@dooc-dev/dooc 0.0.0-stage → 0.0.1

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

package/dist/viewer/fonts/LICENSE.txt

@@ -0,0 +1,119 @@
+# Licensing
+
+- Source fonts are licensed under SIL OPEN FONT LICENSE Version 1.1.
+  For more information, see "LICENSE_<FontName>" file contained in the "source" directory.
+- "UDEV Gothic" are licensed under SIL OPEN FONT LICENSE Version 1.1.
+
+## "UDEV Gothic" licensing
+
+Copyright (c) 2022 Yuko OTAWARA. with Reserved Font Name "UDEV Gothic"
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+
+## Included font copyrights
+
+[JetBrains Mono]
+Copyright 2020 The JetBrains Mono Project Authors https://github.com/JetBrains/JetBrainsMono
+
+[BIZ UDGothic]
+Copyright 2022 The BIZ UDGothic Project Authors https://github.com/googlefonts/morisawa-biz-ud-mincho
+
+[Nerd Fonts]
+Copyright (c) 2014, Ryan L McIntyre https://ryanlmcintyre.com
+
+[UDEV Gothic]
+Copyright 2022 Yuko Otawara
+
+Source: https://github.com/yuru7/udev-gothic/releases/tag/v2.2.0
+UDEVGothic-Regular.ttf (standard 1:2 width, no ligatures), packaged as WOFF2.

package/dist/viewer/fonts.d.ts

@@ -0,0 +1,2 @@
+export declare const readFont: (name: string) => Buffer | undefined;
+export declare function fontCss(inline: boolean): string;

package/dist/viewer/fonts.js

@@ -0,0 +1,13 @@
+import { readViewerAsset } from "./assets.js";
+const fontName = "udev-gothic-regular.woff2";
+const font = readViewerAsset(`fonts/${fontName}`);
+const license = readViewerAsset("fonts/LICENSE.txt").toString("utf8").replaceAll("*/", "* /");
+const face = (url) => `@font-face { font-family:'UDEV Gothic'; font-style:normal; font-weight:400; font-display:swap; src:url(${url}) format('woff2'); }`;
+let embedded;
+export const readFont = (name) => name === fontName ? font : undefined;
+export function fontCss(inline) {
+    if (!inline)
+        return face(`/assets/fonts/${fontName}`);
+    embedded ??= `/* ${license} */\n${face(`data:font/woff2;base64,${font.toString("base64")}`)}`;
+    return embedded;
+}

package/dist/viewer/git-diff.d.ts

@@ -0,0 +1,3 @@
+/** Compare against HEAD so saving or staging does not clear the editor's changes. */
+export declare const gitBaseText: (root: string, file: string) => string | null;
+export declare const gitBaseBody: (root: string, file: string) => string | null;

package/dist/viewer/git-diff.js

@@ -0,0 +1,33 @@
+import { execFileSync } from "node:child_process";
+import { parseDoc } from "../compiler/dialect.js";
+import { textfilePath } from "../compiler/textfile.js";
+/** Compare against HEAD so saving or staging does not clear the editor's changes. */
+export const gitBaseText = (root, file) => {
+    const git = (...args) => execFileSync("git", ["-C", root, ...args], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 2_000,
+        maxBuffer: 5_000_000,
+    });
+    try {
+        textfilePath(root, file);
+        let head;
+        try {
+            head = git("rev-parse", "--verify", "--quiet", "HEAD").trim();
+        }
+        catch (error) {
+            return error.status === 1 ? "" : null;
+        }
+        if (!git("ls-tree", "-z", head, "--", `:(literal)${file}`))
+            return "";
+        return git("show", `${head}:./${file}`);
+    }
+    catch {
+        // Missing Git or unreadable history must leave the editor usable.
+        return null;
+    }
+};
+export const gitBaseBody = (root, file) => {
+    const raw = gitBaseText(root, file);
+    return raw === null ? null : parseDoc(raw).body;
+};

package/dist/viewer/git-types.d.ts

@@ -0,0 +1,73 @@
+export interface GitContext {
+    root: string;
+    branch: string;
+    head: string;
+}
+export interface GitPullRequest {
+    number: number;
+    title: string;
+    body: string;
+    url: string;
+    head: string;
+    base: string;
+    headCommit: string;
+    draft: boolean;
+    status: string;
+}
+export interface GitOriginState {
+    url: string;
+    defaultBranch: string;
+    pullRequests: GitPullRequest[];
+}
+export type GitOriginAction = {
+    action: "fetch" | "pull" | "push";
+} | {
+    action: "createPr";
+    title: string;
+    body: string;
+    base: string;
+    draft: boolean;
+} | {
+    action: "updatePr";
+    number: number;
+    title: string;
+    body: string;
+    previous: GitPullRequest;
+} | {
+    action: "mergePr";
+    number: number;
+    method: "merge" | "squash" | "rebase";
+    previous: GitPullRequest;
+};
+/** Injected by the host, never by dooc.yaml. The host owns credentials and remote policy. */
+export interface GitOrigin {
+    name: string;
+    capabilities: readonly GitOriginAction["action"][];
+    read(context: GitContext): Promise<GitOriginState>;
+    execute(context: GitContext, request: GitOriginAction): Promise<void>;
+}
+export interface GitChange {
+    path: string;
+    index: string;
+    worktree: string;
+}
+export interface GitState {
+    repo: string;
+    branch: string;
+    head: string;
+    version: string;
+    branches: string[];
+    changes: GitChange[];
+    stash?: {
+        id: string;
+        label: string;
+    };
+    upstream: string;
+    ahead: number;
+    behind: number;
+    origin?: GitOriginState & {
+        name: string;
+        capabilities: readonly GitOriginAction["action"][];
+    };
+    originError?: string;
+}

package/dist/viewer/git-types.js

@@ -0,0 +1 @@
+export {};

package/dist/viewer/git.d.ts

@@ -0,0 +1,5 @@
+import type { GitChange, GitOrigin } from "./git-types.js";
+export declare const parseGitChanges: (status: string) => GitChange[];
+export declare const validateGitOrigin: (value: unknown) => GitOrigin;
+/** Serialize UI operations; Git's own locks still arbitrate with other Git clients. */
+export declare const createGitHandler: (documentRoot: string, getOrigin: () => GitOrigin | undefined) => (input: Record<string, unknown> | undefined) => Promise<unknown>;