@dooc-dev/dooc 0.0.0-stage → 0.0.1

package/dist/viewer/assets.d.ts

@@ -0,0 +1,2 @@
+export declare const prebuilt: boolean;
+export declare const readViewerAsset: (name: string) => Buffer;

package/dist/viewer/assets.js

@@ -0,0 +1,3 @@
+import { readFileSync } from "node:fs";
+export const prebuilt = import.meta.url.endsWith(".js");
+export const readViewerAsset = (name) => readFileSync(new URL(name.startsWith("fonts/") ? `./${name}` : `../../dist/${name}`, import.meta.url));

package/dist/viewer/build.d.ts

@@ -0,0 +1,12 @@
+export interface BuildOptions {
+    format: "html" | "zip";
+    urlPreview?: "embed" | "network";
+}
+/** Build one artifact from the manifest and its managed content. */
+export declare const buildBundle: (root: string, options: BuildOptions) => Promise<{
+    data: Buffer<ArrayBufferLike>;
+    docs: number;
+} | {
+    data: string;
+    docs: number;
+}>;

package/dist/viewer/build.js

@@ -0,0 +1,55 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { bundleEntries } from "../compiler/bundle.js";
+import { embedBundleUrls } from "../compiler/bundle-urls.js";
+import { compileSite } from "../compiler/compile.js";
+import { loadProjectFonts } from "../compiler/fonts.js";
+import { textfilePath } from "../compiler/textfile.js";
+import { zip } from "../compiler/zip.js";
+import { loadSiteLanguages } from "./languages.js";
+/** Build one artifact from the manifest and its managed content. */
+export const buildBundle = async (root, options) => {
+    const { format } = options;
+    const urlPreview = options.urlPreview ?? "embed";
+    if (format !== "html" && format !== "zip")
+        throw new Error("build format must be html | zip");
+    if (urlPreview !== "embed" && urlPreview !== "network")
+        throw new Error("--url_preview must be embed | network");
+    const validate = (path) => {
+        const compiled = compileSite(path);
+        if (compiled.errors.length)
+            throw new Error(`Content validation failed:\n${compiled.errors.join("\n")}`);
+        return compiled;
+    };
+    let compiled = validate(root);
+    let entries = format === "zip" || urlPreview === "embed" ? bundleEntries(root) : [];
+    if (urlPreview === "embed") {
+        entries = await embedBundleUrls(root, entries);
+        const temp = mkdtempSync(join(tmpdir(), "dooc-bundle-"));
+        try {
+            for (const entry of entries) {
+                const path = textfilePath(temp, entry.name);
+                mkdirSync(dirname(path), { recursive: true });
+                writeFileSync(path, entry.data);
+            }
+            compiled = validate(temp);
+        }
+        finally {
+            rmSync(temp, { recursive: true, force: true });
+        }
+    }
+    if (format === "zip")
+        return { data: zip(entries), docs: compiled.docs.length };
+    const config = await loadSiteLanguages(root);
+    const { bundleClient, publishHtml, siteFrom } = await import("./serve.js");
+    return {
+        data: publishHtml({
+            ...siteFrom(compiled, config.languages),
+            fonts: loadProjectFonts(root),
+            codeLanguages: config.codeLanguages,
+            codeGrammars: config.codeGrammars,
+        }, await bundleClient("core/schema-graph-global.tsx", true), undefined, await bundleClient("viewer/code-highlight.ts", true), urlPreview === "embed" ? "static" : "network"),
+        docs: compiled.docs.length,
+    };
+};

package/dist/viewer/bundle-network.d.ts

@@ -0,0 +1,2 @@
+/** Self-contained: standalone bundles cannot rely on the local viewer API. */
+export declare const mountBundleNetwork: () => void;

package/dist/viewer/bundle-network.js

@@ -0,0 +1,88 @@
+/** Self-contained: standalone bundles cannot rely on the local viewer API. */
+export const mountBundleNetwork = () => {
+    const load = async (host) => {
+        if (host.dataset.loaded)
+            return;
+        host.dataset.loaded = "true";
+        const source = host.dataset.embedUrl;
+        if (!source)
+            return;
+        const url = new URL(source);
+        const path = url.pathname.toLowerCase();
+        const label = host.textContent || source;
+        const link = host.querySelector("a");
+        const failure = () => {
+            if (link && !host.contains(link))
+                host.append(link);
+            const status = document.createElement("p");
+            status.setAttribute("role", "status");
+            status.textContent = "Could not load this URL. Open the source link to view it.";
+            host.append(status);
+        };
+        try {
+            if (url.protocol !== "https:" || url.username || url.password)
+                throw new Error();
+            if (/\.(png|jpe?g|webp|gif|svg)$/.test(path)) {
+                const image = document.createElement("img");
+                image.alt = label;
+                image.referrerPolicy = "no-referrer";
+                image.style.maxWidth = "100%";
+                image.onerror = failure;
+                image.src = source;
+                host.replaceChildren(image);
+            }
+            else if (/\.(mp4|webm)$/.test(path)) {
+                const video = document.createElement("video");
+                video.controls = true;
+                video.preload = "metadata";
+                video.style.maxWidth = "100%";
+                video.onerror = failure;
+                video.src = source;
+                host.replaceChildren(video);
+            }
+            else if (/\.(txt|md|markdown|csv|tsv|json|yaml|yml|toml|xml|css|[cm]?js|[jt]sx?|py|rs|go|sh|sql)$/.test(path)) {
+                const response = await fetch(source, {
+                    credentials: "omit",
+                    referrerPolicy: "no-referrer",
+                    signal: AbortSignal.timeout(10000),
+                });
+                if (!response.ok)
+                    throw new Error();
+                const code = document.createElement("code");
+                const text = await response.text();
+                const range = /^#L([1-9]\d*)(?:-L([1-9]\d*))?$/.exec(url.hash);
+                code.textContent = range
+                    ? text
+                        .split(/\r\n|\n|\r/)
+                        .slice(Number(range[1]) - 1, Number(range[2] ?? range[1]))
+                        .join("\n")
+                    : text;
+                const pre = document.createElement("pre");
+                pre.style.cssText = "overflow:auto;white-space:pre-wrap";
+                pre.append(code);
+                host.replaceChildren(pre);
+            }
+            else {
+                const frame = document.createElement("iframe");
+                frame.title = label;
+                frame.sandbox.add("allow-scripts");
+                frame.referrerPolicy = "no-referrer";
+                frame.style.cssText = "width:100%;height:400px;border:0";
+                frame.src = source;
+                host.prepend(frame);
+            }
+        }
+        catch {
+            failure();
+        }
+    };
+    const mount = () => {
+        for (const host of document.querySelectorAll(".external-embed[data-embed-url]"))
+            void load(host);
+    };
+    new MutationObserver(mount).observe(document.querySelector("main") ?? document.body, {
+        childList: true,
+        subtree: true,
+    });
+    mount();
+};

package/dist/viewer/code-file.d.ts

@@ -0,0 +1,20 @@
+import type { PreviewSettings } from "../core/previewers.js";
+export declare const codeFileResponse: (root: string, input: Record<string, unknown> | undefined, previews?: PreviewSettings) => {
+    status: number;
+    body: {
+        error: string;
+        file?: undefined;
+        change?: undefined;
+    };
+} | {
+    status: number;
+    body: {
+        file: string;
+        change: {
+            from: number;
+            to: number;
+            insert: string;
+        };
+        error?: undefined;
+    };
+};

package/dist/viewer/code-file.js

@@ -0,0 +1,42 @@
+import { existsSync } from "node:fs";
+import { readManifest } from "../compiler/manifest.js";
+import { textfilePath, writeTextfile } from "../compiler/textfile.js";
+import { codeFileName, codeFilePlan } from "../core/code-file.js";
+import { isDocId } from "../core/content-metadata.js";
+import { defaultFilePath } from "../core/files.js";
+export const codeFileResponse = (root, input, previews) => {
+    if (typeof input?.body !== "string" || typeof input.position !== "number")
+        return { status: 400, body: { error: "Invalid code file request" } };
+    try {
+        const manifest = readManifest(root);
+        if (manifest.errors.length)
+            throw new Error(manifest.errors.join("\n"));
+        const automatic = input.file === undefined && manifest.files?.defaultLayout !== false;
+        if (automatic && (typeof input.documentId !== "string" || !isDocId(input.documentId)))
+            throw new Error("Invalid document id");
+        if (!automatic && typeof input.file !== "string")
+            throw new Error("File path is required");
+        const target = automatic
+            ? defaultFilePath(codeFileName(input.body, input.position, input.documentId))
+            : input.file;
+        let plan = codeFilePlan(input.body, input.position, target, previews);
+        const create = () => !existsSync(textfilePath(root, plan.file)) &&
+            writeTextfile(root, plan.file, plan.content, null);
+        if (automatic) {
+            for (let index = 2; !create(); index++) {
+                const dot = target.lastIndexOf(".");
+                plan = codeFilePlan(input.body, input.position, `${target.slice(0, dot)}-${index}${target.slice(dot)}`, previews);
+            }
+            return { status: 200, body: { file: plan.file, change: plan.change } };
+        }
+        if (!create())
+            return { status: 409, body: { error: "File already exists" } };
+        return { status: 200, body: { file: plan.file, change: plan.change } };
+    }
+    catch (error) {
+        return {
+            status: 400,
+            body: { error: error instanceof Error ? error.message : String(error) },
+        };
+    }
+};

package/dist/viewer/editor-tools.d.ts

@@ -0,0 +1,38 @@
+export { codeBlockAt } from "../core/markdown.js";
+export declare function isLocalToolRequest(host: string, origin: string | undefined, contentType: string | undefined): boolean;
+export declare function runCodeTool(root: string, body: string, position: number, action: "format" | "lint"): Promise<{
+    change: {
+        from: number;
+        to: number;
+        insert: string;
+    };
+    findings?: undefined;
+} | {
+    findings: {
+        range: [number, number];
+        message: string;
+        ruleId: string;
+    }[];
+    change?: undefined;
+}>;
+export declare function validateCodeTools(root: string, body: string): Promise<{
+    changes: {
+        from: number;
+        to: number;
+        insert: string;
+    }[];
+    findings: {
+        range: [number, number];
+        message: string;
+        ruleId: string;
+    }[];
+}>;
+/** Apply the same registered formatter/linter to a complete file without writing to disk. */
+export declare function validateTextfileCode(root: string, language: string, content: string): Promise<{
+    content: string;
+    findings: {
+        range: [number, number];
+        message: string;
+        ruleId: string;
+    }[];
+}>;

package/dist/viewer/editor-tools.js

@@ -0,0 +1,211 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { visit } from "unist-util-visit";
+import { codeBlockAt, offsetAt, parseMdast } from "../core/markdown.js";
+export { codeBlockAt } from "../core/markdown.js";
+import { formatMarkdown } from "../compiler/format.js";
+export function isLocalToolRequest(host, origin, contentType) {
+    return (["localhost", "127.0.0.1", "[::1]"].includes(host.replace(/:\d+$/, "")) &&
+        origin === `http://${host}` &&
+        contentType?.split(";")[0]?.trim() === "application/json");
+}
+function command(value) {
+    if (!Array.isArray(value) ||
+        !value.length ||
+        value.some((v) => typeof v !== "string" || v.includes("\0")) ||
+        !value[0]) {
+        throw new Error("Tool command must be a nonempty array of strings");
+    }
+    return value;
+}
+function execute(args, cwd, input, lint) {
+    return new Promise((resolve, reject) => {
+        const child = execFile(args[0], args.slice(1), {
+            cwd,
+            timeout: 10_000,
+            killSignal: "SIGKILL",
+            maxBuffer: 1024 * 1024,
+            encoding: "utf8",
+        }, (error, stdout, stderr) => {
+            if (error && !(lint && error.code === 1 && !error.killed)) {
+                reject(new Error(stderr.trim().slice(0, 2000) || error.message));
+            }
+            else
+                resolve(stdout);
+        });
+        child.stdin?.on("error", () => {
+            /* Process exit is handled by execFile. */
+        });
+        child.stdin?.end(input);
+    });
+}
+export async function runCodeTool(root, body, position, action) {
+    const block = codeBlockAt(body, position);
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_+-]*$/.test(block.language))
+        throw new Error("Unsupported code language identifier");
+    const path = join(root, ".dooc", "editor-tools", `${block.language}.json`);
+    let config;
+    try {
+        config = JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        throw new Error(`Create .dooc/editor-tools/${block.language}.json to configure this language`);
+    }
+    if (!config || typeof config !== "object")
+        throw new Error("Invalid editor tool configuration");
+    const output = await execute(command(config[action === "format" ? "formatter" : "linter"]), root, `${block.code}\n`, action === "lint");
+    if (action === "format") {
+        const normalized = output.replace(/\r\n/g, "\n").replace(/\n$/, "");
+        if (!normalized && block.code.trim())
+            throw new Error("Formatter returned empty output; code was kept unchanged");
+        const lines = normalized ? normalized.split("\n") : [];
+        const fence = new RegExp(`^ {0,3}${block.marker[0]}{${block.marker.length},}[ \\t]*$`);
+        if (lines.some((line) => fence.test(line)))
+            throw new Error("Formatter output would close the code fence");
+        return {
+            change: {
+                from: block.from,
+                to: block.to,
+                insert: lines.map((line) => block.indent + line + block.eol).join(""),
+            },
+        };
+    }
+    const diagnostics = JSON.parse(output);
+    if (!Array.isArray(diagnostics))
+        throw new Error("Linter must return a JSON array");
+    const lines = block.code.split("\n");
+    const at = (line, column) => {
+        if (typeof line !== "number" ||
+            typeof column !== "number" ||
+            !Number.isInteger(line) ||
+            !Number.isInteger(column) ||
+            line < 1 ||
+            line > block.offsets.length ||
+            column < 1 ||
+            column > (lines[line - 1]?.length ?? 0) + 1)
+            throw new Error("Invalid diagnostic position");
+        return (block.offsets[line - 1] ?? block.from) + column - 1;
+    };
+    const findings = diagnostics.map((d) => {
+        if (!d || typeof d !== "object" || !("message" in d) || typeof d.message !== "string")
+            throw new Error("Invalid diagnostic");
+        const item = d;
+        const from = at(item.line, item.column);
+        const to = item.endLine == null && item.endColumn == null
+            ? Math.min(from + 1, block.to)
+            : at(item.endLine, item.endColumn);
+        if (to < from)
+            throw new Error("Invalid diagnostic range");
+        const severity = item.severity ?? "warning";
+        if (!["error", "warning", "info"].includes(String(severity)))
+            throw new Error("Invalid diagnostic severity");
+        return {
+            range: [from, to],
+            message: d.message,
+            ruleId: String(severity),
+        };
+    });
+    return { findings };
+}
+export async function validateCodeTools(root, body) {
+    const original = body;
+    const configuredBlocks = async (text, tool) => {
+        const blocks = [];
+        const nodes = [];
+        visit(parseMdast(text), (node) => {
+            if (node.type === "code")
+                nodes.push(node);
+        });
+        for (const node of nodes) {
+            if (node.position) {
+                const position = offsetAt(text, node.position.start.line, node.position.start.column);
+                if (/^ {0,3}(`{3,}|~{3,})/.test(text.slice(position))) {
+                    codeBlockAt(text, position);
+                }
+            }
+            if (node.type !== "code" ||
+                node.position?.start.offset == null ||
+                !node.lang ||
+                !/^[a-zA-Z0-9][a-zA-Z0-9_+-]*$/.test(node.lang))
+                continue;
+            let raw;
+            try {
+                raw = await readFile(join(root, ".dooc/editor-tools", `${node.lang}.json`), "utf8");
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            const config = JSON.parse(raw);
+            if (!config || typeof config !== "object")
+                throw new Error("Invalid editor tool configuration");
+            if (config[tool] != null)
+                blocks.push(offsetAt(text, node.position.start.line, node.position.start.column));
+        }
+        return blocks;
+    };
+    const originalFindings = [];
+    for (const position of await configuredBlocks(body, "linter")) {
+        const result = await runCodeTool(root, body, position, "lint");
+        originalFindings.push(...(result.findings ?? []));
+    }
+    if (originalFindings.some((finding) => finding.ruleId === "error")) {
+        return { changes: [], findings: originalFindings };
+    }
+    for (const position of (await configuredBlocks(body, "formatter")).reverse()) {
+        const { change } = await runCodeTool(root, body, position, "format");
+        if (change && body.slice(change.from, change.to) !== change.insert) {
+            body = body.slice(0, change.from) + change.insert + body.slice(change.to);
+        }
+    }
+    body = formatMarkdown(body);
+    if (body === original)
+        return { changes: [], findings: originalFindings };
+    const findings = [];
+    for (const position of await configuredBlocks(body, "linter")) {
+        const result = await runCodeTool(root, body, position, "lint");
+        findings.push(...(result.findings ?? []));
+    }
+    if (findings.some((finding) => finding.ruleId === "error")) {
+        throw new Error("Formatted code failed validation; code was kept unchanged");
+    }
+    let from = 0;
+    while (from < original.length && from < body.length && original[from] === body[from])
+        from++;
+    let to = original.length;
+    let end = body.length;
+    while (to > from && end > from && original[to - 1] === body[end - 1]) {
+        to--;
+        end--;
+    }
+    return {
+        changes: from === to && from === end ? [] : [{ from, to, insert: body.slice(from, end) }],
+        findings,
+    };
+}
+/** Apply the same registered formatter/linter to a complete file without writing to disk. */
+export async function validateTextfileCode(root, language, content) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_+-]*$/.test(language) || content.includes("\0"))
+        throw new Error("Invalid text file tool request");
+    const eol = content.includes("\r\n") ? "\r\n" : "\n";
+    const marker = "`".repeat([...content.matchAll(/`+/g)].reduce((length, match) => Math.max(length, match[0].length + 1), 3));
+    const prefix = `${marker}${language}${eol}`;
+    const separator = content && !content.endsWith("\n") ? eol : "";
+    let body = `${prefix}${content}${separator}${marker}${eol}`;
+    const result = await validateCodeTools(root, body);
+    for (const change of [...result.changes].reverse())
+        body = body.slice(0, change.from) + change.insert + body.slice(change.to);
+    const block = codeBlockAt(body, 0);
+    let formatted = body.slice(block.from, block.to);
+    if (separator)
+        formatted = formatted.replace(/\r?\n$/, "");
+    return {
+        content: formatted,
+        findings: result.findings.map((finding) => ({
+            ...finding,
+            range: finding.range.map((offset) => Math.max(0, Math.min(formatted.length, offset - block.from))),
+        })),
+    };
+}

package/dist/viewer/file-references.d.ts

@@ -0,0 +1,14 @@
+import type { PreviewSettings } from "../core/previewers.js";
+export interface FileReference {
+    line: number;
+    file: string;
+    kind: "textfile" | "figure" | "html" | "term";
+}
+/** Use the compiler's Markdown grammar so examples, escapes and URL encodings agree. */
+export declare const fileReferences: (body: string, settings?: PreviewSettings) => FileReference[];
+export interface FilePreview {
+    state: "pending" | "loading" | "valid" | "error";
+    message?: string;
+}
+/** An empty list means that this file compiled successfully. */
+export type FilePreviewResults = Record<string, string[]>;

package/dist/viewer/file-references.js

@@ -0,0 +1,38 @@
+import { visit } from "unist-util-visit";
+import { parseFileEmbed } from "../core/file-embed.js";
+import { contentLinks, embeddedImages, parseMdast } from "../core/markdown.js";
+import { parseTermReference } from "../core/term-reference.js";
+/** Use the compiler's Markdown grammar so examples, escapes and URL encodings agree. */
+export const fileReferences = (body, settings) => {
+    const root = parseMdast(body);
+    const images = new Set(embeddedImages(root));
+    const references = [];
+    for (const node of contentLinks(root)) {
+        try {
+            const file = parseTermReference(node.url);
+            if (file)
+                references.push({ line: node.position?.start.line ?? 1, file, kind: "term" });
+        }
+        catch {
+            /* The compiler reports invalid paths. */
+        }
+    }
+    visit(root, (node) => {
+        if (node.type === "image" && images.has(node)) {
+            try {
+                const { file, kind } = parseFileEmbed(node.url, settings);
+                if (kind === "external")
+                    return;
+                references.push({
+                    line: node.position?.start.line ?? 1,
+                    file: file.replace(/^(\.\/)+/, ""),
+                    kind,
+                });
+            }
+            catch {
+                // The compiler reports invalid URLs; no editor should open for them.
+            }
+        }
+    });
+    return references.sort((a, b) => a.line - b.line);
+};

package/dist/viewer/font-picker.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectFont } from "../compiler/fonts.js";
+import type { createFontSettings } from "./font-settings.js";
+/** Self-contained because published viewers embed this function directly. */
+export declare const mountFontPickers: (createSettings: typeof createFontSettings, registered: readonly ProjectFont[]) => Promise<void>;