@lapis-notes/api 0.1.0

package/dist/editor.svelte.d.ts

@@ -0,0 +1,126 @@
+import { EditorState, type Text, type Extension, StateField, EditorSelection as CodeMirrorSelection } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import type { TFile } from "./storage/fs";
+import { EventDispatcher } from "./events";
+import type { App } from "./context.svelte";
+export type EditorPosition = {
+    line: number;
+    ch: number;
+};
+export interface EditorRange {
+    from: EditorPosition;
+    to: EditorPosition;
+}
+export interface EditorRangeOrCaret {
+    from: EditorPosition;
+    to?: EditorPosition;
+}
+export interface EditorChange extends EditorRangeOrCaret {
+    text: string;
+}
+export type EditorCommandName = "goUp" | "goDown" | "goLeft" | "goRight" | "goStart" | "goEnd" | "goWordLeft" | "goWordRight" | "indentMore" | "indentLess" | "newlineAndIndent" | "swapLineUp" | "swapLineDown" | "deleteLine" | "toggleFold" | "foldAll" | "unfoldAll";
+export interface EditorScrollInfo {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    clientWidth: number;
+    clientHeight: number;
+}
+export interface EditorSelection {
+    anchor: EditorPosition;
+    head: EditorPosition;
+}
+export interface EditorSelectionOrCaret {
+    anchor: EditorPosition;
+    head?: EditorPosition;
+}
+export interface EditorTransaction {
+    replaceSelection?: string;
+    changes?: EditorChange[];
+    selections?: EditorRangeOrCaret[];
+    selection?: EditorRangeOrCaret;
+}
+/** Controls whether an editor persists its own debounced document changes. */
+export type EditorPersistence = "vault" | "external";
+export interface MarkdownFileInfo {
+    /** @public */
+    app: App;
+    /** @public */
+    get file(): TFile | null;
+    /** @public */
+    editor?: Editor;
+}
+export declare const editorViewField: StateField<MarkdownFileInfo>;
+export declare const editorInfoField: StateField<MarkdownFileInfo>;
+export declare const editorEditorField: StateField<EditorView | null>;
+export declare const editorLivePreviewField: StateField<boolean>;
+export declare function fromPosition(doc: Text, pos: EditorPosition): number;
+export declare function toPosition(doc: Text, pos: number): EditorPosition;
+export declare function createEditorState(editor: Editor, doc: string, extensions?: Extension[], selection?: CodeMirrorSelection): EditorState;
+export declare function createEditor(editor: Editor, doc: string, ...extensions: Extension[]): EditorView;
+export declare class Editor extends EventDispatcher<{
+    change: [data: string];
+}> {
+    data: string;
+    extensions: Extension[];
+    view: EditorView;
+    file: TFile | null;
+    persistence: EditorPersistence;
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    private destroyed;
+    private application;
+    private readonly pendingChange;
+    constructor(data?: string, extensions?: Extension[], application?: App);
+    /** Bind this editor to the application that owns its view. */
+    bindApplication(application: App): this;
+    /** The owning application, with the global alias retained as fallback. */
+    get app(): App;
+    readonly save: import("lodash-es").DebouncedFunc<() => Promise<void>>;
+    get cm(): EditorView;
+    onChange(data: string): void;
+    /** Queue the latest editor contents for persistence/change notification. */
+    queueChange(data: string): void;
+    /** Flush the latest queued change before a view or embedded surface closes. */
+    flushChanges(): Promise<void>;
+    /** Cancel a queued change when the owning document is intentionally reset. */
+    cancelPendingChanges(): void;
+    getValue(): string;
+    refresh(): void;
+    destroy(): void;
+    trackChanges(callback?: (data: string, editor: Editor) => void): () => void;
+    updateExtensions(extensions: Extension[], context?: Record<string, any>): this;
+    setValue(content: string): void;
+    replaceContent(content: string, options?: {
+        userEvent?: string;
+    }): void;
+    getLine(line: number): string;
+    somethingSelected(): boolean;
+    getRange(from: EditorPosition, to: EditorPosition): string;
+    replaceSelection(replacement: string, origin?: string): void;
+    getCursor(side?: "from" | "to" | "head" | "anchor"): EditorPosition;
+    listSelections(): EditorSelection[];
+    setCursor(pos: EditorPosition | number, ch?: number): void;
+    setSelection(anchor: EditorPosition, head?: EditorPosition): void;
+    setSelections(ranges: EditorSelectionOrCaret[], main?: number): void;
+    replaceRange(replacement: string, from: EditorPosition, to?: EditorPosition, origin?: string): void;
+    focus(): void;
+    blur(): void;
+    hasFocus(): boolean;
+    getScrollInfo(): EditorScrollInfo;
+    scrollTo(x?: number | null, y?: number | null): void;
+    scrollIntoView(range: EditorRange, center?: boolean): void;
+    undo(): void;
+    redo(): void;
+    exec(command: EditorCommandName): void;
+    transaction(tx: EditorTransaction, origin?: string): void;
+    wordAt(pos: EditorPosition): EditorRange | null;
+    posToOffset(pos: EditorPosition): number;
+    offsetToPos(offset: number): EditorPosition;
+    processLines<T>(read: (line: number, lineText: string) => T | null, write: (line: number, lineText: string, value: T | null) => EditorChange | void, ignoreEmpty?: boolean): void;
+    lastLine(): number;
+    setLine(n: number, text: string): void;
+    lineCount(): number;
+    getSelection(): string;
+    getDoc(): this;
+}

package/dist/editor.svelte.js

@@ -0,0 +1,454 @@
+import { Annotation, EditorState, Transaction, StateField, EditorSelection as CodeMirrorSelection, } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { redo as redoCommand, undo as undoCommand } from "@codemirror/commands";
+import { EventDispatcher } from "./events";
+import debounce from "lodash-es/debounce";
+import { resolveApplication } from "./application-compatibility";
+export const editorViewField = StateField.define({
+    create() {
+        return {
+            get app() {
+                return resolveApplication();
+            },
+            file: null,
+        };
+    },
+    update(state) {
+        return state;
+    },
+});
+export const editorInfoField = editorViewField;
+export const editorEditorField = StateField.define({
+    create() {
+        return null;
+    },
+    update(value) {
+        return value;
+    },
+});
+export const editorLivePreviewField = StateField.define({
+    create() {
+        return false;
+    },
+    update(value) {
+        return value;
+    },
+});
+export function fromPosition(doc, pos) {
+    return doc.line(pos.line + 1).from + pos.ch;
+}
+export function toPosition(doc, pos) {
+    const line = doc.lineAt(pos);
+    return {
+        line: line.number - 1,
+        ch: pos - line.from,
+    };
+}
+const syncAnnotation = Annotation.define();
+export function createEditorState(editor, doc, extensions = [], selection) {
+    return EditorState.create({
+        doc,
+        selection,
+        extensions: [
+            editorViewField.init(() => ({
+                get app() {
+                    return editor.app;
+                },
+                editor,
+                get file() {
+                    return editor.file;
+                },
+            })),
+            EditorView.updateListener.of((v) => {
+                if (v.docChanged &&
+                    !v.transactions.some((it) => it.annotation(syncAnnotation))) {
+                    editor.queueChange(v.state.doc.toString());
+                }
+            }),
+            ...extensions,
+        ],
+    });
+}
+export function createEditor(editor, doc, ...extensions) {
+    return new EditorView({
+        doc,
+        dispatchTransactions: (trs, view) => {
+            view.update(trs);
+            const specs = [];
+            let selectionChanged = false;
+            for (let tr of trs) {
+                selectionChanged ||= tr.selection !== undefined;
+                if (!tr.changes.empty && !tr.annotation(syncAnnotation)) {
+                    let annotations = [syncAnnotation.of(true)];
+                    let userEvent = tr.annotation(Transaction.userEvent);
+                    if (userEvent)
+                        annotations.push(Transaction.userEvent.of(userEvent));
+                    specs.push({ changes: tr.changes, annotations });
+                }
+            }
+            if (specs.length || selectionChanged) {
+                editor.app.workspace.dispatch("editor-updated", editor, specs);
+            }
+        },
+        state: createEditorState(editor, doc, extensions),
+    });
+}
+export class Editor extends EventDispatcher {
+    data;
+    extensions;
+    view;
+    file = $state(null);
+    persistence = "vault";
+    id = crypto.randomUUID();
+    destroyed = false;
+    application;
+    pendingChange = debounce(async (content) => {
+        if (this.data === content) {
+            return;
+        }
+        if (this.file && this.persistence === "vault") {
+            await this.app.vault.modify(this.file, content);
+        }
+        this.data = content;
+        this.onChange(content);
+    }, 500);
+    constructor(data = "", extensions = [], application) {
+        super();
+        this.data = data;
+        this.extensions = extensions;
+        this.application = application;
+        this.view = createEditor(this, data, extensions);
+    }
+    /** Bind this editor to the application that owns its view. */
+    bindApplication(application) {
+        this.application = application;
+        return this;
+    }
+    /** The owning application, with the global alias retained as fallback. */
+    get app() {
+        return resolveApplication(this.application);
+    }
+    save = debounce(() => {
+        if (this.file) {
+            return this.app.vault.modify(this.file, this.getValue());
+        }
+        return Promise.resolve();
+    }, 500);
+    get cm() {
+        return this.view;
+    }
+    onChange(data) {
+        this.trigger("change", data);
+    }
+    /** Queue the latest editor contents for persistence/change notification. */
+    queueChange(data) {
+        this.pendingChange(data);
+    }
+    /** Flush the latest queued change before a view or embedded surface closes. */
+    flushChanges() {
+        return Promise.resolve(this.pendingChange.flush()).then(() => undefined);
+    }
+    /** Cancel a queued change when the owning document is intentionally reset. */
+    cancelPendingChanges() {
+        this.pendingChange.cancel();
+    }
+    getValue() {
+        return this.view.state.doc.toString();
+    }
+    refresh() {
+        this.view.requestMeasure();
+    }
+    destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        this.pendingChange.cancel();
+        this.save.cancel();
+        this.view.destroy();
+    }
+    trackChanges(callback) {
+        const editorUpdated = this.app.workspace.on("editor-updated", (editor, transactions) => {
+            if (editor.id !== this.id && editor.file?.path === this.file?.path) {
+                if (this.getValue() !== editor.getValue()) {
+                    this.view.dispatch(...transactions);
+                    this.onChange(this.getValue());
+                    callback?.(this.getValue(), this);
+                }
+            }
+        });
+        const fileChanged = this.app.workspace.on("file-change", (file, event) => {
+            if (file.path === this.file?.path) {
+                if (event !== "delete" && file) {
+                    this.app.vault.read(file).then((contents) => {
+                        if (this.getValue() !== contents) {
+                            this.replaceContent(contents);
+                            this.onChange(this.getValue());
+                            callback?.(this.getValue(), this);
+                        }
+                    });
+                }
+            }
+        });
+        return () => {
+            this.app.workspace.offref(editorUpdated);
+            this.app.workspace.offref(fileChanged);
+        };
+    }
+    updateExtensions(extensions, context) {
+        return this.app.telemetry.measure("editor.update_extensions", (span) => {
+            const ext = this.file?.extension;
+            let editorExtensions = extensions.flat();
+            if (!extensions.length && ext) {
+                editorExtensions = this.app.editorExtensions(ext, context);
+            }
+            span.setAttribute("editor.extension_count", editorExtensions.length);
+            span.setAttribute("file.extension", ext ?? "");
+            const content = this.getValue();
+            const selection = this.view.state.selection;
+            this.extensions = editorExtensions;
+            this.data = content;
+            this.view.setState(createEditorState(this, content, this.extensions, selection));
+            return this;
+        }, {
+            attributes: { "file.extension": this.file?.extension ?? "" },
+            slowThresholdMs: 50,
+        });
+    }
+    setValue(content) {
+        this.app.telemetry.measure("editor.set_value", (span) => {
+            span.setAttribute("editor.content_length", content.length);
+            span.setAttribute("file.extension", this.file?.extension ?? "");
+            this.data = content;
+            this.view.setState(createEditorState(this, content, this.extensions));
+        }, {
+            attributes: { "file.extension": this.file?.extension ?? "" },
+            slowThresholdMs: 50,
+        });
+    }
+    replaceContent(content, options = {}) {
+        this.data = content;
+        const annotations = [syncAnnotation.of(true)];
+        this.view.dispatch({
+            changes: {
+                from: 0,
+                to: this.view.state.doc.length,
+                insert: content,
+            },
+            annotations,
+            ...(options.userEvent ? { userEvent: options.userEvent } : {}),
+        });
+    }
+    getLine(line) {
+        return this.view.state.doc.line(line + 1)?.text ?? "";
+    }
+    somethingSelected() {
+        return !this.view.state.selection.main.empty;
+    }
+    getRange(from, to) {
+        return this.view.state.sliceDoc(this.posToOffset(from), this.posToOffset(to));
+    }
+    replaceSelection(replacement, origin) {
+        this.view.dispatch(this.view.state.replaceSelection(replacement), origin ? { userEvent: origin } : {});
+    }
+    getCursor(side = "head") {
+        const selection = this.view.state.selection.main;
+        const pos = side === "from"
+            ? selection.from
+            : side === "to"
+                ? selection.to
+                : side === "anchor"
+                    ? selection.anchor
+                    : selection.head;
+        return toPosition(this.view.state.doc, pos);
+    }
+    listSelections() {
+        return this.view.state.selection.ranges.map((range) => ({
+            anchor: toPosition(this.view.state.doc, range.anchor),
+            head: toPosition(this.view.state.doc, range.head),
+        }));
+    }
+    setCursor(pos, ch) {
+        const cursor = typeof pos === "number" ? { line: pos, ch: ch ?? 0 } : pos;
+        this.setSelection(cursor, cursor);
+    }
+    setSelection(anchor, head) {
+        this.view.dispatch({
+            selection: {
+                anchor: fromPosition(this.view.state.doc, anchor),
+                head: head ? fromPosition(this.view.state.doc, head) : undefined,
+            },
+            scrollIntoView: true,
+        });
+    }
+    setSelections(ranges, main = 0) {
+        const cmRanges = ranges.map((range) => CodeMirrorSelection.range(this.posToOffset(range.anchor), this.posToOffset(range.head ?? range.anchor)));
+        this.view.dispatch({
+            selection: CodeMirrorSelection.create(cmRanges, main),
+            scrollIntoView: true,
+        });
+    }
+    replaceRange(replacement, from, to, origin) {
+        this.view.dispatch({
+            userEvent: origin,
+            changes: {
+                from: fromPosition(this.view.state.doc, from),
+                to: to ? fromPosition(this.view.state.doc, to) : undefined,
+                insert: replacement,
+            },
+        });
+    }
+    focus() {
+        this.view.focus();
+    }
+    blur() {
+        this.view.contentDOM.blur();
+    }
+    hasFocus() {
+        return this.view.hasFocus;
+    }
+    getScrollInfo() {
+        const el = this.view.scrollDOM;
+        return {
+            left: el.scrollLeft,
+            top: el.scrollTop,
+            width: el.scrollWidth,
+            height: el.scrollHeight,
+            clientWidth: el.clientWidth,
+            clientHeight: el.clientHeight,
+        };
+    }
+    scrollTo(x, y) {
+        this.view.scrollDOM.scrollTo({
+            left: x ?? this.view.scrollDOM.scrollLeft,
+            top: y ?? this.view.scrollDOM.scrollTop,
+        });
+    }
+    scrollIntoView(range, center) {
+        this.view.dispatch({
+            effects: EditorView.scrollIntoView(this.posToOffset(range.from), {
+                y: center ? "center" : "nearest",
+            }),
+        });
+    }
+    undo() {
+        undoCommand(this.view);
+    }
+    redo() {
+        redoCommand(this.view);
+    }
+    exec(command) {
+        const commands = {
+            goUp: () => this.view.dispatch({ selection: { anchor: 0 } }),
+            goStart: () => this.view.dispatch({ selection: { anchor: 0 } }),
+            goEnd: () => this.view.dispatch({
+                selection: { anchor: this.view.state.doc.length },
+            }),
+            deleteLine: () => {
+                const line = this.view.state.doc.lineAt(this.view.state.selection.main.head);
+                this.view.dispatch({
+                    changes: {
+                        from: line.from,
+                        to: Math.min(line.to + 1, this.view.state.doc.length),
+                        insert: "",
+                    },
+                });
+            },
+        };
+        commands[command]?.();
+    }
+    transaction(tx, origin) {
+        const specs = [];
+        if (tx.replaceSelection !== undefined) {
+            specs.push(this.view.state.replaceSelection(tx.replaceSelection));
+        }
+        if (tx.changes) {
+            specs.push(...tx.changes.map((change) => ({
+                changes: {
+                    from: this.posToOffset(change.from),
+                    to: this.posToOffset(change.to ?? change.from),
+                    insert: change.text,
+                },
+            })));
+        }
+        if (tx.selection) {
+            specs.push({
+                selection: {
+                    anchor: this.posToOffset(tx.selection.from),
+                    head: this.posToOffset(tx.selection.to ?? tx.selection.from),
+                },
+            });
+        }
+        if (tx.selections) {
+            specs.push({
+                selection: CodeMirrorSelection.create(tx.selections.map((selection) => CodeMirrorSelection.range(this.posToOffset(selection.from), this.posToOffset(selection.to ?? selection.from)))),
+            });
+        }
+        if (origin) {
+            specs.push({ userEvent: origin });
+        }
+        if (specs.length) {
+            this.view.dispatch(...specs);
+        }
+    }
+    wordAt(pos) {
+        const lineText = this.getLine(pos.line);
+        const wordPattern = /[\p{L}\p{N}_-]+/gu;
+        for (const match of lineText.matchAll(wordPattern)) {
+            const start = match.index ?? 0;
+            const end = start + match[0].length;
+            if (pos.ch >= start && pos.ch <= end) {
+                return {
+                    from: { line: pos.line, ch: start },
+                    to: { line: pos.line, ch: end },
+                };
+            }
+        }
+        return null;
+    }
+    posToOffset(pos) {
+        return fromPosition(this.view.state.doc, pos);
+    }
+    offsetToPos(offset) {
+        return toPosition(this.view.state.doc, offset);
+    }
+    processLines(read, write, ignoreEmpty) {
+        const changes = [];
+        for (let line = 0; line < this.lineCount(); line++) {
+            const lineText = this.getLine(line);
+            if (ignoreEmpty && !lineText.trim()) {
+                continue;
+            }
+            const value = read(line, lineText);
+            const change = write(line, lineText, value);
+            if (change) {
+                changes.push(change);
+            }
+        }
+        this.transaction({ changes });
+    }
+    lastLine() {
+        return this.view.state.doc.lines - 1;
+    }
+    setLine(n, text) {
+        const line = this.view.state.doc.line(n + 1);
+        if (line) {
+            this.view.dispatch({
+                changes: { from: line.from, to: line.to, insert: text },
+            });
+        }
+    }
+    lineCount() {
+        return this.view.state.doc.lines;
+    }
+    getSelection() {
+        const selection = this.view.state.selection.main;
+        if (selection) {
+            return this.view.state.sliceDoc(selection.from, selection.to);
+        }
+        return "";
+    }
+    getDoc() {
+        return this;
+    }
+}

package/dist/embed-registry.d.ts

@@ -0,0 +1,15 @@
+import type { App } from "./context.svelte";
+export type EmbedViewHandle = {
+    destroy?: () => void | Promise<void>;
+};
+export type EmbedView = (props: {
+    app: App;
+    containerEl: HTMLElement;
+    state: Record<string, any>;
+}) => void | EmbedViewHandle;
+export declare class EmbedRegistry {
+    readonly embedByExtension: Record<string, EmbedView>;
+    constructor();
+    register(extension: string, view: EmbedView): () => void;
+    get(extension: string): EmbedView | null;
+}

package/dist/embed-registry.js

@@ -0,0 +1,16 @@
+export class EmbedRegistry {
+    embedByExtension = {};
+    constructor() { }
+    register(extension, view) {
+        const normalizedExtension = extension.toLowerCase();
+        this.embedByExtension[normalizedExtension] = view;
+        return () => {
+            if (this.embedByExtension[normalizedExtension] === view) {
+                delete this.embedByExtension[normalizedExtension];
+            }
+        };
+    }
+    get(extension) {
+        return this.embedByExtension[extension.toLowerCase()] ?? null;
+    }
+}