@lapis-notes/api 0.1.0

package/dist/source-text-file-view.d.ts

@@ -0,0 +1,25 @@
+import { TextFileView } from "./view.svelte";
+import type { WorkspaceLeaf } from "./workspace.svelte";
+/**
+ * Source-only text editor view backed by the API NoteEditor.
+ *
+ * Language behavior is supplied through the workspace editor-extension
+ * registry; this view intentionally adds no Markdown rendering policy.
+ *
+ * @public
+ */
+export declare class SourceTextFileView extends TextFileView {
+    #private;
+    constructor(leaf: WorkspaceLeaf, viewType: string, acceptedExtensions: string | readonly string[]);
+    getViewType(): string;
+    getViewData(): string;
+    setViewData(data: string, clear?: boolean): void;
+    clear(): void;
+    load(): void;
+    unload(): void;
+    canAcceptExtension(extension: string): boolean;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    getDisplayText(): string;
+    showSearch(replace?: boolean): void;
+}

package/dist/source-text-file-view.js

@@ -0,0 +1,78 @@
+import { openSearchPanel } from "@codemirror/search";
+import { NoteEditor } from "./components/editor";
+import { mountComponent, } from "./hooks/mountComponent.svelte";
+import { TextFileView } from "./view.svelte";
+/**
+ * Source-only text editor view backed by the API NoteEditor.
+ *
+ * Language behavior is supplied through the workspace editor-extension
+ * registry; this view intentionally adds no Markdown rendering policy.
+ *
+ * @public
+ */
+export class SourceTextFileView extends TextFileView {
+    #viewType;
+    #acceptedExtensions;
+    #component = null;
+    constructor(leaf, viewType, acceptedExtensions) {
+        super(leaf);
+        this.#viewType = viewType;
+        this.#acceptedExtensions = new Set((typeof acceptedExtensions === "string"
+            ? [acceptedExtensions]
+            : acceptedExtensions).map(normalizeExtension));
+    }
+    getViewType() {
+        return this.#viewType;
+    }
+    getViewData() {
+        return this.editor.getValue();
+    }
+    setViewData(data, clear = false) {
+        void clear;
+        this.data = data;
+        this.editor.setValue(data);
+    }
+    clear() {
+        this.data = "";
+        this.editor.setValue("");
+    }
+    load() {
+        if (!this.containerEl)
+            return;
+        this.unload();
+        this.containerEl.replaceChildren();
+        this.containerEl.classList.add("text-view", "source-text-file-view");
+        this.actions = [];
+        this.#component = mountComponent(NoteEditor, {
+            target: this.containerEl,
+            props: {
+                app: this.app,
+                leaf: this.leaf,
+                editor: this.editor,
+            },
+        });
+    }
+    unload() {
+        this.#component?.destroy();
+        this.#component = null;
+    }
+    canAcceptExtension(extension) {
+        return this.#acceptedExtensions.has(normalizeExtension(extension));
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+    getDisplayText() {
+        return this.file?.baseName ?? "";
+    }
+    showSearch(replace) {
+        void replace;
+        openSearchPanel(this.editor.view);
+    }
+}
+function normalizeExtension(extension) {
+    return extension.trim().replace(/^\./, "").toLowerCase();
+}

package/dist/status-bar.svelte.d.ts

@@ -0,0 +1,29 @@
+import type { ContextKeyService } from "./context-keys.svelte";
+import type { Menu } from "./menu.svelte";
+export type StatusBarAlignment = "left" | "right";
+export interface StatusBarItemDescriptor {
+    id: string;
+    text?: string;
+    segments?: string[];
+    icon?: string;
+    spin?: boolean;
+    tooltip?: string;
+    command?: string;
+    buildMenu?: (menu: Menu) => void;
+    when?: string;
+    alignment?: StatusBarAlignment;
+    priority?: number;
+    sourcePlugin?: string;
+}
+interface RegisteredStatusBarItem extends StatusBarItemDescriptor {
+    sequence: number;
+}
+export declare class StatusBarManager {
+    #private;
+    readonly items: Record<string, RegisteredStatusBarItem>;
+    registerItem(item: StatusBarItemDescriptor): () => void;
+    upsertItem(item: StatusBarItemDescriptor): void;
+    unregisterItem(id: string): void;
+    getVisibleItems(alignment: StatusBarAlignment, contextKeys: ContextKeyService): StatusBarItemDescriptor[];
+}
+export {};

package/dist/status-bar.svelte.js

@@ -0,0 +1,72 @@
+function sameSegments(left, right) {
+    if (left === right)
+        return true;
+    if (!left || !right || left.length !== right.length)
+        return false;
+    return left.every((value, index) => value === right[index]);
+}
+function sameVisibleStatusBarItem(left, right) {
+    return (left.id === right.id &&
+        left.text === right.text &&
+        sameSegments(left.segments, right.segments) &&
+        left.icon === right.icon &&
+        left.spin === right.spin &&
+        left.tooltip === right.tooltip &&
+        left.command === right.command &&
+        left.when === right.when &&
+        (left.alignment ?? "right") === (right.alignment ?? "right") &&
+        (left.priority ?? 0) === (right.priority ?? 0) &&
+        left.sourcePlugin === right.sourcePlugin);
+}
+export class StatusBarManager {
+    #sequence = 0;
+    #listeners = new Set();
+    items = $state({});
+    registerItem(item) {
+        this.upsertItem(item);
+        return () => {
+            delete this.items[item.id];
+            this.notify();
+        };
+    }
+    upsertItem(item) {
+        const existing = this.items[item.id];
+        const next = {
+            alignment: "right",
+            priority: 0,
+            ...existing,
+            ...item,
+            sequence: existing?.sequence ?? this.#sequence++,
+        };
+        if (existing && sameVisibleStatusBarItem(existing, next)) {
+            return;
+        }
+        this.items[item.id] = next;
+        this.notify();
+    }
+    unregisterItem(id) {
+        if (this.items[id]) {
+            delete this.items[id];
+            this.notify();
+        }
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener();
+        return () => this.#listeners.delete(listener);
+    }
+    notify() {
+        for (const listener of this.#listeners)
+            listener();
+    }
+    getVisibleItems(alignment, contextKeys) {
+        return Object.values(this.items)
+            .filter((item) => (item.alignment ?? "right") === alignment &&
+            contextKeys.evaluate(item.when))
+            .sort((left, right) => {
+            const priority = (left.priority ?? 0) - (right.priority ?? 0);
+            return priority !== 0 ? priority : left.sequence - right.sequence;
+        })
+            .map(({ sequence: _sequence, ...item }) => item);
+    }
+}