@dooc-dev/dooc 0.0.0-stage → 0.0.2

package/dist/viewer/extensions.js

@@ -0,0 +1,302 @@
+import { createHash } from "node:crypto";
+import { lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { inflateRawSync } from "node:zlib";
+import { textfilePath } from "../compiler/textfile.js";
+import { zip } from "../compiler/zip.js";
+import { extensionFile, extensionManifest, MAX_EXTENSION_BYTES, readExtensionZip, } from "../core/extension-package.js";
+import { validateViewerPlugins, } from "./plugin-config.js";
+export const EXTENSIONS_DIR = ".dooc/plugins";
+const hash = (source) => createHash("sha256").update(source).digest("hex");
+const unpack = (data) => readExtensionZip(data, async (bytes, size) => inflateRawSync(bytes, { maxOutputLength: Math.max(1, size) }));
+/** ZIPs found on disk stay inactive until the browser approves their exact content hash. */
+export const createExtensionManager = (root, registry, initial, personal) => {
+    const active = new Map();
+    const scope = createHash("sha256").update(realpathSync(root)).digest("hex");
+    const approvalFile = `extensions-${scope}.json`;
+    const approval = () => {
+        const value = personal?.read(approvalFile);
+        return value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : {};
+    };
+    const remember = (file, revision) => {
+        if (!personal)
+            return;
+        const approved = approval();
+        if (revision)
+            approved[file] = revision;
+        else
+            delete approved[file];
+        personal.write(approvalFile, approved);
+    };
+    let queued = Promise.resolve();
+    const directory = () => {
+        for (const name of [".dooc", EXTENSIONS_DIR]) {
+            const entry = lstatSync(join(root, name), { throwIfNoEntry: false });
+            if (entry && (!entry.isDirectory() || entry.isSymbolicLink()))
+                throw new Error("Plugin folders must be local directories");
+        }
+        return textfilePath(root, EXTENSIONS_DIR);
+    };
+    const read = (name) => {
+        const path = join(directory(), name);
+        const entry = lstatSync(path, { throwIfNoEntry: false });
+        if (!entry)
+            return null;
+        if (!entry.isFile() || entry.isSymbolicLink() || entry.size > MAX_EXTENSION_BYTES)
+            throw new Error("Expected a plugin ZIP smaller than 16 MiB");
+        return readFileSync(path);
+    };
+    const disable = (name) => {
+        const value = active.get(name);
+        if (!value)
+            return;
+        for (const plugin of value.config.plugins)
+            if (!registry.configuration || registry.configuration().plugins.includes(plugin))
+                registry.unregister(plugin.id);
+        rmSync(value.directory, { recursive: true, force: true });
+        active.delete(name);
+    };
+    const list = async () => {
+        const path = directory();
+        const entries = lstatSync(path, { throwIfNoEntry: false })
+            ? readdirSync(path, { withFileTypes: true })
+            : [];
+        const items = [];
+        for (const entry of entries.filter((entry) => entry.isFile() && entry.name.endsWith(".zip"))) {
+            let file;
+            try {
+                file = extensionFile(entry.name);
+            }
+            catch {
+                continue;
+            }
+            const data = read(file);
+            if (!data)
+                continue;
+            const revision = hash(data);
+            const loaded = active.get(file);
+            if (loaded &&
+                (loaded.hash !== revision ||
+                    (registry.configuration &&
+                        loaded.config.plugins.some((plugin) => !registry.configuration?.().plugins.includes(plugin)))))
+                disable(file);
+            try {
+                const pkg = await unpack(data);
+                items.push({
+                    file,
+                    name: pkg.name,
+                    icon: pkg.icon ??
+                        active.get(file)?.config.plugins.find((plugin) => plugin.icon)?.icon,
+                    version: pkg.version,
+                    hash: revision,
+                    size: data.length,
+                    enabled: active.has(file),
+                    plugins: active.get(file)?.config.plugins.map((plugin) => plugin.id) ?? [],
+                });
+            }
+            catch (error) {
+                disable(file);
+                items.push({
+                    file,
+                    name: file,
+                    version: "",
+                    hash: revision,
+                    size: data.length,
+                    enabled: false,
+                    plugins: [],
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        for (const name of active.keys())
+            if (!items.some((item) => item.file === name))
+                disable(name);
+        const owned = new Set([...active.values()].flatMap((value) => value.config.plugins));
+        for (const plugin of (registry.configuration?.() ?? initial).plugins) {
+            if (owned.has(plugin))
+                continue;
+            items.push({
+                file: `viewer/${plugin.id}`,
+                name: plugin.name ?? plugin.id,
+                icon: plugin.icon,
+                version: "",
+                hash: "",
+                size: 0,
+                enabled: true,
+                plugins: [plugin.id],
+                readonly: true,
+            });
+        }
+        return { scope, items: items.sort((a, b) => a.name.localeCompare(b.name)) };
+    };
+    const activate = async (name, data, save, base) => {
+        const revision = hash(data);
+        if (!save && active.get(name)?.hash === revision)
+            return;
+        const pkg = await unpack(data);
+        const folder = mkdtempSync(join(tmpdir(), "dooc-extension-"));
+        let timer;
+        try {
+            for (const file of pkg.files) {
+                const path = join(folder, file.name);
+                mkdirSync(dirname(path), { recursive: true });
+                writeFileSync(path, file.data, { flag: "wx" });
+            }
+            const module = await Promise.race([
+                import(pathToFileURL(join(folder, pkg.main)).href),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error("Plugin initialization timed out")), 10000);
+                }),
+            ]);
+            const config = validateViewerPlugins(module.default);
+            if (!config.plugins.length ||
+                config.setup ||
+                config.gitOrigin ||
+                config.workspace ||
+                config.allowedDomains)
+                throw new Error("Export a viewer configuration with plugins and optional mocks");
+            const live = registry.configuration?.();
+            const owned = active.get(name)?.config.plugins ?? [];
+            for (const plugin of config.plugins) {
+                const existing = live?.plugins.find((item) => item.id === plugin.id);
+                if (existing && !owned.includes(existing))
+                    throw new Error(`Plugin ID is already registered: ${plugin.id}`);
+            }
+            if (Object.keys(config.mocks).some((id) => !config.plugins.some((plugin) => plugin.id === id)))
+                throw new Error("Mocks must belong to plugins in this package");
+            const other = live
+                ? [
+                    {
+                        plugins: live.plugins.filter((plugin) => !owned.includes(plugin)),
+                        mocks: Object.fromEntries(Object.entries(live.mocks).filter(([id]) => !owned.some((plugin) => plugin.id === id))),
+                    },
+                ]
+                : [
+                    initial,
+                    ...[...active]
+                        .filter(([key]) => key !== name)
+                        .map(([, value]) => value.config),
+                ];
+            validateViewerPlugins({
+                plugins: [...other.flatMap((config) => config.plugins), ...config.plugins],
+                mocks: Object.assign({}, ...other.map((config) => config.mocks), config.mocks),
+            });
+            if (save) {
+                const current = read(name);
+                if ((current ? hash(current) : null) !== base)
+                    throw new Error("Plugin changed. Reopen it before saving.");
+                const target = join(directory(), name);
+                mkdirSync(dirname(target), { recursive: true });
+                const temporary = join(dirname(target), `.upload-${Date.now()}.tmp`);
+                try {
+                    writeFileSync(temporary, data, { flag: "wx" });
+                    renameSync(temporary, target);
+                }
+                finally {
+                    rmSync(temporary, { force: true });
+                }
+            }
+            disable(name);
+            for (const plugin of config.plugins)
+                registry.register(plugin, { mock: config.mocks[plugin.id] });
+            active.set(name, { hash: revision, config, directory: folder });
+            remember(name, revision);
+        }
+        finally {
+            clearTimeout(timer);
+            if (active.get(name)?.directory !== folder)
+                rmSync(folder, { recursive: true, force: true });
+        }
+    };
+    const perform = async (input) => {
+        if (input.action === "list")
+            return list();
+        const name = extensionFile(input.file);
+        const current = read(name);
+        if (input.action === "read") {
+            if (!current)
+                throw new Error("Plugin not found");
+            const pkg = await unpack(current);
+            return {
+                file: name,
+                hash: hash(current),
+                ...pkg,
+                files: pkg.files.map((file) => ({
+                    name: file.name,
+                    data: Buffer.from(file.data).toString("base64"),
+                })),
+            };
+        }
+        if (input.action === "install") {
+            if (typeof input.data !== "string" ||
+                input.data.length > Math.ceil((MAX_EXTENSION_BYTES * 4) / 3) ||
+                input.data.length % 4 !== 0 ||
+                !/^[A-Za-z0-9+/]*={0,2}$/.test(input.data))
+                throw new Error("Expected a ZIP smaller than 16 MiB");
+            if ((current ? hash(current) : null) !== input.base)
+                throw new Error("Plugin changed. Reopen it before saving.");
+            await activate(name, Buffer.from(input.data, "base64"), true, input.base);
+        }
+        else {
+            if (!current || hash(current) !== input.hash)
+                throw new Error("Plugin changed. Reopen it before continuing.");
+            if (input.action === "enable")
+                await activate(name, current, false, input.hash);
+            else if (input.action === "disable") {
+                disable(name);
+                remember(name);
+            }
+            else if (input.action === "delete") {
+                unlinkSync(join(directory(), name));
+                disable(name);
+                remember(name);
+            }
+            else if (input.action === "edit") {
+                if (typeof input.source !== "string" ||
+                    Buffer.byteLength(input.source) > MAX_EXTENSION_BYTES ||
+                    input.source.includes("\0"))
+                    throw new Error("Expected UTF-8 text smaller than 16 MiB");
+                const pkg = await unpack(current);
+                const file = pkg.files.find((file) => file.name === input.path);
+                if (!file)
+                    throw new Error("Plugin file not found");
+                file.data = Buffer.from(input.source);
+                extensionManifest(pkg.files);
+                const data = zip(pkg.files.map((file) => ({ name: file.name, data: Buffer.from(file.data) })));
+                await activate(name, data, true, input.hash);
+            }
+            else
+                throw new Error("Unknown plugin action");
+        }
+        return list();
+    };
+    const request = (input) => {
+        const result = queued.then(() => perform(input));
+        queued = result.catch(() => { });
+        return result;
+    };
+    return Object.assign(request, {
+        async restore() {
+            const approved = approval();
+            const errors = [];
+            for (const item of (await list()).items)
+                if (!item.readonly && !item.error && approved[item.file] === item.hash) {
+                    try {
+                        await request({ action: "enable", file: item.file, hash: item.hash });
+                    }
+                    catch (error) {
+                        errors.push(`${item.file}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            return errors;
+        },
+        dispose: () => {
+            for (const name of active.keys())
+                disable(name);
+        },
+    });
+};

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>;

package/dist/viewer/font-picker.js

@@ -0,0 +1,145 @@
+/** Self-contained because published viewers embed this function directly. */
+export const mountFontPickers = async (createSettings, registered) => {
+    const settings = createSettings(registered);
+    const root = document.documentElement;
+    const t = (key) => window.__docsTranslate?.(key) ??
+        key;
+    const popup = document.createElement("div");
+    popup.className = "theme-picker font-picker";
+    popup.id = "font-picker";
+    popup.popover = "auto";
+    popup.setAttribute("role", "menu");
+    document.body.append(popup);
+    let trigger;
+    let busy = true;
+    let message = "Loading fonts";
+    const target = (button) => button.dataset.fontPicker === "editor" ? "editor" : "viewer";
+    const choices = () => new Map([
+        ["", t("Default font")],
+        ...registered
+            .filter((font) => settings.fonts.has(font.family))
+            .map((font) => [font.family, font.name]),
+    ]);
+    const render = () => {
+        if (!trigger)
+            return;
+        popup.replaceChildren();
+        popup.setAttribute("aria-label", t(target(trigger) === "editor" ? "Editor font" : "Viewer font"));
+        for (const [family, name] of choices()) {
+            const option = document.createElement("button");
+            option.type = "button";
+            option.dataset.fontValue = family;
+            option.setAttribute("role", "menuitemradio");
+            option.setAttribute("aria-checked", String(family === settings.selected[target(trigger)]));
+            option.textContent = option.title = name;
+            popup.append(option);
+        }
+        if (message) {
+            const status = document.createElement("div");
+            status.className = "font-status";
+            status.setAttribute("role", "status");
+            status.textContent = t(message);
+            popup.append(status);
+        }
+    };
+    const sync = () => {
+        const names = choices();
+        for (const button of document.querySelectorAll("[data-font-picker]")) {
+            const kind = target(button);
+            button.disabled = busy;
+            button.title = `${t(kind === "editor" ? "Editor font" : "Viewer font")}: ${names.get(settings.selected[kind]) ?? t("Default font")}`;
+            button.setAttribute("aria-label", button.title);
+            button.setAttribute("aria-controls", popup.id);
+            button.setAttribute("popovertarget", popup.id);
+        }
+        if (popup.matches(":popover-open"))
+            render();
+    };
+    document.addEventListener("click", (event) => {
+        const button = event.target instanceof Element
+            ? event.target.closest("[data-font-picker]")
+            : null;
+        if (!button || busy)
+            return;
+        event.preventDefault();
+        if (trigger === button && popup.matches(":popover-open")) {
+            popup.hidePopover();
+            return;
+        }
+        trigger?.setAttribute("aria-expanded", "false");
+        if (popup.matches(":popover-open"))
+            popup.hidePopover();
+        trigger = button;
+        popup.dataset.theme =
+            (target(button) === "editor"
+                ? root.dataset.editorTheme
+                : (button.closest(".preview-pane")?.dataset.theme ??
+                    root.dataset.theme)) ?? "auto";
+        render();
+        const rect = button.getBoundingClientRect();
+        popup.style.left = `${Math.max(8, Math.min(rect.left, innerWidth - 248))}px`;
+        popup.style.top = `${rect.bottom + 6}px`;
+        popup.style.maxHeight = `${Math.max(60, innerHeight - rect.bottom - 14)}px`;
+        popup.showPopover();
+        button.setAttribute("aria-expanded", "true");
+        popup.querySelector('[aria-checked="true"]')?.focus();
+    });
+    popup.addEventListener("click", (event) => {
+        const option = event.target instanceof Element
+            ? event.target.closest("[data-font-value]")
+            : null;
+        if (!option || !trigger)
+            return;
+        message = "";
+        try {
+            settings.select(target(trigger), option.dataset.fontValue ?? "");
+        }
+        catch (error) {
+            message = error instanceof Error ? error.message : "Invalid font file";
+        }
+        if (!message) {
+            popup.hidePopover();
+            trigger.focus({ preventScroll: true });
+        }
+        sync();
+        if (message)
+            popup.querySelector('[aria-checked="true"]')?.focus();
+    });
+    popup.addEventListener("keydown", (event) => {
+        const options = [...popup.querySelectorAll("button")];
+        const index = options.indexOf(document.activeElement);
+        if (["ArrowDown", "ArrowUp", "Home", "End"].includes(event.key)) {
+            event.preventDefault();
+            const next = event.key === "Home"
+                ? 0
+                : event.key === "End"
+                    ? options.length - 1
+                    : (index + (event.key === "ArrowDown" ? 1 : options.length - 1)) %
+                        options.length;
+            options[next]?.focus();
+        }
+        if (event.key === "Escape")
+            trigger?.focus({ preventScroll: true });
+    });
+    popup.addEventListener("toggle", () => {
+        if (!popup.matches(":popover-open"))
+            trigger?.setAttribute("aria-expanded", "false");
+    });
+    new MutationObserver((records) => {
+        if (records.some((record) => [...record.addedNodes].some((node) => node instanceof Element &&
+            (node.matches("[data-font-picker]") ||
+                node.querySelector("[data-font-picker]")))))
+            sync();
+    }).observe(document.body, { childList: true, subtree: true });
+    document.addEventListener("docs:ui-language", sync);
+    sync();
+    try {
+        await settings.ready;
+        message = "";
+    }
+    catch (error) {
+        message = error instanceof Error ? error.message : "Invalid font file";
+    }
+    busy = false;
+    sync();
+};

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

@@ -0,0 +1,11 @@
+import type { ProjectFont } from "../compiler/fonts.js";
+/** Self-contained because published viewers embed this function directly. */
+export declare const createFontSettings: (registered: readonly ProjectFont[]) => {
+    fonts: Map<string, FontFace>;
+    selected: {
+        editor: string;
+        viewer: string;
+    };
+    ready: Promise<void>;
+    select: (target: "editor" | "viewer", family: string) => void;
+};

package/dist/viewer/font-settings.js

@@ -0,0 +1,50 @@
+/** Self-contained because published viewers embed this function directly. */
+export const createFontSettings = (registered) => {
+    const fonts = new Map();
+    const selected = { editor: "", viewer: "" };
+    const key = (target) => `docs-${target === "viewer" ? "preview" : target}:font`;
+    for (const target of ["editor", "viewer"]) {
+        try {
+            selected[target] = localStorage.getItem(key(target)) ?? "";
+        }
+        catch {
+            /* Defaults still work when storage is unavailable. */
+        }
+    }
+    const apply = () => {
+        for (const target of ["editor", "viewer"]) {
+            const face = fonts.get(selected[target]);
+            if (face)
+                document.documentElement.style.setProperty(`--${target}-font`, `"${face.family}", "UDEV Gothic", monospace`);
+            else
+                document.documentElement.style.removeProperty(`--${target}-font`);
+        }
+        document.dispatchEvent(new Event("docs:font-change"));
+    };
+    const select = (target, family) => {
+        if (family && !fonts.has(family))
+            throw new Error("Invalid font file");
+        selected[target] = family;
+        apply();
+        try {
+            localStorage.setItem(key(target), family);
+        }
+        catch {
+            throw new Error("Font choice applies only to this tab");
+        }
+    };
+    const ready = (async () => {
+        const results = await Promise.allSettled(registered.map(async ({ family, source }) => {
+            const face = await new FontFace(family, source).load();
+            document.fonts.add(face);
+            fonts.set(family, face);
+        }));
+        for (const target of ["editor", "viewer"])
+            if (!fonts.has(selected[target]))
+                selected[target] = "";
+        apply();
+        if (results.some((result) => result.status === "rejected"))
+            throw new Error("Some registered fonts could not be loaded");
+    })();
+    return { fonts, selected, ready, select };
+};