@lapis-notes/api 0.1.0

package/dist/view.svelte.d.ts

@@ -0,0 +1,215 @@
+import type { DataAdapter, TFile } from "./storage/fs";
+import type { WorkspaceLeaf } from "./workspace.svelte";
+import type { Menu } from "./menu.svelte";
+import { Editor } from "./editor.svelte";
+import type { App } from "./context.svelte";
+import "./enhance";
+import { EventDispatcher, type EventNames, type EventRef, type ValidEventTypes } from "./events";
+import type { Scope } from "./command.svelte";
+/**
+ * Base lifecycle helper used throughout the public API.
+ *
+ * Components can own child components and cleanup callbacks so complex views
+ * and plugins can tear themselves down predictably.
+ *
+ * @public
+ */
+export declare abstract class Component<Events extends ValidEventTypes = Record<string, any>> extends EventDispatcher<Events> {
+    children: Component[];
+    private unloaders;
+    loaded: boolean;
+    protected _containerEl: HTMLElement;
+    get containerEl(): HTMLElement;
+    set containerEl(el: HTMLElement);
+    /**
+     * Load this component and its children
+     *
+     * @public
+     */
+    load(): void;
+    /**
+     * Override this to load your component
+     *
+     * @abstract
+     * @public
+     */
+    onload(): Promise<void> | void;
+    protected loadAsync(): Promise<void>;
+    /**
+     * Unload this component and its children
+     *
+     * @public
+     */
+    unload(): void;
+    protected unloadAsync(): Promise<void>;
+    /**
+     * Override this to unload your component
+     *
+     * @abstract
+     * @public
+     */
+    onunload(): void;
+    private cleanupAsync;
+    /**
+     * Adds a child component, loading it if this component is loaded
+     *
+     * @public
+     */
+    addChild<T extends Component>(component: T): T;
+    /**
+     * Removes a child component, unloading it
+     *
+     * @public
+     */
+    removeChild<T extends Component>(component: T): T;
+    /**
+     * Registers a callback to be called when unloading
+     *
+     * @public
+     */
+    register(cb: () => any): void;
+    registerEvent<T extends ValidEventTypes, K extends EventNames<T>>(eventRef: EventRef<T, K, any>): void;
+    registerInterval(id: ReturnType<typeof setInterval>): void;
+    /**
+     * Registers an DOM event to be detached when unloading
+     *
+     * @public
+     */
+    registerDomEvent<K extends keyof HTMLElementEventMap>(el: HTMLElement, type: K, callback: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    registerDomEvent<K extends keyof DocumentEventMap>(el: Document, type: K, callback: (this: HTMLElement, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    registerDomEvent<K extends keyof WindowEventMap>(el: Window, type: K, callback: (this: HTMLElement, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+}
+/**
+ * Additional metadata returned from view-state transitions.
+ *
+ * @public
+ */
+export interface ViewStateResult {
+    /**
+     * Set this to true to indicate that there is a state change which should be
+     * recorded in the navigation history.
+     *
+     * @public
+     */
+    history: boolean;
+}
+/**
+ * Serialized workspace state for a single leaf.
+ *
+ * @public
+ */
+export interface ViewState {
+    /** @public */
+    type: string;
+    /** @public */
+    state?: Record<string, unknown>;
+    /** @public */
+    active?: boolean;
+    /** @public */
+    pinned?: boolean;
+    /** @public */
+    group?: WorkspaceLeaf;
+}
+/**
+ * Header breadcrumb contributed by a view. Keep the leaf filename in the
+ * header title rather than this list.
+ *
+ * @public
+ */
+export interface ViewBreadcrumb {
+    id: string;
+    label: string;
+    onSelect?: () => void;
+}
+/**
+ * Base class for anything that can be mounted inside a workspace leaf.
+ *
+ * @public
+ */
+export declare abstract class View extends Component {
+    icon: string;
+    leaf: WorkspaceLeaf;
+    scope: Scope | null;
+    protected state: Record<string, unknown>;
+    constructor(leaf?: WorkspaceLeaf);
+    get containerEl(): HTMLElement;
+    get app(): App;
+    /** @public */
+    protected abstract onOpen(): Promise<void>;
+    /** @public */
+    protected abstract onClose(): Promise<void>;
+    /** @public */
+    abstract getViewType(): string;
+    getState(): Record<string, unknown>;
+    setState(state: Record<string, unknown>, result?: ViewStateResult): Promise<void>;
+    getIcon(): string;
+    abstract getDisplayText(): string;
+    getBreadcrumbFilePath(): string | null;
+    getBreadcrumbs(): ViewBreadcrumb[];
+    onPaneMenu(menu: Menu, source: "more-options" | "tab-header" | string): void;
+}
+export declare class EmptyView extends View {
+    private component;
+    constructor(leaf?: WorkspaceLeaf);
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    load(): void;
+    unload(): void;
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+}
+/**
+ * View base class with an action bar and content area.
+ *
+ * @public
+ */
+export declare abstract class ItemView extends View {
+    actions: Array<{
+        icon: string;
+        title: string;
+        callback: (evt: MouseEvent) => any;
+        disabled?: boolean;
+    }>;
+    constructor(leaf?: WorkspaceLeaf);
+    get contentEl(): HTMLElement;
+    unload(): void;
+    addAction(icon: string, title: string, callback: (evt: MouseEvent) => any, options?: {
+        disabled?: boolean;
+    }): void;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+}
+/**
+ * Item view base class that is backed by a vault file.
+ *
+ * @public
+ */
+export declare abstract class FileView extends ItemView {
+    file: TFile | null;
+    constructor(leaf?: WorkspaceLeaf);
+    getBreadcrumbFilePath(): string | null;
+    abstract onLoadFile(file: TFile): Promise<void>;
+    abstract onUnloadFile(file: TFile): Promise<void>;
+    abstract onRename(file: TFile): Promise<void>;
+    abstract canAcceptExtension(extension: string): boolean;
+}
+/**
+ * File view base class for text-backed editors.
+ *
+ * @public
+ */
+export declare abstract class TextFileView extends FileView {
+    editor: Editor;
+    data: string;
+    constructor(leaf?: WorkspaceLeaf);
+    get adapter(): DataAdapter;
+    abstract getViewData(): string;
+    abstract setViewData(data: string, clear?: boolean): void;
+    abstract clear(): void;
+    onLoadFile(file: TFile): Promise<void>;
+    getIcon(): string;
+    onRename(file: TFile): Promise<void>;
+    onUnloadFile(file: TFile): Promise<void>;
+    save(clear?: boolean): Promise<void>;
+}

package/dist/view.svelte.js

@@ -0,0 +1,381 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { DateTime } from "luxon";
+import { Editor } from "./editor.svelte";
+import { mount, unmount } from "svelte";
+import EmptyViewComponent from "./components/empty-view/empty-view.svelte";
+import "./enhance";
+import { EventDispatcher, } from "./events";
+import { t } from "./localization-manager.svelte";
+/**
+ * Base lifecycle helper used throughout the public API.
+ *
+ * Components can own child components and cleanup callbacks so complex views
+ * and plugins can tear themselves down predictably.
+ *
+ * @public
+ */
+export class Component extends EventDispatcher {
+    children = [];
+    unloaders = new Set();
+    loaded = false;
+    _containerEl = $state(createDiv());
+    get containerEl() {
+        return this._containerEl;
+    }
+    set containerEl(el) {
+        this._containerEl = el;
+    }
+    /**
+     * Load this component and its children
+     *
+     * @public
+     */
+    load() {
+        if (this.loaded) {
+            return;
+        }
+        this.onload();
+        this.children.forEach((it) => it.load());
+        this.loaded = true;
+    }
+    /**
+     * Override this to load your component
+     *
+     * @abstract
+     * @public
+     */
+    onload() { }
+    async loadAsync() {
+        if (this.loaded) {
+            return;
+        }
+        try {
+            await this.onload();
+            for (const child of [...this.children]) {
+                await child.loadAsync();
+            }
+            this.loaded = true;
+        }
+        catch (error) {
+            try {
+                await this.cleanupAsync(false);
+            }
+            catch (cleanupError) {
+                console.error("Failed to rollback component load", cleanupError);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Unload this component and its children
+     *
+     * @public
+     */
+    unload() {
+        if (!this.loaded) {
+            return;
+        }
+        this.children.forEach((child) => child.unload());
+        this.unloaders.forEach((cb) => cb());
+        this.unloaders.clear();
+        this.children = [];
+        this.onunload();
+        this.loaded = false;
+    }
+    async unloadAsync() {
+        if (!this.loaded &&
+            this.children.length === 0 &&
+            this.unloaders.size === 0) {
+            return;
+        }
+        await this.cleanupAsync(this.loaded);
+        this.loaded = false;
+    }
+    /**
+     * Override this to unload your component
+     *
+     * @abstract
+     * @public
+     */
+    onunload() { }
+    async cleanupAsync(callOnUnload) {
+        let firstError = null;
+        for (const child of [...this.children].reverse()) {
+            try {
+                await child.unloadAsync();
+            }
+            catch (error) {
+                firstError ??= error;
+            }
+        }
+        this.children = [];
+        for (const cb of [...this.unloaders]) {
+            try {
+                cb();
+            }
+            catch (error) {
+                firstError ??= error;
+            }
+        }
+        this.unloaders.clear();
+        if (callOnUnload) {
+            try {
+                await this.onunload();
+            }
+            catch (error) {
+                firstError ??= error;
+            }
+        }
+        if (firstError) {
+            throw firstError;
+        }
+    }
+    /**
+     * Adds a child component, loading it if this component is loaded
+     *
+     * @public
+     */
+    addChild(component) {
+        if (this.children.indexOf(component) === -1) {
+            this.children.push(component);
+            if (this.loaded) {
+                component.load();
+            }
+        }
+        return component;
+    }
+    /**
+     * Removes a child component, unloading it
+     *
+     * @public
+     */
+    removeChild(component) {
+        const index = this.children.indexOf(component);
+        if (index > -1) {
+            this.children.splice(index, 1);
+        }
+        return component;
+    }
+    /**
+     * Registers a callback to be called when unloading
+     *
+     * @public
+     */
+    register(cb) {
+        this.unloaders.add(cb);
+    }
+    registerEvent(eventRef) {
+        this.register(() => eventRef.dispatcher.offref(eventRef));
+    }
+    registerInterval(id) {
+        this.register(() => clearInterval(id));
+    }
+    registerDomEvent(el, type, callback, options) {
+        el.addEventListener(type, callback, options);
+        this.register(() => el.removeEventListener(type, callback, options));
+    }
+}
+/**
+ * Base class for anything that can be mounted inside a workspace leaf.
+ *
+ * @public
+ */
+export class View extends Component {
+    icon = "";
+    leaf;
+    scope = null;
+    state = $state({});
+    constructor(leaf) {
+        super();
+        if (leaf) {
+            this.leaf = leaf;
+            leaf.view = this;
+        }
+    }
+    get containerEl() {
+        return this.leaf.containerEl;
+    }
+    get app() {
+        return this.leaf.app;
+    }
+    getState() {
+        return { ...this.state };
+    }
+    setState(state, result) {
+        this.state = { ...state };
+        return Promise.resolve();
+    }
+    getIcon() {
+        return this.icon;
+    }
+    /**
+     * Vault path used for parent-path header breadcrumbs. File views return
+     * the open file; other views MAY return a related path or null.
+     *
+     * @public
+     */
+    getBreadcrumbFilePath() {
+        return null;
+    }
+    /**
+     * Prefix breadcrumbs rendered before parent-path segments.
+     *
+     * @public
+     */
+    getBreadcrumbs() {
+        return [];
+    }
+    onPaneMenu(menu, source) { }
+}
+export class EmptyView extends View {
+    component;
+    constructor(leaf) {
+        super(leaf);
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+    load() {
+        if (this.containerEl) {
+            this.containerEl.innerHTML = "";
+            this.component = mount(EmptyViewComponent, {
+                target: this.containerEl,
+                props: {
+                    app: this.app,
+                    onClose: () => this.leaf.close(),
+                },
+            });
+        }
+    }
+    unload() {
+        if (this.component) {
+            unmount(this.component);
+            this.component = null;
+        }
+    }
+    getViewType() {
+        return "empty";
+    }
+    getDisplayText() {
+        const missingViewType = this.state["__missingViewType"];
+        if (typeof missingViewType === "string" && missingViewType.length > 0) {
+            return missingViewType;
+        }
+        return t("base/empty-view", "New Tab");
+    }
+    getIcon() {
+        const missingViewType = this.state["__missingViewType"];
+        if (typeof missingViewType === "string" && missingViewType.length > 0) {
+            return "ghost";
+        }
+        return "file";
+    }
+}
+/**
+ * View base class with an action bar and content area.
+ *
+ * @public
+ */
+export class ItemView extends View {
+    actions = $state([]);
+    constructor(leaf) {
+        super(leaf);
+    }
+    get contentEl() {
+        return this.leaf.contentEl;
+    }
+    unload() {
+        super.unload();
+    }
+    addAction(icon, title, callback, options) {
+        this.actions.push({ icon, title, callback, disabled: options?.disabled });
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+}
+/**
+ * Item view base class that is backed by a vault file.
+ *
+ * @public
+ */
+export class FileView extends ItemView {
+    file = $state();
+    constructor(leaf) {
+        super(leaf);
+    }
+    getBreadcrumbFilePath() {
+        return this.file?.path ?? null;
+    }
+}
+/**
+ * File view base class for text-backed editors.
+ *
+ * @public
+ */
+export class TextFileView extends FileView {
+    editor;
+    data = $state("");
+    constructor(leaf) {
+        super(leaf);
+        this.editor = new Editor(this.data, [], leaf?.application);
+    }
+    get adapter() {
+        return this.app.vault.adapter;
+    }
+    async onLoadFile(file) {
+        return this.app.telemetry.measureAsync("view.text_file.on_load_file", async (span) => {
+            span.setAttribute("view.type", this.getViewType());
+            span.setAttribute("file.extension", file.extension);
+            const contents = await this.app.telemetry.measureAsync("vault.read", async () => this.app.vault.read(file), {
+                attributes: {
+                    "file.extension": file.extension,
+                    "view.type": this.getViewType(),
+                },
+                slowThresholdMs: 100,
+            });
+            this.file = file.copy();
+            this.editor.file = file;
+            await this.setState({ ...this.getState(), file: file.path });
+            this.editor.extensions = this.app.editorExtensions(this.file.extension, this.getState());
+            this.data = contents;
+            this.setViewData(contents, true);
+        }, {
+            attributes: {
+                "view.type": this.getViewType(),
+                "file.extension": file.extension,
+            },
+            slowThresholdMs: 150,
+        });
+    }
+    getIcon() {
+        return "file";
+    }
+    onRename(file) {
+        this.file = file.copy();
+        this.editor.file = file;
+        this.setState({ ...this.getState(), file: file.path });
+        return Promise.resolve();
+    }
+    onUnloadFile(file) {
+        this.setState({ ...this.getState(), file: "" });
+        return Promise.resolve();
+    }
+    save(clear) {
+        return this.app.vault
+            .modify(this.file, this.data, {
+            mtime: DateTime.now().toMillis(),
+        })
+            .then(() => {
+            if (clear) {
+                this.clear();
+            }
+        });
+    }
+}

package/dist/vite-env.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="svelte" />
+/// <reference types="vite/client" />

package/dist/workspace-host-internal.d.ts

@@ -0,0 +1,7 @@
+import type { AppShellController } from "@lapismd/design-core/workspace/core";
+import type { Workspace } from "./workspace.svelte";
+export interface WorkspaceHostBinding {
+    readonly controller: AppShellController;
+}
+export declare function setWorkspaceHostBinding(workspace: Workspace, binding: WorkspaceHostBinding): void;
+export declare function resolveWorkspaceHostBinding(workspace: Workspace): WorkspaceHostBinding | undefined;

package/dist/workspace-host-internal.js

@@ -0,0 +1,7 @@
+const workspaceHostBindings = new WeakMap();
+export function setWorkspaceHostBinding(workspace, binding) {
+    workspaceHostBindings.set(workspace, Object.freeze(binding));
+}
+export function resolveWorkspaceHostBinding(workspace) {
+    return workspaceHostBindings.get(workspace);
+}

package/dist/workspace-host.d.ts

@@ -0,0 +1,10 @@
+import type { Workspace } from "./workspace.svelte";
+import { type WorkspaceHostBinding } from "./workspace-host-internal";
+export type { WorkspaceHostBinding } from "./workspace-host-internal";
+/**
+ * Return the renderer binding owned by a Lapis workspace.
+ *
+ * This host-only entry point intentionally keeps design-core controller types
+ * out of the root Obsidian-compatible API export.
+ */
+export declare function getWorkspaceHostBinding(workspace: Workspace): WorkspaceHostBinding;

package/dist/workspace-host.js

@@ -0,0 +1,14 @@
+import { resolveWorkspaceHostBinding, } from "./workspace-host-internal";
+/**
+ * Return the renderer binding owned by a Lapis workspace.
+ *
+ * This host-only entry point intentionally keeps design-core controller types
+ * out of the root Obsidian-compatible API export.
+ */
+export function getWorkspaceHostBinding(workspace) {
+    const binding = resolveWorkspaceHostBinding(workspace);
+    if (!binding) {
+        throw new Error("Workspace host binding is not initialized");
+    }
+    return binding;
+}

package/dist/workspace-layout-commands.d.ts

@@ -0,0 +1,3 @@
+import type { App } from "./context.svelte";
+export declare function promptSaveWorkspaceLayout(app: App, existingNames: string[], onSave: (name: string) => Promise<void>): void;
+export declare function promptLoadWorkspaceLayout(app: App, names: string[], onLoad: (name: string) => Promise<void>): void;