@lapismd/mira 0.0.4 → 0.1.0

package/dist/internal/codemirror/base/index.test.js

@@ -1,303 +0,0 @@
-// @vitest-environment jsdom
-import { describe, expect, it } from "vitest";
-import { CompletionContext } from "@codemirror/autocomplete";
-import { EditorState } from "@codemirror/state";
-import { EditorView } from "@codemirror/view";
-import { createBaseCodeMirrorExtensions, createMarkdownTemplate, createSlashCommandCompletionSource, createSlashCommandExtensions, createSlashSnippet, } from ".";
-const slashCommands = [
-    createSlashSnippet({
-        id: "heading",
-        label: "Heading 1",
-        description: "Large section heading",
-        group: "Basic",
-        keywords: ["h1"],
-        markdown: "# <|>",
-    }),
-    createSlashSnippet({
-        id: "quote",
-        label: "Quote",
-        description: "Create a quote",
-        group: "Basic",
-        keywords: ["blockquote"],
-        markdown: "> <|>",
-    }),
-    createSlashSnippet({
-        id: "table",
-        label: "Table",
-        description: "Insert a pipe table",
-        group: "Blocks",
-        keywords: ["tabular"],
-        markdown: "| Column | Value |\n| --- | --- |\n| Item | Detail |\n",
-    }),
-];
-function createSlashEditor(doc = "") {
-    const parent = document.createElement("div");
-    document.body.append(parent);
-    const view = new EditorView({
-        doc,
-        selection: { anchor: doc.length },
-        extensions: [
-            createSlashCommandExtensions({
-                commands: slashCommands,
-            }),
-        ],
-        parent,
-    });
-    return {
-        parent,
-        view,
-        destroy() {
-            view.destroy();
-            parent.remove();
-        },
-    };
-}
-function createAfterWhitespaceSlashEditor(doc = "") {
-    const parent = document.createElement("div");
-    document.body.append(parent);
-    const view = new EditorView({
-        doc,
-        selection: { anchor: doc.length },
-        extensions: [
-            createSlashCommandExtensions({
-                commands: slashCommands,
-                triggerScope: "after-whitespace",
-            }),
-        ],
-        parent,
-    });
-    return {
-        parent,
-        view,
-        destroy() {
-            view.destroy();
-            parent.remove();
-        },
-    };
-}
-function insertText(view, text) {
-    const selection = view.state.selection.main;
-    view.dispatch({
-        changes: {
-            from: selection.from,
-            to: selection.to,
-            insert: text,
-        },
-        selection: {
-            anchor: selection.from + text.length,
-        },
-    });
-}
-function pressKey(view, key) {
-    view.contentDOM.dispatchEvent(new KeyboardEvent("keydown", {
-        bubbles: true,
-        cancelable: true,
-        key,
-    }));
-}
-function slashMenu(parent) {
-    return parent.querySelector(".mira-slash-menu");
-}
-function slashMenuTitles(parent) {
-    return Array.from(parent.querySelectorAll(".mira-slash-menu__item-title"), (title) => title.textContent ?? "");
-}
-describe("createBaseCodeMirrorExtensions", () => {
-    it("returns a non-empty extension set", () => {
-        expect(createBaseCodeMirrorExtensions()).not.toHaveLength(0);
-    });
-    it("uses muted monospaced tabular line numbers", () => {
-        const parent = document.createElement("div");
-        document.body.append(parent);
-        const view = new EditorView({
-            doc: Array.from({ length: 12 }, (_, index) => `Line ${index + 1}`).join("\n"),
-            extensions: createBaseCodeMirrorExtensions(),
-            parent,
-        });
-        const gutter = parent.querySelector(".cm-gutter.cm-lineNumbers");
-        const number = gutter?.querySelector(".cm-gutterElement");
-        expect(gutter).not.toBeNull();
-        expect(number).not.toBeNull();
-        expect(getComputedStyle(gutter).fontFamily).toBe("var(--font-monospace, var(--mira-font-mono))");
-        expect(getComputedStyle(gutter).fontVariantNumeric).toBe("tabular-nums");
-        expect(getComputedStyle(gutter).color).toBe("var(--text-faint, var(--mira-muted-foreground))");
-        expect(getComputedStyle(number).justifyContent).toBe("end");
-        view.destroy();
-        parent.remove();
-    });
-});
-describe("createSlashCommandExtensions", () => {
-    it("is empty without commands", () => {
-        expect(createSlashCommandExtensions()).toEqual([]);
-    });
-    it("completes slash commands after a slash trigger", () => {
-        const source = createSlashCommandCompletionSource([
-            {
-                id: "heading",
-                label: "Heading 1",
-                group: "Basic",
-                keywords: ["h1"],
-                insert: "# ",
-            },
-            {
-                id: "table",
-                label: "Table",
-                group: "Blocks",
-                insert: "| Column |",
-            },
-        ]);
-        const state = EditorState.create({ doc: "/h" });
-        const result = source(new CompletionContext(state, 2, false));
-        if (result instanceof Promise) {
-            throw new Error("Expected synchronous slash completions.");
-        }
-        expect(result?.from).toBe(1);
-        expect(result?.to).toBe(2);
-        expect(result?.filter).toBe(false);
-        expect(result?.options.map((option) => option.label)).toEqual([
-            "Heading 1",
-        ]);
-    });
-    it("does not complete slash commands in the middle of a word", () => {
-        const source = createSlashCommandCompletionSource([
-            {
-                id: "heading",
-                label: "Heading 1",
-                insert: "# ",
-            },
-        ]);
-        const state = EditorState.create({ doc: "word/h" });
-        const result = source(new CompletionContext(state, 6, false));
-        expect(result).toBeNull();
-    });
-    it("keeps the autocomplete UI path available", () => {
-        expect(createSlashCommandExtensions({
-            commands: slashCommands,
-            ui: "autocomplete",
-        })).not.toHaveLength(0);
-    });
-});
-describe("slash command popover", () => {
-    it("opens on slash at line start and after indentation", () => {
-        const editor = createSlashEditor();
-        insertText(editor.view, "/");
-        expect(slashMenu(editor.parent)).not.toBeNull();
-        editor.destroy();
-        const indentedEditor = createSlashEditor("  ");
-        insertText(indentedEditor.view, "/");
-        expect(slashMenu(indentedEditor.parent)).not.toBeNull();
-        indentedEditor.destroy();
-    });
-    it("does not open after prose, URLs, or paths", () => {
-        for (const doc of ["word ", "https:/", "notes"]) {
-            const editor = createSlashEditor(doc);
-            insertText(editor.view, "/");
-            expect(slashMenu(editor.parent)).toBeNull();
-            editor.destroy();
-        }
-    });
-    it("can opt into opening after whitespace", () => {
-        const editor = createAfterWhitespaceSlashEditor("word ");
-        insertText(editor.view, "/");
-        expect(slashMenu(editor.parent)).not.toBeNull();
-        editor.destroy();
-    });
-    it("filters commands by label, description, and keywords", () => {
-        const editor = createSlashEditor();
-        insertText(editor.view, "/tab");
-        expect(slashMenuTitles(editor.parent)).toEqual(["Table"]);
-        editor.view.dispatch({
-            changes: { from: 0, to: editor.view.state.doc.length, insert: "/large" },
-            selection: { anchor: 6 },
-        });
-        expect(slashMenuTitles(editor.parent)).toEqual(["Heading 1"]);
-        editor.view.dispatch({
-            changes: { from: 0, to: editor.view.state.doc.length, insert: "/block" },
-            selection: { anchor: 6 },
-        });
-        expect(slashMenuTitles(editor.parent)).toEqual(["Quote"]);
-        editor.destroy();
-    });
-    it("renders no menu when no commands match", () => {
-        const editor = createSlashEditor();
-        insertText(editor.view, "/missing");
-        expect(slashMenu(editor.parent)).toBeNull();
-        editor.destroy();
-    });
-    it("groups commands while preserving command order within groups", () => {
-        const editor = createSlashEditor();
-        insertText(editor.view, "/");
-        expect(Array.from(editor.parent.querySelectorAll(".mira-slash-menu__group"), (group) => group.textContent)).toEqual(["Basic", "Blocks"]);
-        expect(slashMenuTitles(editor.parent)).toEqual([
-            "Heading 1",
-            "Quote",
-            "Table",
-        ]);
-        editor.destroy();
-    });
-    it("navigates with wrapping arrow keys and applies the active command", () => {
-        const editor = createSlashEditor();
-        insertText(editor.view, "/");
-        pressKey(editor.view, "ArrowUp");
-        pressKey(editor.view, "Enter");
-        expect(editor.view.state.doc.toString()).toBe("| Column | Value |\n| --- | --- |\n| Item | Detail |\n");
-        expect(slashMenu(editor.parent)).toBeNull();
-        editor.destroy();
-    });
-    it("applies a command selected by mouse", () => {
-        const editor = createSlashEditor();
-        insertText(editor.view, "/tab");
-        editor.parent
-            .querySelector(".mira-slash-menu__item")
-            ?.click();
-        expect(editor.view.state.doc.toString()).toBe("| Column | Value |\n| --- | --- |\n| Item | Detail |\n");
-        editor.destroy();
-    });
-    it("closes on escape, space, and backspace from an empty query", () => {
-        const escapeEditor = createSlashEditor();
-        insertText(escapeEditor.view, "/");
-        pressKey(escapeEditor.view, "Escape");
-        expect(slashMenu(escapeEditor.parent)).toBeNull();
-        escapeEditor.destroy();
-        const spaceEditor = createSlashEditor();
-        insertText(spaceEditor.view, "/");
-        insertText(spaceEditor.view, " ");
-        expect(slashMenu(spaceEditor.parent)).toBeNull();
-        spaceEditor.destroy();
-        const backspaceEditor = createSlashEditor();
-        insertText(backspaceEditor.view, "/");
-        backspaceEditor.view.dispatch({
-            changes: { from: 0, to: 1 },
-            selection: { anchor: 0 },
-        });
-        expect(slashMenu(backspaceEditor.parent)).toBeNull();
-        backspaceEditor.destroy();
-    });
-    it("places the cursor at the markdown template marker", () => {
-        const editor = createSlashEditor();
-        insertText(editor.view, "/h");
-        pressKey(editor.view, "Enter");
-        expect(editor.view.state.doc.toString()).toBe("# ");
-        expect(editor.view.state.selection.main.head).toBe(2);
-        editor.destroy();
-    });
-});
-describe("slash snippet helpers", () => {
-    it("creates templates and slash commands with cursor markers", () => {
-        expect(createMarkdownTemplate("## <|>")).toEqual({
-            markdown: "## ",
-            selection: 3,
-        });
-        expect(createSlashSnippet({
-            id: "math",
-            label: "Math block",
-            markdown: "$$\n<|>\n$$",
-        })).toEqual({
-            id: "math",
-            label: "Math block",
-            insert: {
-                markdown: "$$\n\n$$",
-                selection: 3,
-            },
-        });
-    });
-});

package/dist/internal/codemirror/base/search.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=search.test.d.ts.map

package/dist/internal/codemirror/base/search.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search.test.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/base/search.test.ts"],"names":[],"mappings":""}

package/dist/internal/codemirror/base/search.test.js

@@ -1,155 +0,0 @@
-// @vitest-environment jsdom
-import { getSearchQuery, openSearchPanel, searchPanelOpen, } from "@codemirror/search";
-import { EditorState } from "@codemirror/state";
-import { EditorView } from "@codemirror/view";
-import { tick } from "svelte";
-import { describe, expect, it } from "vitest";
-import { createBaseCodeMirrorExtensions } from ".";
-import { createMiraSearchExtension, createSearchPanelHost, focusSearchPanelInput, } from "./search";
-function createSearchEditor(doc = "Alpha beta Alpha", selection = { anchor: 0, head: 5 }) {
-    const parent = document.createElement("div");
-    document.body.append(parent);
-    const view = new EditorView({
-        state: EditorState.create({
-            doc,
-            selection,
-            extensions: [createBaseCodeMirrorExtensions()],
-        }),
-        parent,
-    });
-    return {
-        parent,
-        view,
-        destroy() {
-            view.destroy();
-            parent.remove();
-        },
-    };
-}
-function inputValue(input, value) {
-    input.value = value;
-    input.dispatchEvent(new Event("input", { bubbles: true }));
-}
-describe("Mira search extension", () => {
-    it("opens the Lapis-compatible search interface with the selection", () => {
-        const editor = createSearchEditor();
-        openSearchPanel(editor.view);
-        const panel = editor.parent.querySelector(".mira-search-panel");
-        const searchInput = editor.parent.querySelector(".mira-search-panel__search-input");
-        expect(panel).not.toBeNull();
-        expect(editor.parent.querySelector(".cm-panels-top .mira-search-panel-host")).not.toBeNull();
-        expect(searchInput?.value).toBe("Alpha");
-        expect(document.activeElement).toBe(searchInput);
-        expect(editor.parent.querySelector('[aria-label="Case sensitive"]')).not.toBeNull();
-        expect(editor.parent.querySelector('[aria-label="Match whole word"]')).not.toBeNull();
-        expect(editor.parent.querySelector('[aria-label="Use regular expression"]')).not.toBeNull();
-        const searchField = editor.parent.querySelector(".mira-search-panel__search-field");
-        const searchOptions = editor.parent.querySelector('[role="group"][aria-label="Search options"]');
-        expect(searchField?.contains(searchInput)).toBe(true);
-        expect(searchField?.contains(searchOptions)).toBe(true);
-        expect(searchOptions?.parentElement).toBe(searchField);
-        expect(searchField?.querySelector(".mira-search-panel__find-icon svg")).not.toBeNull();
-        expect(editor.parent.querySelector('[aria-label="Select all matches"]')).not.toBeNull();
-        editor.destroy();
-    });
-    it("updates search flags and reports missing matches", async () => {
-        const editor = createSearchEditor();
-        openSearchPanel(editor.view);
-        editor.parent
-            .querySelector('[aria-label="Case sensitive"]')
-            ?.click();
-        editor.parent
-            .querySelector('[aria-label="Match whole word"]')
-            ?.click();
-        editor.parent
-            .querySelector('[aria-label="Use regular expression"]')
-            ?.click();
-        expect(getSearchQuery(editor.view.state)).toMatchObject({
-            caseSensitive: true,
-            wholeWord: true,
-            regexp: true,
-        });
-        const searchInput = editor.parent.querySelector(".mira-search-panel__search-input");
-        if (!searchInput) {
-            throw new Error("Expected the search input.");
-        }
-        inputValue(searchInput, "Missing");
-        await tick();
-        expect(getSearchQuery(editor.view.state).search).toBe("Missing");
-        expect(searchInput.getAttribute("aria-invalid")).toBe("true");
-        expect(editor.parent.querySelector('[role="status"]')?.textContent).toContain("No matches found");
-        editor.destroy();
-    });
-    it("expands replace controls and replaces all matches", async () => {
-        const editor = createSearchEditor("one two one", { anchor: 0, head: 3 });
-        openSearchPanel(editor.view);
-        editor.parent
-            .querySelector('[aria-label="Toggle replace"]')
-            ?.click();
-        await tick();
-        const replaceInput = editor.parent.querySelector('input[aria-label="Replace"]');
-        if (!replaceInput) {
-            throw new Error("Expected the replace input.");
-        }
-        inputValue(replaceInput, "three");
-        editor.parent
-            .querySelector('[aria-label="Replace all matches"]')
-            ?.click();
-        expect(editor.view.state.doc.toString()).toBe("three two three");
-        editor.destroy();
-    });
-    it("respects initial search configuration and panel placement", () => {
-        const parent = document.createElement("div");
-        document.body.append(parent);
-        const view = new EditorView({
-            state: EditorState.create({
-                doc: "Alpha alpha",
-                extensions: [
-                    createMiraSearchExtension({
-                        top: false,
-                        caseSensitive: true,
-                        wholeWord: true,
-                    }),
-                ],
-            }),
-            parent,
-        });
-        openSearchPanel(view);
-        expect(getSearchQuery(view.state)).toMatchObject({
-            caseSensitive: true,
-            wholeWord: true,
-        });
-        expect(parent.querySelector(".cm-panels-bottom .mira-search-panel-host")).not.toBeNull();
-        view.destroy();
-        parent.remove();
-    });
-    it("closes with Escape from the search panel", () => {
-        const editor = createSearchEditor();
-        openSearchPanel(editor.view);
-        const searchInput = editor.parent.querySelector(".mira-search-panel__search-input");
-        searchInput?.dispatchEvent(new KeyboardEvent("keydown", {
-            bubbles: true,
-            cancelable: true,
-            key: "Escape",
-        }));
-        expect(searchPanelOpen(editor.view.state)).toBe(false);
-        editor.destroy();
-    });
-    it("creates and focuses the panel host in the editor document", () => {
-        const iframe = document.createElement("iframe");
-        document.body.append(iframe);
-        const popupDocument = iframe.contentDocument;
-        if (!popupDocument) {
-            throw new Error("Expected an iframe document.");
-        }
-        const host = createSearchPanelHost(popupDocument);
-        const input = popupDocument.createElement("input");
-        input.className = "mira-search-panel__search-input";
-        host.append(input);
-        popupDocument.body.append(host);
-        focusSearchPanelInput(host);
-        expect(host.ownerDocument).toBe(popupDocument);
-        expect(popupDocument.activeElement).toBe(input);
-        iframe.remove();
-    });
-});

package/dist/internal/codemirror/base/selection-toolbar.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=selection-toolbar.test.d.ts.map

package/dist/internal/codemirror/base/selection-toolbar.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"selection-toolbar.test.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/base/selection-toolbar.test.ts"],"names":[],"mappings":""}

package/dist/internal/codemirror/base/selection-toolbar.test.js

@@ -1,149 +0,0 @@
-// @vitest-environment jsdom
-import { EditorSelection, EditorState } from "@codemirror/state";
-import { EditorView } from "@codemirror/view";
-import { describe, expect, it } from "vitest";
-import { createMarkdownCodeMirrorExtensions } from "../markdown";
-import { createSelectionToolbarExtension, defaultMiraSelectionToolbarActions, } from "./selection-toolbar";
-function createEditor({ actions, ariaLabel, labels, placement, readonly = false, doc = "Format this text", selection = EditorSelection.single(7, 11), } = {}) {
-    const parent = document.createElement("div");
-    document.body.append(parent);
-    const view = new EditorView({
-        state: EditorState.create({
-            doc,
-            selection,
-            extensions: [
-                createMarkdownCodeMirrorExtensions({ sourceMode: true }),
-                EditorState.readOnly.of(readonly),
-                createSelectionToolbarExtension({
-                    actions,
-                    ariaLabel,
-                    labels,
-                    placement,
-                }),
-            ],
-        }),
-        parent,
-    });
-    return {
-        parent,
-        view,
-        destroy() {
-            view.destroy();
-            parent.remove();
-        },
-    };
-}
-function toolbar(parent) {
-    return parent.querySelector('[role="toolbar"]');
-}
-describe("createSelectionToolbarExtension", () => {
-    it("shows the default accessible actions in screenshot order", () => {
-        const editor = createEditor();
-        const selectionToolbar = toolbar(editor.parent);
-        expect(defaultMiraSelectionToolbarActions).toEqual([
-            "link",
-            "bold",
-            "italic",
-            "strikethrough",
-        ]);
-        expect(selectionToolbar?.getAttribute("aria-label")).toBe("Text formatting");
-        expect(selectionToolbar?.dataset.placement).toBe("below");
-        expect(Array.from(selectionToolbar?.querySelectorAll("button") ?? [], (button) => ({
-            action: button.dataset.miraSelectionAction,
-            label: button.getAttribute("aria-label"),
-            title: button.title,
-            icon: button.querySelector("svg")?.getAttribute("aria-hidden"),
-        }))).toEqual([
-            { action: "link", label: "Link", title: "Link", icon: "true" },
-            { action: "bold", label: "Bold", title: "Bold", icon: "true" },
-            { action: "italic", label: "Italic", title: "Italic", icon: "true" },
-            {
-                action: "strikethrough",
-                label: "Strikethrough",
-                title: "Strikethrough",
-                icon: "true",
-            },
-        ]);
-        expect(Array.from(selectionToolbar?.querySelectorAll("button") ?? [], (button) => button.getAttribute("aria-pressed"))).toEqual(["false", "false", "false", "false"]);
-        expect(editor.view.state.doc.toString()).toBe("Format this text");
-        editor.destroy();
-    });
-    it("delegates button activation to the shared Markdown action engine", () => {
-        const editor = createEditor();
-        const bold = editor.parent.querySelector('[data-mira-selection-action="bold"]');
-        bold?.click();
-        expect(editor.view.state.doc.toString()).toBe("Format **this** text");
-        expect(editor.view.state.selection.main.from).toBe(9);
-        expect(editor.view.state.selection.main.to).toBe(13);
-        expect(toolbar(editor.parent)).not.toBeNull();
-        expect(editor.parent
-            .querySelector('[data-mira-selection-action="bold"]')
-            ?.getAttribute("aria-pressed")).toBe("true");
-        editor.parent
-            .querySelector('[data-mira-selection-action="bold"]')
-            ?.click();
-        expect(editor.view.state.doc.toString()).toBe("Format this text");
-        expect(editor.parent
-            .querySelector('[data-mira-selection-action="bold"]')
-            ?.getAttribute("aria-pressed")).toBe("false");
-        editor.destroy();
-    });
-    it("marks an existing exact formatting span as selected", () => {
-        const editor = createEditor({
-            doc: "Format __this__ text",
-            selection: EditorSelection.single(9, 13),
-        });
-        expect(editor.parent
-            .querySelector('[data-mira-selection-action="bold"]')
-            ?.getAttribute("aria-pressed")).toBe("true");
-        expect(editor.parent
-            .querySelector('[data-mira-selection-action="italic"]')
-            ?.getAttribute("aria-pressed")).toBe("false");
-        editor.destroy();
-    });
-    it("supports configured action order, labels, placement, and toolbar name", () => {
-        const editor = createEditor({
-            actions: ["inlineCode", "italic", "inlineCode"],
-            ariaLabel: "Quick formatting",
-            labels: { inlineCode: "Code selection" },
-            placement: "above",
-        });
-        const selectionToolbar = toolbar(editor.parent);
-        expect(selectionToolbar?.getAttribute("aria-label")).toBe("Quick formatting");
-        expect(selectionToolbar?.dataset.placement).toBe("above");
-        expect(Array.from(selectionToolbar?.querySelectorAll("button") ?? [], (button) => button.getAttribute("aria-label"))).toEqual(["Code selection", "Italic"]);
-        editor.destroy();
-    });
-    it("moves keyboard focus into and through the toolbar", () => {
-        const editor = createEditor();
-        editor.view.focus();
-        editor.view.contentDOM.dispatchEvent(new KeyboardEvent("keydown", {
-            bubbles: true,
-            cancelable: true,
-            key: "Tab",
-        }));
-        expect(document.activeElement?.getAttribute("aria-label")).toBe("Link");
-        document.activeElement?.dispatchEvent(new KeyboardEvent("keydown", {
-            bubbles: true,
-            cancelable: true,
-            key: "ArrowRight",
-        }));
-        expect(document.activeElement?.getAttribute("aria-label")).toBe("Bold");
-        document.activeElement?.dispatchEvent(new KeyboardEvent("keydown", {
-            bubbles: true,
-            cancelable: true,
-            key: "Escape",
-        }));
-        expect(document.activeElement).toBe(editor.view.contentDOM);
-        editor.destroy();
-    });
-    it("hides for collapsed selections and readonly editors", () => {
-        const editor = createEditor();
-        editor.view.dispatch({ selection: EditorSelection.cursor(7) });
-        expect(toolbar(editor.parent)).toBeNull();
-        editor.destroy();
-        const readonlyEditor = createEditor({ readonly: true });
-        expect(toolbar(readonlyEditor.parent)).toBeNull();
-        readonlyEditor.destroy();
-    });
-});

package/dist/internal/codemirror/markdown/authoring.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=authoring.test.d.ts.map

package/dist/internal/codemirror/markdown/authoring.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"authoring.test.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/authoring.test.ts"],"names":[],"mappings":""}