@lapismd/mira 0.0.1

package/dist/internal/codemirror/markdown/authoring.test.js

@@ -0,0 +1,222 @@
+import { CompletionContext, } from "@codemirror/autocomplete";
+import { EditorSelection, EditorState, } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { convertHtmlToMarkdown, createMarkdownCompletionSources, createMarkdownInputHandlerExtensions, createMarkdownSmartPasteExtension, } from ".";
+const files = [
+    {
+        extension: "md",
+        kind: "markdown",
+        name: "project.md",
+        path: "notes/project.md",
+    },
+    {
+        extension: "png",
+        kind: "image",
+        name: "diagram.png",
+        path: "assets/diagram.png",
+    },
+];
+const adapter = {
+    getHeadings(file) {
+        return file.path === "notes/project.md"
+            ? [{ id: "next-steps", level: 2, text: "Next Steps" }]
+            : [];
+    },
+    listFiles: () => files,
+    resolveLink({ href }) {
+        const normalized = href.replace(/\.md$/i, "");
+        return (files.find((file) => file.path.replace(/\.md$/i, "") === normalized ||
+            file.name?.replace(/\.md$/i, "") === normalized ||
+            file.path.replace(/\.md$/i, "").endsWith(`/${normalized}`)) ?? null);
+    },
+};
+afterEach(() => {
+    document.body.replaceChildren();
+});
+describe("Markdown completions", () => {
+    it("formats file and embed targets through the portable adapter", async () => {
+        const sources = createMarkdownCompletionSources({
+            fileAdapter: adapter,
+            sourcePath: "notes/today.md",
+        });
+        const file = await firstResult(sources, "[[pro");
+        expect(file.options.map((option) => option.label)).toContain("project.md");
+        expect(applyCompletion("[[pro", file, "project.md")).toBe("[[project]]");
+        const embed = await firstResult(sources, "![[dia");
+        expect(embed.options.map((option) => option.label)).toContain("diagram.png");
+        expect(applyCompletion("![[dia", embed, "diagram.png")).toBe("![[diagram.png]]");
+    });
+    it("completes headings while preserving existing display text", async () => {
+        const sources = createMarkdownCompletionSources({
+            fileAdapter: adapter,
+            sourcePath: "notes/today.md",
+        });
+        const doc = "[[project#Ne|Alias]]";
+        const position = doc.indexOf("|");
+        const result = await firstResult(sources, doc, position);
+        expect(result.options.map((option) => option.label)).toContain("Next Steps");
+        expect(applyCompletion(doc, result, "Next Steps", position)).toBe("[[project#Next Steps|Alias]]");
+    });
+    it("resolves a unique basename from listFiles when resolveLink cannot", async () => {
+        const sources = createMarkdownCompletionSources({
+            fileAdapter: {
+                ...adapter,
+                resolveLink: () => null,
+            },
+            sourcePath: "notes/today.md",
+        });
+        const result = await firstResult(sources, "[[project#Ne");
+        expect(applyCompletion("[[project#Ne", result, "Next Steps")).toBe("[[project#Next Steps]]");
+    });
+    it("completes display text without losing the selected target", async () => {
+        const sources = createMarkdownCompletionSources({
+            fileAdapter: adapter,
+            sourcePath: "notes/today.md",
+        });
+        const result = await firstResult(sources, "[[project|Shown");
+        expect(applyCompletion("[[project|Shown", result, "Shown")).toBe("[[project|Shown]]");
+    });
+    it("lets consumers replace the link formatter", async () => {
+        const formatLink = vi.fn((target) => `${target.embed ? "embed" : "link"}:${target.targetPath}`);
+        const sources = createMarkdownCompletionSources({
+            config: { formatLink },
+            fileAdapter: adapter,
+            sourcePath: "notes/today.md",
+        });
+        const result = await firstResult(sources, "[[pro");
+        expect(applyCompletion("[[pro", result, "project.md")).toBe("link:notes/project.md");
+        expect(formatLink).toHaveBeenCalled();
+    });
+});
+describe("Markdown input handlers", () => {
+    it("scaffolds code fences and frontmatter by default", () => {
+        expect(runInputHandler("``", "`")).toEqual({
+            doc: "```\n```",
+            selection: 3,
+        });
+        expect(runInputHandler("--", "-")).toEqual({
+            doc: "---\n\n---",
+            selection: 4,
+        });
+    });
+    it("keeps ellipsis substitution opt-in", () => {
+        expect(runInputHandler("..", ".")).toEqual({
+            doc: "..",
+            selection: 2,
+        });
+        expect(runInputHandler("..", ".", { ellipsis: true })).toEqual({
+            doc: "…",
+            selection: 1,
+        });
+    });
+});
+describe("Markdown smart paste", () => {
+    it("converts rich HTML to Markdown", async () => {
+        const markdown = await convertHtmlToMarkdown("<h2>Plan</h2><ul><li>First</li><li>Second</li></ul>");
+        expect(markdown).toContain("## Plan");
+        expect(markdown).toContain("* First");
+        expect(markdown).toContain("* Second");
+    });
+    it("wraps the current selection when a URL is pasted", () => {
+        const view = createView("Read Mira", 5, 9, [
+            createMarkdownSmartPasteExtension(),
+        ]);
+        const event = pasteEvent({
+            "text/plain": "https://mira.example/docs",
+        });
+        view.contentDOM.dispatchEvent(event);
+        expect(event.defaultPrevented).toBe(true);
+        expect(view.state.doc.toString()).toBe("Read [Mira](https://mira.example/docs)");
+        view.destroy();
+    });
+    it("supports an application-supplied HTML converter", async () => {
+        const view = createView("", 0, 0, [
+            createMarkdownSmartPasteExtension({
+                convertHtml: async () => "**converted**",
+            }),
+        ]);
+        const event = pasteEvent({
+            "text/html": "<strong>converted</strong>",
+            "text/plain": "converted",
+        });
+        view.contentDOM.dispatchEvent(event);
+        await vi.waitFor(() => expect(view.state.doc.toString()).toBe("**converted**"));
+        expect(event.defaultPrevented).toBe(true);
+        view.destroy();
+    });
+});
+async function firstResult(sources, doc, position = doc.length) {
+    const state = EditorState.create({ doc });
+    const context = new CompletionContext(state, position, true);
+    for (const source of sources) {
+        const result = await source(context);
+        if (result) {
+            return result;
+        }
+    }
+    throw new Error(`No completion matched ${doc}`);
+}
+function applyCompletion(doc, result, label, position = doc.length) {
+    const option = result.options.find((item) => item.label === label);
+    if (!option || typeof option.apply !== "function") {
+        throw new Error(`Missing completion ${label}`);
+    }
+    const state = EditorState.create({
+        doc,
+        selection: EditorSelection.cursor(position),
+    });
+    const view = mockView(state);
+    option.apply(view, option, result.from, result.to ?? position);
+    return view.state.doc.toString();
+}
+function runInputHandler(doc, text, config = {}) {
+    const state = EditorState.create({
+        doc,
+        selection: EditorSelection.cursor(doc.length),
+        extensions: createMarkdownInputHandlerExtensions(config),
+    });
+    const view = mockView(state);
+    const handled = state.facet(EditorView.inputHandler).some((handler) => handler(view, doc.length, doc.length, text, () => view.state.update({
+        changes: { from: doc.length, insert: text, to: doc.length },
+    })));
+    return {
+        doc: view.state.doc.toString(),
+        selection: handled ? view.state.selection.main.anchor : doc.length,
+    };
+}
+function mockView(initialState) {
+    let state = initialState;
+    return {
+        dispatch(spec) {
+            state = state.update(spec).state;
+        },
+        get state() {
+            return state;
+        },
+    };
+}
+function createView(doc, from, to, extensions) {
+    const parent = document.createElement("div");
+    document.body.append(parent);
+    return new EditorView({
+        parent,
+        state: EditorState.create({
+            doc,
+            extensions,
+            selection: EditorSelection.range(from, to),
+        }),
+    });
+}
+function pasteEvent(data) {
+    const event = new Event("paste", { bubbles: true, cancelable: true });
+    Object.defineProperty(event, "clipboardData", {
+        value: {
+            getData(type) {
+                return data[type] ?? "";
+            },
+            items: [],
+        },
+    });
+    return event;
+}

package/dist/internal/codemirror/markdown/completion.d.ts

@@ -0,0 +1,12 @@
+import type { CompletionSource } from "@codemirror/autocomplete";
+import { type Extension } from "@codemirror/state";
+import { type MiraFileAdapter, type MiraInternalLinkFormatTarget, type MiraMarkdownCompletionConfig } from "@lapismd/mira/extensions";
+export type MiraMarkdownCompletionOptions = {
+    fileAdapter?: MiraFileAdapter;
+    sourcePath?: string;
+    config?: boolean | MiraMarkdownCompletionConfig;
+};
+export declare function createMarkdownCompletionExtensions(options?: MiraMarkdownCompletionOptions): Extension[];
+export declare function createMarkdownCompletionSources(options?: MiraMarkdownCompletionOptions): CompletionSource[];
+export declare function formatMiraInternalLink(target: MiraInternalLinkFormatTarget): string;
+//# sourceMappingURL=completion.d.ts.map

package/dist/internal/codemirror/markdown/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/completion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,gBAAgB,EACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAEL,KAAK,eAAe,EAEpB,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EAClC,MAAM,0BAA0B,CAAC;AAElC,MAAM,MAAM,6BAA6B,GAAG;IAC1C,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,GAAG,4BAA4B,CAAC;CACjD,CAAC;AAoBF,wBAAgB,kCAAkC,CAChD,OAAO,GAAE,6BAAkC,GAC1C,SAAS,EAAE,CAUb;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,GAAE,6BAAkC,GAC1C,gBAAgB,EAAE,CAGpB;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,4BAA4B,GACnC,MAAM,CA0BR"}

package/dist/internal/codemirror/markdown/completion.js

@@ -0,0 +1,302 @@
+import { EditorState } from "@codemirror/state";
+import { parseMiraFileTarget, } from "@lapismd/mira/extensions";
+export function createMarkdownCompletionExtensions(options = {}) {
+    const resolved = resolveCompletionOptions(options);
+    if (!resolved) {
+        return [];
+    }
+    const sources = createMarkdownCompletionSourcesFromResolved(resolved);
+    return sources.map((source) => EditorState.languageData.of(() => [{ autocomplete: source }]));
+}
+export function createMarkdownCompletionSources(options = {}) {
+    const resolved = resolveCompletionOptions(options);
+    return resolved ? createMarkdownCompletionSourcesFromResolved(resolved) : [];
+}
+export function formatMiraInternalLink(target) {
+    const normalizedPath = normalizePath(target.targetPath);
+    const file = target.file;
+    const extension = (file?.extension ??
+        normalizedPath.split("/").pop()?.split(".").pop() ??
+        "").toLowerCase();
+    const withoutMarkdownExtension = extension === "md" ? normalizedPath.replace(/\.md$/i, "") : normalizedPath;
+    const basename = withoutMarkdownExtension.split("/").pop() ?? "";
+    const basenameMatches = target.files.filter((candidate) => {
+        const candidatePath = normalizePath(candidate.path).replace(/\.md$/i, "");
+        return (candidatePath.split("/").pop() ?? "") === basename;
+    });
+    const sourceDirectory = dirname(normalizePath(target.sourcePath ?? ""));
+    const targetDirectory = dirname(normalizedPath);
+    const linkPath = normalizedPath === normalizePath(target.sourcePath ?? "")
+        ? ""
+        : targetDirectory === sourceDirectory || basenameMatches.length === 1
+            ? basename
+            : withoutMarkdownExtension;
+    const heading = target.heading ? `#${target.heading}` : "";
+    const alias = target.alias ? `|${target.alias}` : "";
+    return `${target.embed ? "!" : ""}[[${linkPath}${heading}${alias}]]`;
+}
+function createMarkdownCompletionSourcesFromResolved(options) {
+    const sources = [];
+    if (options.config.displayText) {
+        sources.push(displayTextCompletionSource(options));
+    }
+    if (options.config.headings) {
+        sources.push(headingCompletionSource(options));
+    }
+    if (options.config.embeds) {
+        sources.push(fileCompletionSource(options, true));
+    }
+    if (options.config.files) {
+        sources.push(fileCompletionSource(options, false));
+    }
+    return sources;
+}
+function resolveCompletionOptions(options) {
+    const adapter = options.fileAdapter;
+    if (options.config === false ||
+        (typeof options.config === "object" && options.config.enabled === false) ||
+        !adapter?.listFiles) {
+        return null;
+    }
+    const config = typeof options.config === "object" ? options.config : {};
+    return {
+        adapter,
+        sourcePath: options.sourcePath,
+        config: {
+            displayText: config.displayText ?? true,
+            embeds: config.embeds ?? true,
+            files: config.files ?? true,
+            headings: config.headings ?? true,
+            includeMissing: config.includeMissing ?? true,
+            ...config,
+        },
+    };
+}
+function fileCompletionSource(options, embed) {
+    return async (context) => {
+        const word = context.matchBefore(embed ? /!\[\[[^\]|#\r\n]*$/u : /(?<!!)\[\[[^\]|#\r\n]*$/u);
+        if (!word) {
+            return null;
+        }
+        const query = word.text.slice(embed ? 3 : 2).trim();
+        const files = await options.adapter.listFiles();
+        const filter = embed
+            ? options.config.embedFilter
+            : options.config.fileFilter;
+        const matches = files
+            .filter((file) => !filter || filter(file))
+            .filter((file) => matchesFileQuery(file, query))
+            .sort(compareFiles);
+        const completionOptions = matches.map((file) => ({
+            label: file.name ?? basename(file.path),
+            detail: dirname(file.path),
+            type: completionType(file, embed),
+            apply(view, _completion, from, to) {
+                replaceOpenWikiLink(view, from, to, formatLink(options, {
+                    embed,
+                    file,
+                    files,
+                    sourcePath: options.sourcePath,
+                    targetPath: file.path,
+                }));
+            },
+        }));
+        if (query && options.config.includeMissing) {
+            completionOptions.push({
+                label: `Link to new note "${query}"`,
+                detail: "Missing target",
+                type: "text",
+                apply(view, _completion, from, to) {
+                    replaceOpenWikiLink(view, from, to, formatLink(options, {
+                        embed,
+                        files,
+                        sourcePath: options.sourcePath,
+                        targetPath: query,
+                    }));
+                },
+            });
+        }
+        return {
+            filter: false,
+            from: word.from,
+            options: completionOptions,
+        };
+    };
+}
+function headingCompletionSource(options) {
+    return async (context) => {
+        const word = context.matchBefore(/!?\[\[[^\]|\r\n]*#[^\]|\r\n]*$/u);
+        if (!word) {
+            return null;
+        }
+        const embed = word.text.startsWith("!");
+        const target = parseWikiTarget(word.text.slice(embed ? 3 : 2));
+        if (target.heading === undefined) {
+            return null;
+        }
+        const files = await options.adapter.listFiles();
+        const file = await resolveCompletionFile(options.adapter, target.path, options.sourcePath, files);
+        const headings = file && options.adapter.getHeadings
+            ? await options.adapter.getHeadings(file)
+            : [];
+        const query = target.heading.toLocaleLowerCase();
+        const suffix = lineSuffix(context, word.to);
+        const alias = aliasFromSuffix(suffix);
+        const completionOptions = headings
+            .filter((heading) => heading.text.toLocaleLowerCase().includes(query))
+            .map((heading) => ({
+            label: heading.text,
+            detail: `H${heading.level}`,
+            type: "property",
+            apply(view, _completion, from, to) {
+                replaceOpenWikiLink(view, from, to, formatLink(options, {
+                    alias,
+                    embed,
+                    file: file ?? undefined,
+                    files,
+                    heading: heading.text,
+                    sourcePath: options.sourcePath,
+                    targetPath: file?.path ?? target.path,
+                }));
+            },
+        }));
+        if (completionOptions.length === 0) {
+            completionOptions.push({
+                label: target.heading.trim() || "Heading",
+                detail: "No matching heading",
+                type: "text",
+            });
+        }
+        return {
+            filter: false,
+            from: word.from,
+            options: completionOptions,
+        };
+    };
+}
+function displayTextCompletionSource(options) {
+    return async (context) => {
+        const word = context.matchBefore(/!?\[\[[^\]\r\n]*\|[^\]\r\n]*$/u);
+        if (!word) {
+            return null;
+        }
+        const embed = word.text.startsWith("!");
+        const target = parseWikiTarget(word.text.slice(embed ? 3 : 2));
+        if (target.alias === undefined) {
+            return null;
+        }
+        const files = await options.adapter.listFiles();
+        const file = await resolveCompletionFile(options.adapter, target.path, options.sourcePath, files);
+        const label = embed &&
+            isImage(file, target.path) &&
+            /^\d+\s*(x\s*\d+)?$/i.test(target.alias)
+            ? `Image size: ${target.alias.trim()} px`
+            : target.alias || "Display text";
+        return {
+            filter: false,
+            from: word.from,
+            options: [
+                {
+                    label,
+                    detail: target.path,
+                    type: "text",
+                    apply(view, _completion, from, to) {
+                        replaceOpenWikiLink(view, from, to, formatLink(options, {
+                            alias: target.alias || undefined,
+                            embed,
+                            file: file ?? undefined,
+                            files,
+                            heading: target.heading,
+                            sourcePath: options.sourcePath,
+                            targetPath: file?.path ?? target.path,
+                        }));
+                    },
+                },
+            ],
+        };
+    };
+}
+function formatLink(options, target) {
+    return (options.config.formatLink ?? formatMiraInternalLink)(target);
+}
+function replaceOpenWikiLink(view, from, to, insert) {
+    const line = view.state.doc.lineAt(from);
+    const suffix = line.text.slice(to - line.from);
+    const marker = suffix.indexOf("]]");
+    view.dispatch({
+        changes: {
+            from,
+            insert,
+            to: marker === -1 ? to : to + marker + 2,
+        },
+        selection: { anchor: from + insert.length },
+        userEvent: "input.complete",
+    });
+}
+function lineSuffix(context, position) {
+    const line = context.state.doc.lineAt(position);
+    return context.state.doc.sliceString(position, line.to);
+}
+function aliasFromSuffix(suffix) {
+    const match = /^\|([^\]\r\n]*)]]/.exec(suffix);
+    return match?.[1] || undefined;
+}
+function parseWikiTarget(value) {
+    const [targetAndHeading = "", alias] = value.split("|", 2);
+    const hash = targetAndHeading.indexOf("#");
+    return {
+        path: hash === -1
+            ? targetAndHeading.trim()
+            : targetAndHeading.slice(0, hash).trim(),
+        heading: hash === -1 ? undefined : targetAndHeading.slice(hash + 1).trim(),
+        alias,
+    };
+}
+async function resolveCompletionFile(adapter, path, sourcePath, files) {
+    if (!path && sourcePath) {
+        return (files.find((file) => normalizePath(file.path) === normalizePath(sourcePath)) ?? {
+            kind: "markdown",
+            path: sourcePath,
+        });
+    }
+    const resolved = await adapter.resolveLink(parseMiraFileTarget(path, sourcePath));
+    const normalizedTarget = normalizePath(path).replace(/\.md$/i, "");
+    const directMatch = files.find((file) => normalizePath(file.path).replace(/\.md$/i, "") === normalizedTarget);
+    const basenameMatches = files.filter((file) => basename(normalizePath(file.path).replace(/\.md$/i, "")) ===
+        basename(normalizedTarget));
+    return (resolved ??
+        directMatch ??
+        (basenameMatches.length === 1 ? basenameMatches[0] : null) ??
+        null);
+}
+function matchesFileQuery(file, query) {
+    const normalizedQuery = query.toLocaleLowerCase();
+    return (!normalizedQuery ||
+        file.path.toLocaleLowerCase().includes(normalizedQuery) ||
+        (file.name ?? "").toLocaleLowerCase().includes(normalizedQuery));
+}
+function compareFiles(left, right) {
+    return (left.name ?? left.path).localeCompare(right.name ?? right.path);
+}
+function completionType(file, embed) {
+    if (!embed) {
+        return "text";
+    }
+    return isImage(file, file.path) ? "image" : "text";
+}
+function isImage(file, path) {
+    return (file?.kind === "image" ||
+        /\.(?:avif|gif|jpe?g|png|svg|webp)$/i.test(file?.path ?? path));
+}
+function normalizePath(path) {
+    return path.replaceAll("\\", "/").replace(/^\.\/+/, "");
+}
+function dirname(path) {
+    const normalized = normalizePath(path);
+    const slash = normalized.lastIndexOf("/");
+    return slash === -1 ? "" : normalized.slice(0, slash);
+}
+function basename(path) {
+    const normalized = normalizePath(path);
+    return normalized.slice(normalized.lastIndexOf("/") + 1);
+}

package/dist/internal/codemirror/markdown/directives.d.ts

@@ -0,0 +1,3 @@
+import { type MarkdownConfig } from "@lezer/markdown";
+export declare const GenericDirectives: MarkdownConfig;
+//# sourceMappingURL=directives.d.ts.map

package/dist/internal/codemirror/markdown/directives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directives.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/directives.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AAwNzB,eAAO,MAAM,iBAAiB,EAAE,cAoE/B,CAAC"}