@lapismd/mira 0.0.1

package/dist/internal/codemirror/base/slash-commands.d.ts

@@ -0,0 +1,61 @@
+import { type Completion, type CompletionSource } from "@codemirror/autocomplete";
+import { type Extension } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+export type MiraTextRange = {
+    from: number;
+    to: number;
+};
+export type MiraTemplateSelection = number | {
+    anchor: number;
+    head?: number;
+};
+export type MiraMarkdownTemplate = {
+    markdown: string;
+    selection?: MiraTemplateSelection;
+};
+export type MiraSlashCommandContext = {
+    view?: unknown;
+    query: string;
+    range: MiraTextRange;
+    getValue: () => string;
+    setValue: (value: string) => void;
+    focus: () => void;
+    insertMarkdown: (markdown: string, selection?: MiraTemplateSelection) => void;
+    replaceRange: (markdown: string, range?: Partial<MiraTextRange>, selection?: MiraTemplateSelection) => void;
+};
+export type MiraSlashCommand = {
+    id: string;
+    label: string;
+    description?: string;
+    group?: string;
+    keywords?: string[];
+    boost?: number;
+    insert?: string | MiraMarkdownTemplate;
+    run?: (context: MiraSlashCommandContext) => void;
+};
+export type MiraSlashCommandUi = "popover" | "autocomplete";
+export type MiraSlashCommandTriggerScope = "line-start" | "after-whitespace";
+export type MiraSlashCommandOptions = {
+    commands?: readonly MiraSlashCommand[];
+    enabled?: boolean;
+    ui?: MiraSlashCommandUi;
+    triggerScope?: MiraSlashCommandTriggerScope;
+};
+export type MiraSlashSnippetOptions<TId extends string = string> = {
+    id: TId;
+    label: string;
+    description?: string;
+    group?: string;
+    keywords?: string[];
+    boost?: number;
+    markdown: string;
+    marker?: string;
+};
+export declare function createSlashCommandExtensions(options?: MiraSlashCommandOptions): Extension[];
+export declare function createSlashCommandCompletionSource(commands: readonly MiraSlashCommand[], options?: Pick<MiraSlashCommandOptions, "triggerScope">): CompletionSource;
+export declare function createMarkdownTemplate(markdown: string, marker?: string): MiraMarkdownTemplate;
+export declare function createSlashSnippet<TId extends string = string>(options: MiraSlashSnippetOptions<TId>): MiraSlashCommand & {
+    id: TId;
+};
+export declare function applyMarkdownTemplate(view: EditorView, template: string | MiraMarkdownTemplate, from: number, to: number, completion?: Completion): void;
+//# sourceMappingURL=slash-commands.d.ts.map

package/dist/internal/codemirror/base/slash-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash-commands.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/base/slash-commands.ts"],"names":[],"mappings":"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"}

package/dist/internal/codemirror/base/slash-commands.js

@@ -0,0 +1,463 @@
+import { pickedCompletion, } from "@codemirror/autocomplete";
+import { EditorState, Prec, StateEffect, StateField, } from "@codemirror/state";
+import { EditorView, keymap, showTooltip, } from "@codemirror/view";
+export function createSlashCommandExtensions(options = {}) {
+    if (options.enabled === false || !options.commands?.length) {
+        return [];
+    }
+    const triggerScope = options.triggerScope ?? "line-start";
+    if (options.ui === "autocomplete") {
+        const source = createSlashCommandCompletionSource(options.commands, {
+            triggerScope,
+        });
+        return [
+            EditorState.languageData.of(() => [
+                {
+                    autocomplete: source,
+                },
+            ]),
+        ];
+    }
+    return createSlashCommandPopoverExtensions(options.commands, triggerScope);
+}
+export function createSlashCommandCompletionSource(commands, options = {}) {
+    const triggerScope = options.triggerScope ?? "after-whitespace";
+    return (context) => {
+        const match = matchSlashCommand(context, triggerScope);
+        if (!match) {
+            return null;
+        }
+        const options = commands
+            .filter((command) => commandMatchesQuery(command, match.query))
+            .map((command) => completionForSlashCommand(command, match));
+        if (options.length === 0) {
+            return null;
+        }
+        return {
+            from: match.from + 1,
+            to: match.to,
+            options,
+            filter: false,
+        };
+    };
+}
+export function createMarkdownTemplate(markdown, marker = "<|>") {
+    if (!marker) {
+        return { markdown };
+    }
+    const selection = markdown.indexOf(marker);
+    if (selection === -1) {
+        return { markdown };
+    }
+    return {
+        markdown: markdown.replace(marker, ""),
+        selection,
+    };
+}
+export function createSlashSnippet(options) {
+    const { markdown, marker, ...command } = options;
+    return {
+        ...command,
+        insert: createMarkdownTemplate(markdown, marker),
+    };
+}
+export function applyMarkdownTemplate(view, template, from, to, completion) {
+    const normalized = normalizeMarkdownTemplate(template);
+    const selection = selectionForTemplate(normalized, from);
+    const transaction = {
+        changes: {
+            from,
+            to,
+            insert: normalized.markdown,
+        },
+        selection,
+        scrollIntoView: true,
+    };
+    if (completion) {
+        transaction.annotations = pickedCompletion.of(completion);
+    }
+    view.dispatch(transaction);
+}
+function createSlashCommandPopoverExtensions(commands, triggerScope) {
+    const close = StateEffect.define();
+    const select = StateEffect.define();
+    const field = StateField.define({
+        create(state) {
+            return resolveSlashPopoverState(state, commands, triggerScope, null);
+        },
+        update(value, transaction) {
+            let nextSelection = null;
+            for (const effect of transaction.effects) {
+                if (effect.is(close)) {
+                    return null;
+                }
+                if (effect.is(select)) {
+                    nextSelection = effect.value;
+                }
+            }
+            if (!transaction.docChanged && !transaction.selection) {
+                if (value && nextSelection !== null) {
+                    return {
+                        ...value,
+                        selectedIndex: wrapIndex(nextSelection, value.commands.length),
+                    };
+                }
+                return value;
+            }
+            const next = resolveSlashPopoverState(transaction.state, commands, triggerScope, value);
+            if (!next) {
+                return null;
+            }
+            if (nextSelection !== null) {
+                return {
+                    ...next,
+                    selectedIndex: wrapIndex(nextSelection, next.commands.length),
+                };
+            }
+            return next;
+        },
+        provide: (activeField) => showTooltip.compute([activeField], (state) => {
+            const value = state.field(activeField);
+            return value
+                ? slashCommandTooltip(value, { close, select, field: activeField })
+                : null;
+        }),
+    });
+    return [
+        slashCommandTheme,
+        field,
+        Prec.highest(keymap.of(slashCommandKeymap({ close, select, field }))),
+    ];
+}
+function resolveSlashPopoverState(state, commands, triggerScope, previous) {
+    if (state.selection.ranges.length !== 1 || !state.selection.main.empty) {
+        return null;
+    }
+    const match = matchSlashCommandAt(state, state.selection.main.head, triggerScope);
+    if (!match) {
+        return null;
+    }
+    const matchingCommands = commands.filter((command) => commandMatchesQuery(command, match.query));
+    if (matchingCommands.length === 0) {
+        return null;
+    }
+    const selectedIndex = previous?.match.from === match.from && previous.match.query === match.query
+        ? clampIndex(previous.selectedIndex, matchingCommands.length)
+        : 0;
+    return {
+        match,
+        commands: matchingCommands,
+        selectedIndex,
+    };
+}
+function slashCommandKeymap(controls) {
+    return [
+        {
+            key: "ArrowDown",
+            run(view) {
+                return moveSlashSelection(view, controls, 1);
+            },
+        },
+        {
+            key: "ArrowUp",
+            run(view) {
+                return moveSlashSelection(view, controls, -1);
+            },
+        },
+        {
+            key: "Enter",
+            run(view) {
+                const state = view.state.field(controls.field, false);
+                const command = state?.commands[state.selectedIndex];
+                if (!state || !command) {
+                    return false;
+                }
+                applySlashCommand(view, command, state.match);
+                view.dispatch({
+                    effects: controls.close.of(null),
+                });
+                return true;
+            },
+        },
+        {
+            key: "Escape",
+            run(view) {
+                const state = view.state.field(controls.field, false);
+                if (!state) {
+                    return false;
+                }
+                view.dispatch({
+                    effects: controls.close.of(null),
+                });
+                return true;
+            },
+        },
+    ];
+}
+function moveSlashSelection(view, controls, direction) {
+    const state = view.state.field(controls.field, false);
+    if (!state) {
+        return false;
+    }
+    view.dispatch({
+        effects: controls.select.of(state.selectedIndex + direction),
+    });
+    return true;
+}
+function slashCommandTooltip(value, controls) {
+    return {
+        pos: value.match.from,
+        create(view) {
+            return new SlashCommandTooltipView(view, value, controls);
+        },
+    };
+}
+class SlashCommandTooltipView {
+    dom = document.createElement("div");
+    #view;
+    #value;
+    #controls;
+    constructor(view, value, controls) {
+        this.#view = view;
+        this.#value = value;
+        this.#controls = controls;
+        this.dom.className = "mira-slash-menu";
+        this.dom.setAttribute("role", "listbox");
+        this.render();
+    }
+    update(update) {
+        const next = update.state.field(this.#controls.field, false);
+        if (!next) {
+            return;
+        }
+        this.#value = next;
+        this.render();
+    }
+    render() {
+        this.dom.replaceChildren();
+        const groups = groupSlashCommands(this.#value.commands);
+        let index = 0;
+        for (const [group, commands] of groups) {
+            if (group) {
+                const groupElement = document.createElement("div");
+                groupElement.className = "mira-slash-menu__group";
+                groupElement.textContent = group;
+                this.dom.append(groupElement);
+            }
+            for (const command of commands) {
+                const commandIndex = index;
+                const button = document.createElement("button");
+                const isActive = commandIndex === this.#value.selectedIndex;
+                button.type = "button";
+                button.tabIndex = -1;
+                button.className = isActive
+                    ? "mira-slash-menu__item mira-slash-menu__item--active"
+                    : "mira-slash-menu__item";
+                button.setAttribute("role", "option");
+                button.setAttribute("aria-selected", isActive ? "true" : "false");
+                button.onmousedown = (event) => {
+                    event.preventDefault();
+                };
+                button.onclick = () => {
+                    applySlashCommand(this.#view, command, this.#value.match);
+                    this.#view.dispatch({
+                        effects: this.#controls.close.of(null),
+                    });
+                };
+                const title = document.createElement("span");
+                title.className = "mira-slash-menu__item-title";
+                title.textContent = command.label;
+                button.append(title);
+                if (command.description) {
+                    const description = document.createElement("span");
+                    description.className = "mira-slash-menu__item-description";
+                    description.textContent = command.description;
+                    button.append(description);
+                }
+                this.dom.append(button);
+                index += 1;
+            }
+        }
+        const activeElement = this.dom.querySelector(".mira-slash-menu__item--active");
+        activeElement?.scrollIntoView?.({ block: "nearest" });
+    }
+}
+function groupSlashCommands(commands) {
+    const groups = new Map();
+    for (const command of commands) {
+        const group = command.group ?? "";
+        const groupCommands = groups.get(group);
+        if (groupCommands) {
+            groupCommands.push(command);
+        }
+        else {
+            groups.set(group, [command]);
+        }
+    }
+    return Array.from(groups);
+}
+function applySlashCommand(view, command, match) {
+    if (command.run) {
+        command.run(createSlashCommandContext(view, match, match.to));
+        return;
+    }
+    applyMarkdownTemplate(view, command.insert ?? command.label, match.from, match.to);
+}
+function completionForSlashCommand(command, match) {
+    return {
+        label: command.label,
+        detail: command.description,
+        info: command.group,
+        type: "keyword",
+        section: command.group,
+        boost: command.boost,
+        apply(view, completion, _from, to) {
+            if (command.run) {
+                command.run(createSlashCommandContext(view, match, to));
+                return;
+            }
+            applyMarkdownTemplate(view, command.insert ?? command.label, match.from, to, completion);
+        },
+    };
+}
+function createSlashCommandContext(view, match, to) {
+    const defaultRange = {
+        from: match.from,
+        to,
+    };
+    return {
+        view,
+        query: match.query,
+        range: defaultRange,
+        getValue: () => view.state.doc.toString(),
+        setValue(value) {
+            view.dispatch({
+                changes: {
+                    from: 0,
+                    to: view.state.doc.length,
+                    insert: value,
+                },
+            });
+        },
+        focus: () => view.focus(),
+        insertMarkdown(markdown, selection) {
+            applyMarkdownTemplate(view, { markdown, selection }, defaultRange.from, defaultRange.to);
+        },
+        replaceRange(markdown, range = defaultRange, selection) {
+            applyMarkdownTemplate(view, { markdown, selection }, range.from ?? defaultRange.from, range.to ?? defaultRange.to);
+        },
+    };
+}
+function matchSlashCommand(context, triggerScope) {
+    return matchSlashCommandAt(context.state, context.pos, triggerScope);
+}
+function matchSlashCommandAt(state, pos, triggerScope) {
+    const line = state.doc.lineAt(pos);
+    const beforeCursor = state.doc.sliceString(line.from, pos);
+    const match = triggerScope === "line-start"
+        ? /^(\s*)\/([^\s/]*)$/u.exec(beforeCursor)
+        : /(^|\s)\/([^\s/]*)$/u.exec(beforeCursor);
+    if (!match) {
+        return null;
+    }
+    const slashOffset = match.index + (match[1]?.length ?? 0);
+    return {
+        from: line.from + slashOffset,
+        to: pos,
+        query: match[2] ?? "",
+    };
+}
+function commandMatchesQuery(command, query) {
+    if (!query) {
+        return true;
+    }
+    const normalizedQuery = normalizeSearchText(query);
+    return [command.label, command.description, ...(command.keywords ?? [])]
+        .filter((value) => typeof value === "string")
+        .some((value) => normalizeSearchText(value).includes(normalizedQuery));
+}
+function normalizeSearchText(value) {
+    return value.toLowerCase().replace(/\s+/gu, " ").trim();
+}
+function normalizeMarkdownTemplate(template) {
+    return typeof template === "string" ? { markdown: template } : template;
+}
+function selectionForTemplate(template, from) {
+    const fallbackOffset = template.markdown.length;
+    const selection = template.selection ?? fallbackOffset;
+    if (typeof selection === "number") {
+        const offset = from + clampOffset(selection, template.markdown);
+        return { anchor: offset };
+    }
+    const anchor = from + clampOffset(selection.anchor, template.markdown);
+    const head = from + clampOffset(selection.head ?? selection.anchor, template.markdown);
+    return { anchor, head };
+}
+function clampOffset(offset, markdown) {
+    return Math.max(0, Math.min(markdown.length, offset));
+}
+function clampIndex(index, length) {
+    return Math.max(0, Math.min(length - 1, index));
+}
+function wrapIndex(index, length) {
+    return ((index % length) + length) % length;
+}
+const slashCommandTheme = EditorView.theme({
+    ".mira-slash-menu": {
+        backgroundColor: "var(--popover, var(--mira-popover, var(--mira-widget-background)))",
+        border: "1px solid var(--border, var(--mira-border))",
+        borderRadius: "var(--radius-m, var(--mira-radius))",
+        boxShadow: "var(--mira-widget-shadow)",
+        boxSizing: "border-box",
+        color: "var(--popover-foreground, var(--mira-popover-foreground, var(--mira-foreground)))",
+        fontFamily: "var(--font-interface, var(--mira-font-sans, ui-sans-serif, system-ui, sans-serif))",
+        fontSize: "0.875rem",
+        lineHeight: "1.25rem",
+        maxHeight: "min(18rem, 50vh)",
+        overflowY: "auto",
+        padding: "0.25rem",
+        scrollPadding: "0.25rem",
+        width: "min(18rem, calc(100vw - 24px))",
+    },
+    ".mira-slash-menu__group": {
+        color: "var(--muted-foreground, var(--mira-muted-foreground))",
+        fontSize: "0.75rem",
+        fontWeight: "600",
+        letterSpacing: "0.02em",
+        lineHeight: "1.2",
+        padding: "0.375rem 0.5rem",
+        textTransform: "uppercase",
+    },
+    ".mira-slash-menu__item": {
+        appearance: "none",
+        backgroundColor: "transparent",
+        border: "0",
+        borderRadius: "var(--radius-s, 4px)",
+        color: "inherit",
+        cursor: "pointer",
+        display: "grid",
+        font: "inherit",
+        gap: "0.125rem",
+        padding: "0.375rem 0.5rem",
+        textAlign: "left",
+        width: "100%",
+    },
+    ".mira-slash-menu__item:hover, .mira-slash-menu__item--active": {
+        backgroundColor: "var(--accent, var(--background-modifier-hover, var(--mira-accent-soft)))",
+        color: "var(--accent-foreground, var(--mira-foreground))",
+    },
+    ".mira-slash-menu__item-title": {
+        color: "inherit",
+        fontSize: "0.875rem",
+        fontWeight: "500",
+        lineHeight: "1.25",
+    },
+    ".mira-slash-menu__item-description": {
+        color: "var(--muted-foreground, var(--mira-muted-foreground))",
+        fontSize: "0.75rem",
+        lineHeight: "1.25",
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap",
+    },
+});

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

@@ -0,0 +1,9 @@
+import type { Extension } from "@codemirror/state";
+import type { MiraFileAdapter, MiraMarkdownAuthoringConfig } from "@lapismd/mira/extensions";
+export type MiraMarkdownAuthoringOptions = {
+    config?: MiraMarkdownAuthoringConfig;
+    fileAdapter?: MiraFileAdapter;
+    sourcePath?: string;
+};
+export declare function createMarkdownAuthoringExtensions(options?: MiraMarkdownAuthoringOptions): Extension[];
+//# sourceMappingURL=authoring.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/authoring.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EACV,eAAe,EACf,2BAA2B,EAC5B,MAAM,0BAA0B,CAAC;AAKlC,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,CAAC,EAAE,2BAA2B,CAAC;IACrC,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,wBAAgB,iCAAiC,CAC/C,OAAO,GAAE,4BAAiC,GACzC,SAAS,EAAE,CAUb"}

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

@@ -0,0 +1,14 @@
+import { createMarkdownCompletionExtensions } from "./completion";
+import { createMarkdownInputHandlerExtensions } from "./input-handlers";
+import { createMarkdownSmartPasteExtension } from "./paste";
+export function createMarkdownAuthoringExtensions(options = {}) {
+    return [
+        createMarkdownCompletionExtensions({
+            config: options.config?.completions,
+            fileAdapter: options.fileAdapter,
+            sourcePath: options.sourcePath,
+        }),
+        createMarkdownSmartPasteExtension(options.config?.smartPaste),
+        createMarkdownInputHandlerExtensions(options.config?.inputHandlers),
+    ].flat();
+}

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

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

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

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