kcode_k1_web_code_document/

lib.rs

use kcode_k1_web_package::{PackageError, SourceFile, SourcePackage, WebId};
use serde::{Deserialize, Serialize};
use std::{
    fmt::{Display, Formatter},
    ops::Range,
};

const HTML_ENTRY: &str = "const frame=document.createElement(\"iframe\");\nframe.hidden=true;\nframe.src=new URL(\"./Code.html\",import.meta.url).href;\ndocument.body.append(frame);\nawait new Promise((resolve,reject)=>{frame.addEventListener(\"load\",resolve,{once:true});frame.addEventListener(\"error\",()=>reject(new Error(\"Code.html failed to load\")),{once:true});});\nexport const codeWindow=frame.contentWindow;\n";
const HTML_TESTS: &str = "import {codeWindow} from \"./k1-entry.js\";\nexport async function runTests(){const test=codeWindow.globalThis.runTests;if(typeof test!==\"function\")throw new Error(\"Code.html must define globalThis.runTests\");return await test.call(codeWindow);}\n";
const CSS_ENTRY: &str = "const link=document.createElement(\"link\");\nlink.rel=\"stylesheet\";\nlink.href=new URL(\"./Code.css\",import.meta.url).href;\ndocument.head.append(link);\nawait new Promise((resolve,reject)=>{link.addEventListener(\"load\",resolve,{once:true});link.addEventListener(\"error\",()=>reject(new Error(\"Code.css failed to load\")),{once:true});});\nexport const sheet=link.sheet;\nvoid sheet.cssRules;\n";
const CSS_TESTS: &str = "import {sheet} from \"./k1-entry.js\";\nexport async function runTests(){void sheet.cssRules;}\n";

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum Language {
    JavaScript,
    Html,
    Css,
}
impl Language {
    pub const fn code_path(self) -> &'static str {
        match self {
            Self::JavaScript => "Code.js",
            Self::Html => "Code.html",
            Self::Css => "Code.css",
        }
    }
}

#[derive(Clone, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Dependency {
    authority: String,
    name: String,
    selector: String,
}
impl Dependency {
    pub fn authority(&self) -> &str {
        &self.authority
    }
    pub fn name(&self) -> &str {
        &self.name
    }
    pub fn selector(&self) -> &str {
        &self.selector
    }
}
#[derive(Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct Header {
    dependencies: Vec<Dependency>,
}
#[derive(Serialize)]
struct Manifest<'a> {
    name: &'a str,
    version: String,
    entry: &'a str,
    tests: &'a str,
    dependencies: Vec<&'a Dependency>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DocumentError(String);
impl DocumentError {
    pub fn message(&self) -> &str {
        &self.0
    }
}
impl Display for DocumentError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.0)
    }
}
impl std::error::Error for DocumentError {}
impl From<PackageError> for DocumentError {
    fn from(value: PackageError) -> Self {
        Self(value.to_string())
    }
}
fn fail<T>(message: impl Into<String>) -> Result<T, DocumentError> {
    Err(DocumentError(message.into()))
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CodeDocument {
    id: WebId,
    documentation: Vec<u8>,
    language: Language,
    code: Vec<u8>,
    dependencies: Vec<Dependency>,
}
impl CodeDocument {
    pub fn new(
        id: WebId,
        documentation: Vec<u8>,
        language: Language,
        code: Vec<u8>,
    ) -> Result<Self, DocumentError> {
        let dependencies = parse_header(&documentation)?;
        std::str::from_utf8(&code).map_err(|_| DocumentError("code must be UTF-8".into()))?;
        let value = Self {
            id,
            documentation,
            language,
            code,
            dependencies,
        };
        value.to_source_package()?;
        Ok(value)
    }
    pub fn id(&self) -> &WebId {
        &self.id
    }
    pub fn documentation(&self) -> &[u8] {
        &self.documentation
    }
    pub const fn language(&self) -> Language {
        self.language
    }
    pub fn code(&self) -> &[u8] {
        &self.code
    }
    pub fn dependencies(&self) -> &[Dependency] {
        &self.dependencies
    }
    pub fn to_source_package(&self) -> Result<SourcePackage, DocumentError> {
        let (entry, tests) = if self.language == Language::JavaScript {
            ("Code.js", "Code.js")
        } else {
            ("k1-entry.js", "k1-tests.js")
        };
        let mut dependencies = self.dependencies.iter().collect::<Vec<_>>();
        dependencies.sort_by(|a, b| {
            (&a.authority, &a.name, &a.selector).cmp(&(&b.authority, &b.name, &b.selector))
        });
        let manifest = Manifest {
            name: self.id.family().logical_name(),
            version: self.id.version().to_string(),
            entry,
            tests,
            dependencies,
        };
        let mut files = vec![
            SourceFile::new("Documentation.md", self.documentation.clone()),
            SourceFile::new(self.language.code_path(), self.code.clone()),
            SourceFile::new(
                "k1-web.json",
                serde_json::to_vec(&manifest).map_err(|e| DocumentError(e.to_string()))?,
            ),
        ];
        match self.language {
            Language::JavaScript => {}
            Language::Html => {
                files.push(SourceFile::new(
                    "k1-entry.js",
                    HTML_ENTRY.as_bytes().to_vec(),
                ));
                files.push(SourceFile::new(
                    "k1-tests.js",
                    HTML_TESTS.as_bytes().to_vec(),
                ));
            }
            Language::Css => {
                files.push(SourceFile::new(
                    "k1-entry.js",
                    CSS_ENTRY.as_bytes().to_vec(),
                ));
                files.push(SourceFile::new(
                    "k1-tests.js",
                    CSS_TESTS.as_bytes().to_vec(),
                ));
            }
        }
        SourcePackage::new(self.id.clone(), files).map_err(Into::into)
    }
    pub fn from_source_package(source: &SourcePackage) -> Result<Self, DocumentError> {
        let documentation = source
            .files()
            .iter()
            .find(|f| f.path() == "Documentation.md")
            .ok_or_else(|| DocumentError("noncanonical code-document projection".into()))?
            .bytes()
            .to_vec();
        for language in [Language::JavaScript, Language::Html, Language::Css] {
            let Some(file) = source
                .files()
                .iter()
                .find(|f| f.path() == language.code_path())
            else {
                continue;
            };
            let Ok(value) = Self::new(
                source.id().clone(),
                documentation.clone(),
                language,
                file.bytes().to_vec(),
            ) else {
                continue;
            };
            if value
                .to_source_package()
                .is_ok_and(|made| made.files() == source.files())
            {
                return Ok(value);
            }
        }
        fail("noncanonical code-document projection")
    }
    pub fn chunk_ranges(&self) -> Vec<Range<usize>> {
        let text = std::str::from_utf8(&self.code).expect("CodeDocument maintains UTF-8");
        let points = match self.language {
            Language::JavaScript => js_points(text),
            Language::Css => css_points(text),
            Language::Html => html_points(text),
        };
        points.map_or_else(|| whole(self.code.len()), |p| pack(text, p))
    }
}

fn parse_header(bytes: &[u8]) -> Result<Vec<Dependency>, DocumentError> {
    let text = std::str::from_utf8(bytes)
        .map_err(|_| DocumentError("Documentation.md must be UTF-8".into()))?;
    let rest = text
        .strip_prefix("<!-- k1-web/v1\n")
        .ok_or_else(|| DocumentError("missing exact documentation header".into()))?;
    let (json, rest) = rest
        .split_once('\n')
        .ok_or_else(|| DocumentError("incomplete documentation header".into()))?;
    if !(rest == "-->" || rest.starts_with("-->\n")) {
        return fail("documentation header must end with an exact --> line");
    }
    let header: Header = serde_json::from_str(json)
        .map_err(|e| DocumentError(format!("invalid documentation header: {e}")))?;
    if serde_json::to_string(&header).map_err(|e| DocumentError(e.to_string()))? != json {
        return fail("documentation header JSON must be canonical and compact");
    }
    if header
        .dependencies
        .iter()
        .any(|d| d.authority.is_empty() || d.name.is_empty() || d.selector.is_empty())
    {
        return fail("dependency fields must be nonempty");
    }
    let mut unique = header.dependencies.clone();
    unique.sort();
    unique.dedup();
    if unique.len() != header.dependencies.len() {
        return fail("duplicate dependency declaration");
    }
    Ok(header.dependencies)
}

fn whole(len: usize) -> Vec<Range<usize>> {
    std::iter::once(0..len).collect()
}
fn pack(text: &str, mut points: Vec<usize>) -> Vec<Range<usize>> {
    if text.is_empty() {
        return whole(0);
    }
    if text.chars().count() < 800 {
        return whole(text.len());
    }
    points.push(0);
    points.push(text.len());
    points.sort_unstable();
    points.dedup();
    let mut out = Vec::new();
    let mut start = 0;
    while start < text.len() {
        let end = points
            .iter()
            .copied()
            .filter(|&p| p > start)
            .find(|&p| {
                text[start..p].chars().count() >= 800
                    && (p == text.len() || text[p..].chars().count() >= 800)
            })
            .unwrap_or(text.len());
        out.push(start..end);
        start = end;
    }
    out
}

#[derive(Clone, Copy)]
enum Brace {
    Class(bool),
    Function,
    Member,
    Other,
}
fn js_points(text: &str) -> Option<Vec<usize>> {
    let b = text.as_bytes();
    let mut out = vec![0];
    let (mut i, mut paren, mut bracket) = (0, 0usize, 0usize);
    let mut braces = Vec::new();
    let mut pending = None;
    let mut regex = true;
    let mut statement = true;
    let mut last = 0;
    while i < b.len() {
        match b[i] {
            b'\'' | b'"' => {
                i = skip_quote(b, i)?;
                regex = false;
                statement = false;
            }
            b'`' => {
                i = skip_template(b, i)?;
                regex = false;
                statement = false;
            }
            b'/' if b.get(i + 1) == Some(&b'/') => {
                i = b[i + 2..]
                    .iter()
                    .position(|&c| c == b'\n')
                    .map_or(b.len(), |n| i + n + 3);
            }
            b'/' if b.get(i + 1) == Some(&b'*') => {
                i = find_bytes(b, i + 2, b"*/")? + 2;
            }
            b'/' if regex => {
                i = skip_regex(b, i)?;
                regex = false;
                statement = false;
            }
            c if ident_start(c) => {
                let start = i;
                i += 1;
                while i < b.len() && ident_continue(b[i]) {
                    i += 1;
                }
                let word = &text[start..i];
                if word == "class" {
                    pending = Some(Brace::Class(statement));
                }
                if word == "function" && statement {
                    pending = Some(Brace::Function);
                }
                regex = matches!(
                    word,
                    "return"
                        | "throw"
                        | "case"
                        | "delete"
                        | "void"
                        | "typeof"
                        | "new"
                        | "yield"
                        | "await"
                        | "else"
                        | "do"
                        | "in"
                        | "of"
                        | "instanceof"
                );
                if !matches!(word, "export" | "default" | "async") {
                    statement = false;
                }
                last = b'x';
            }
            b'(' => {
                paren += 1;
                i += 1;
                regex = true;
                last = b'(';
            }
            b')' => {
                paren = paren.checked_sub(1)?;
                i += 1;
                regex = false;
                last = b')';
            }
            b'[' => {
                bracket += 1;
                i += 1;
                regex = true;
                last = b'[';
            }
            b']' => {
                bracket = bracket.checked_sub(1)?;
                i += 1;
                regex = false;
                last = b']';
            }
            b'{' => {
                let kind = if paren == 0 && bracket == 0 {
                    pending.take().unwrap_or_else(|| {
                        if matches!(braces.last(), Some(Brace::Class(_))) && last == b')' {
                            Brace::Member
                        } else {
                            Brace::Other
                        }
                    })
                } else {
                    Brace::Other
                };
                braces.push(kind);
                i += 1;
                regex = true;
                last = b'{';
            }
            b'}' => {
                if paren != 0 || bracket != 0 {
                    return None;
                }
                let kind = braces.pop()?;
                i += 1;
                regex = false;
                last = b'}';
                let boundary = matches!(kind, Brace::Function) && braces.is_empty()
                    || matches!(kind, Brace::Class(true)) && braces.is_empty()
                    || matches!(kind, Brace::Member)
                        && matches!(braces.last(), Some(Brace::Class(_)));
                if boundary {
                    out.push(i);
                    statement = braces.is_empty();
                }
            }
            b';' => {
                i += 1;
                regex = true;
                pending = None;
                if paren == 0
                    && bracket == 0
                    && (braces.is_empty() || matches!(braces.last(), Some(Brace::Class(_))))
                {
                    out.push(i);
                    statement = braces.is_empty();
                }
                last = b';';
            }
            c if c.is_ascii_whitespace() => i += 1,
            c if c.is_ascii_digit() => {
                i += 1;
                while i < b.len() && (ident_continue(b[i]) || b"._".contains(&b[i])) {
                    i += 1;
                }
                regex = false;
                statement = false;
                last = b'n';
            }
            b'/' => {
                i += 1;
                regex = true;
                statement = false;
                last = b'/';
            }
            c => {
                i += 1;
                regex = !matches!(c, b'.');
                if !matches!(c, b',' | b':') {
                    statement = false;
                }
                last = c;
            }
        }
    }
    if paren != 0 || bracket != 0 || !braces.is_empty() {
        None
    } else {
        out.push(b.len());
        Some(out)
    }
}
fn ident_start(c: u8) -> bool {
    c.is_ascii_alphabetic() || matches!(c, b'_' | b'$')
}
fn ident_continue(c: u8) -> bool {
    ident_start(c) || c.is_ascii_digit()
}
fn skip_quote(b: &[u8], mut i: usize) -> Option<usize> {
    let quote = b[i];
    i += 1;
    while i < b.len() {
        match b[i] {
            b'\\' => i = (i + 2).min(b.len()),
            c if c == quote => return Some(i + 1),
            b'\n' | b'\r' => return None,
            _ => i += 1,
        }
    }
    None
}
fn skip_regex(b: &[u8], mut i: usize) -> Option<usize> {
    i += 1;
    let mut class = false;
    while i < b.len() {
        match b[i] {
            b'\\' => i = (i + 2).min(b.len()),
            b'[' => {
                class = true;
                i += 1;
            }
            b']' => {
                class = false;
                i += 1;
            }
            b'/' if !class => {
                i += 1;
                while i < b.len() && b[i].is_ascii_alphabetic() {
                    i += 1;
                }
                return Some(i);
            }
            b'\n' | b'\r' => return None,
            _ => i += 1,
        }
    }
    None
}
fn skip_template(b: &[u8], mut i: usize) -> Option<usize> {
    i += 1;
    while i < b.len() {
        match b[i] {
            b'\\' => i = (i + 2).min(b.len()),
            b'`' => return Some(i + 1),
            b'$' if b.get(i + 1) == Some(&b'{') => i = skip_expression(b, i + 2)?,
            _ => i += 1,
        }
    }
    None
}
fn skip_expression(b: &[u8], mut i: usize) -> Option<usize> {
    let (mut depth, mut paren, mut bracket) = (1usize, 0usize, 0usize);
    let mut regex = true;
    while i < b.len() {
        match b[i] {
            b'\'' | b'"' => {
                i = skip_quote(b, i)?;
                regex = false;
            }
            b'`' => {
                i = skip_template(b, i)?;
                regex = false;
            }
            b'/' if b.get(i + 1) == Some(&b'/') => {
                i = b[i + 2..]
                    .iter()
                    .position(|&c| c == b'\n')
                    .map_or(b.len(), |n| i + n + 3)
            }
            b'/' if b.get(i + 1) == Some(&b'*') => i = find_bytes(b, i + 2, b"*/")? + 2,
            b'/' if regex => {
                i = skip_regex(b, i)?;
                regex = false;
            }
            b'{' => {
                depth += 1;
                i += 1;
                regex = true;
            }
            b'}' => {
                depth -= 1;
                i += 1;
                if depth == 0 {
                    return (paren == 0 && bracket == 0).then_some(i);
                }
                regex = false;
            }
            b'(' => {
                paren += 1;
                i += 1;
                regex = true;
            }
            b')' => {
                paren = paren.checked_sub(1)?;
                i += 1;
                regex = false;
            }
            b'[' => {
                bracket += 1;
                i += 1;
                regex = true;
            }
            b']' => {
                bracket = bracket.checked_sub(1)?;
                i += 1;
                regex = false;
            }
            c if c.is_ascii_whitespace() => i += 1,
            c if ident_continue(c) => {
                i += 1;
                regex = false;
            }
            _ => {
                i += 1;
                regex = true;
            }
        }
    }
    None
}
fn find_bytes(haystack: &[u8], start: usize, needle: &[u8]) -> Option<usize> {
    haystack[start..]
        .windows(needle.len())
        .position(|w| w == needle)
        .map(|n| start + n)
}

fn css_points(text: &str) -> Option<Vec<usize>> {
    let b = text.as_bytes();
    let mut out = vec![0];
    let (mut i, mut braces, mut paren, mut bracket) = (0, 0usize, 0usize, 0usize);
    while i < b.len() {
        match b[i] {
            b'\'' | b'"' => i = skip_quote(b, i)?,
            b'/' if b.get(i + 1) == Some(&b'*') => i = find_bytes(b, i + 2, b"*/")? + 2,
            b'{' => {
                braces += 1;
                i += 1;
            }
            b'}' => {
                braces = braces.checked_sub(1)?;
                i += 1;
                out.push(i);
            }
            b'(' => {
                paren += 1;
                i += 1;
            }
            b')' => {
                paren = paren.checked_sub(1)?;
                i += 1;
            }
            b'[' => {
                bracket += 1;
                i += 1;
            }
            b']' => {
                bracket = bracket.checked_sub(1)?;
                i += 1;
            }
            b';' if braces == 0 && paren == 0 && bracket == 0 => {
                i += 1;
                out.push(i);
            }
            _ => i += 1,
        }
    }
    if braces + paren + bracket == 0 {
        out.push(b.len());
        Some(out)
    } else {
        None
    }
}

fn html_points(text: &str) -> Option<Vec<usize>> {
    let b = text.as_bytes();
    let mut out = vec![0];
    let mut stack: Vec<String> = Vec::new();
    let mut i = 0;
    while i < b.len() {
        if b[i] != b'<' {
            i = b[i..]
                .iter()
                .position(|&c| c == b'<')
                .map_or(b.len(), |n| i + n);
            out.push(i);
            continue;
        }
        if starts_ci(b, i, b"<!--") {
            i = find_bytes(b, i + 4, b"-->")? + 3;
            out.push(i);
            continue;
        }
        if starts_ci(b, i, b"</") {
            let (name, end) = close_tag(b, i)?;
            if stack.pop().as_deref() != Some(&name) {
                return None;
            }
            i = end;
            out.push(i);
            continue;
        }
        if starts_ci(b, i, b"<!") || starts_ci(b, i, b"<?") {
            i = tag_end(b, i + 2)?;
            out.push(i);
            continue;
        }
        let (name, end, closed, script_type) = start_tag(b, i)?;
        if !closed && (name == "script" || name == "style") {
            let (raw_end, close_end) = raw_close(b, end, &name)?;
            let raw = std::str::from_utf8(&b[end..raw_end]).ok()?;
            let points = if name == "style" {
                css_points(raw)?
            } else if script_type.as_deref().is_none_or(is_javascript_type) {
                js_points(raw)?
            } else {
                vec![0, raw.len()]
            };
            out.extend(
                points
                    .into_iter()
                    .filter(|&p| p > 0 && p < raw.len())
                    .map(|p| end + p),
            );
            i = close_end;
            out.push(i);
            continue;
        }
        i = end;
        if closed || is_void(&name) {
            out.push(i);
        } else {
            stack.push(name);
        }
    }
    if stack.is_empty() {
        out.push(b.len());
        Some(out)
    } else {
        None
    }
}
fn starts_ci(b: &[u8], at: usize, needle: &[u8]) -> bool {
    b.get(at..at + needle.len())
        .is_some_and(|v| v.eq_ignore_ascii_case(needle))
}
fn tag_end(b: &[u8], mut i: usize) -> Option<usize> {
    let mut quote = None;
    while i < b.len() {
        let c = b[i];
        if let Some(q) = quote {
            if c == q {
                quote = None;
            }
        } else if matches!(c, b'\'' | b'"') {
            quote = Some(c);
        } else if c == b'>' {
            return Some(i + 1);
        }
        i += 1;
    }
    None
}
fn start_tag(b: &[u8], at: usize) -> Option<(String, usize, bool, Option<String>)> {
    let mut i = at + 1;
    let start = i;
    while i < b.len() && (ident_continue(b[i]) || matches!(b[i], b':' | b'-')) {
        i += 1;
    }
    if i == start {
        return None;
    }
    let name = std::str::from_utf8(&b[start..i]).ok()?.to_ascii_lowercase();
    let mut kind = None;
    loop {
        while b.get(i).is_some_and(u8::is_ascii_whitespace) {
            i += 1;
        }
        if b.get(i) == Some(&b'>') {
            return Some((name, i + 1, false, kind));
        }
        if b.get(i) == Some(&b'/') && b.get(i + 1) == Some(&b'>') {
            return Some((name, i + 2, true, kind));
        }
        let a = i;
        while i < b.len() && (ident_continue(b[i]) || matches!(b[i], b':' | b'-')) {
            i += 1;
        }
        if i == a {
            return None;
        }
        let attr = std::str::from_utf8(&b[a..i]).ok()?.to_ascii_lowercase();
        while b.get(i).is_some_and(u8::is_ascii_whitespace) {
            i += 1;
        }
        let mut value = "";
        if b.get(i) == Some(&b'=') {
            i += 1;
            while b.get(i).is_some_and(u8::is_ascii_whitespace) {
                i += 1;
            }
            let q = *b.get(i)?;
            let v;
            if matches!(q, b'\'' | b'"') {
                i += 1;
                v = i;
                while b.get(i).is_some_and(|&c| c != q) {
                    i += 1;
                }
                value = std::str::from_utf8(&b[v..i]).ok()?;
                i += 1;
            } else {
                v = i;
                while b
                    .get(i)
                    .is_some_and(|c| !c.is_ascii_whitespace() && !matches!(c, b'>' | b'/'))
                {
                    i += 1;
                }
                value = std::str::from_utf8(&b[v..i]).ok()?;
            }
        }
        if attr == "type" {
            kind = Some(value.trim().to_ascii_lowercase());
        }
    }
}
fn close_tag(b: &[u8], at: usize) -> Option<(String, usize)> {
    let mut i = at + 2;
    let start = i;
    while i < b.len() && (ident_continue(b[i]) || matches!(b[i], b':' | b'-')) {
        i += 1;
    }
    let name = std::str::from_utf8(&b[start..i]).ok()?.to_ascii_lowercase();
    while b.get(i).is_some_and(u8::is_ascii_whitespace) {
        i += 1;
    }
    (b.get(i) == Some(&b'>') && !name.is_empty()).then_some((name, i + 1))
}
fn raw_close(b: &[u8], mut i: usize, name: &str) -> Option<(usize, usize)> {
    while i < b.len() {
        let n = b[i..].iter().position(|&c| c == b'<')? + i;
        if starts_ci(b, n, b"</")
            && let Some((found, end)) = close_tag(b, n)
            && found == name
        {
            return Some((n, end));
        }
        i = n + 1;
    }
    None
}
fn is_javascript_type(value: &str) -> bool {
    matches!(
        value,
        "" | "module"
            | "text/javascript"
            | "application/javascript"
            | "text/ecmascript"
            | "application/ecmascript"
    )
}
fn is_void(name: &str) -> bool {
    matches!(
        name,
        "area"
            | "base"
            | "br"
            | "col"
            | "embed"
            | "hr"
            | "img"
            | "input"
            | "link"
            | "meta"
            | "param"
            | "source"
            | "track"
            | "wbr"
    )
}