@lapis-notes/api 0.1.0

package/dist/workspace-layout-commands.js

@@ -0,0 +1,72 @@
+import { promptConfirm } from "./prompt-confirm";
+import { FuzzySuggestModal, SuggestModal } from "./suggest";
+class SaveWorkspaceLayoutModal extends SuggestModal {
+    existingNames;
+    onSave;
+    constructor(app, existingNames, onSave) {
+        super(app);
+        this.existingNames = existingNames;
+        this.onSave = onSave;
+        this.setPlaceholder("Layout name");
+        this.emptyStateText = "Type a name to save this layout";
+        this.setInstructions([
+            { command: "↵", purpose: "Save" },
+            { command: "esc", purpose: "Cancel" },
+        ]);
+    }
+    getSuggestions(query) {
+        const name = query.trim();
+        const matches = this.existingNames.filter((existing) => existing.toLocaleLowerCase().includes(name.toLocaleLowerCase()));
+        if (name && !matches.includes(name))
+            return [name, ...matches];
+        return matches.length > 0 ? matches : this.existingNames;
+    }
+    renderSuggestion(value, el) {
+        el.textContent = this.existingNames.includes(value)
+            ? `Replace “${value}”`
+            : `Save as “${value}”`;
+    }
+    onChooseSuggestion(item) {
+        const name = item.trim();
+        if (!name)
+            return;
+        void (async () => {
+            if (this.existingNames.includes(name)) {
+                const replace = await promptConfirm(this.app.workspace.getCommandHostDocument(), {
+                    title: "Replace workspace layout",
+                    description: `Replace the saved layout “${name}” with the current workspace?`,
+                    confirmLabel: "Replace",
+                });
+                if (!replace)
+                    return;
+            }
+            await this.onSave(name);
+        })();
+    }
+}
+class LoadWorkspaceLayoutModal extends FuzzySuggestModal {
+    names;
+    onLoad;
+    constructor(app, names, onLoad) {
+        super(app);
+        this.names = names;
+        this.onLoad = onLoad;
+        this.setPlaceholder("Load workspace layout");
+        this.emptyStateText = "No saved workspace layouts";
+    }
+    getItems() {
+        return this.names;
+    }
+    getItemText(item) {
+        return item;
+    }
+    onChooseItem(item) {
+        void this.onLoad(item);
+    }
+}
+export function promptSaveWorkspaceLayout(app, existingNames, onSave) {
+    new SaveWorkspaceLayoutModal(app, existingNames, onSave).open();
+}
+export function promptLoadWorkspaceLayout(app, names, onLoad) {
+    new LoadWorkspaceLayoutModal(app, names, onLoad).open();
+}

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

@@ -0,0 +1,92 @@
+/**
+ * Pure workspace layout normalizer.
+ *
+ * Repairs common corruption in workspace JSON before it is hydrated into the
+ * live Svelte model:
+ *
+ * - Mismatched sizes arrays (length ≠ children count, non-finite values)
+ * - Out-of-range or non-integer currentTab indices
+ * - Empty floating / popout windows (dropped — popout windows cannot be restored
+ *   across sessions)
+ * - Stale hiddenLeafIds / collapsed / panelSizes entries in sidebar groups that
+ *   refer to leaf ids no longer present in the group's children
+ * - Unknown or malformed child node types (dropped gracefully)
+ * - Missing required fields filled with safe defaults
+ *
+ * The function is pure (no side effects, no imports from the live model) and
+ * always returns a structurally valid WorkspaceJson even when the input is
+ * empty, partial, or fully corrupted.
+ */
+type WorkspaceLeafJson = {
+    id: string;
+    type: "leaf";
+    state: {
+        type: string;
+        state: Record<string, unknown>;
+        icon: string;
+        title: string;
+    };
+};
+type WorkspaceSidebarGroupJson = {
+    id: string;
+    type: "sidebar-group";
+    name: string;
+    icon?: string;
+    hiddenLeafIds?: string[];
+    collapsed?: Record<string, boolean>;
+    panelSizes?: Record<string, number>;
+    selectedLeafId?: string;
+    children: WorkspaceLeafJson[];
+};
+type WorkspaceTabsChildJson = WorkspaceLeafJson | WorkspaceSidebarGroupJson;
+type WorkspaceTabsJson = {
+    id: string;
+    type: "tabs";
+    stacked: boolean;
+    children: WorkspaceTabsChildJson[];
+    currentTab: number;
+};
+type WorkspaceSplitJson = {
+    id: string;
+    type: "split";
+    direction: "horizontal" | "vertical";
+    sizes: number[];
+    children: Array<WorkspaceSplitJson | WorkspaceTabsJson>;
+};
+type WorkspaceSidedockJson = WorkspaceSplitJson & {
+    width: string;
+};
+type WorkspaceBottomPanelJson = WorkspaceTabsJson & {
+    height: string;
+};
+type WorkspaceWindowJson = {
+    id: string;
+    type: "floating";
+    mode?: "floating";
+    displayState?: "collapsed" | "minimized";
+    direction: "horizontal" | "vertical";
+    sizes: number[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    children: Array<WorkspaceSplitJson | WorkspaceTabsJson>;
+};
+/** Canonical workspace layout shape returned by the normalizer. */
+export type WorkspaceJson = {
+    main: WorkspaceSplitJson;
+    left: WorkspaceSidedockJson;
+    right: WorkspaceSidedockJson;
+    bottom: WorkspaceBottomPanelJson;
+    floating?: WorkspaceWindowJson[];
+    active?: string;
+};
+/**
+ * Normalizes raw workspace layout JSON before it is loaded into the live
+ * workspace model.
+ *
+ * Always returns a structurally valid {@link WorkspaceJson} even when the input
+ * is `null`, empty, partial, or corrupted.
+ */
+export declare function normalizeWorkspaceJson(raw: unknown): WorkspaceJson;
+export {};

package/dist/workspace-layout-normalizer.js

@@ -0,0 +1,301 @@
+/**
+ * Pure workspace layout normalizer.
+ *
+ * Repairs common corruption in workspace JSON before it is hydrated into the
+ * live Svelte model:
+ *
+ * - Mismatched sizes arrays (length ≠ children count, non-finite values)
+ * - Out-of-range or non-integer currentTab indices
+ * - Empty floating / popout windows (dropped — popout windows cannot be restored
+ *   across sessions)
+ * - Stale hiddenLeafIds / collapsed / panelSizes entries in sidebar groups that
+ *   refer to leaf ids no longer present in the group's children
+ * - Unknown or malformed child node types (dropped gracefully)
+ * - Missing required fields filled with safe defaults
+ *
+ * The function is pure (no side effects, no imports from the live model) and
+ * always returns a structurally valid WorkspaceJson even when the input is
+ * empty, partial, or fully corrupted.
+ */
+import { uniqueId } from "./utils";
+// ---------------------------------------------------------------------------
+// Low-level helpers
+// ---------------------------------------------------------------------------
+function ensureId(raw) {
+    return typeof raw === "string" && raw.length > 0 ? raw : uniqueId();
+}
+function ensureDirection(raw) {
+    return raw === "horizontal" ? "horizontal" : "vertical";
+}
+/**
+ * Returns a sizes array of exactly `count` positive finite numbers. Any missing
+ * or invalid slot is filled with 50 (equal-weight default).
+ */
+function repairSizes(sizes, count) {
+    const arr = Array.isArray(sizes) ? sizes : [];
+    const result = [];
+    for (let i = 0; i < count; i++) {
+        const v = arr[i];
+        result.push(typeof v === "number" && isFinite(v) && v > 0 ? v : 50);
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Node normalizers
+// ---------------------------------------------------------------------------
+function normalizeLeaf(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (r.type !== "leaf")
+        return null;
+    const s = r.state && typeof r.state === "object"
+        ? r.state
+        : {};
+    return {
+        id: ensureId(r.id),
+        type: "leaf",
+        state: {
+            type: typeof s.type === "string" ? s.type : "empty",
+            state: s.state && typeof s.state === "object"
+                ? s.state
+                : {},
+            icon: typeof s.icon === "string" ? s.icon : "",
+            title: typeof s.title === "string" ? s.title : "",
+        },
+    };
+}
+function normalizeSidebarGroup(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (r.type !== "sidebar-group")
+        return null;
+    const children = (Array.isArray(r.children) ? r.children : [])
+        .map(normalizeLeaf)
+        .filter((c) => c !== null);
+    const childIds = new Set(children.map((c) => c.id));
+    const hiddenLeafIds = Array.isArray(r.hiddenLeafIds)
+        ? r.hiddenLeafIds.filter((id) => typeof id === "string" && childIds.has(id))
+        : undefined;
+    const collapsed = r.collapsed && typeof r.collapsed === "object"
+        ? Object.fromEntries(Object.entries(r.collapsed)
+            .filter(([k]) => childIds.has(k))
+            .map(([k, v]) => [k, Boolean(v)]))
+        : undefined;
+    const panelSizes = r.panelSizes && typeof r.panelSizes === "object"
+        ? Object.fromEntries(Object.entries(r.panelSizes)
+            .filter(([k]) => childIds.has(k))
+            .map(([k, v]) => [k, typeof v === "number" ? v : 50]))
+        : undefined;
+    return {
+        id: ensureId(r.id),
+        type: "sidebar-group",
+        name: typeof r.name === "string" ? r.name : "",
+        ...(r.icon !== undefined
+            ? { icon: typeof r.icon === "string" ? r.icon : "" }
+            : {}),
+        ...(hiddenLeafIds && hiddenLeafIds.length > 0 ? { hiddenLeafIds } : {}),
+        ...(collapsed && Object.keys(collapsed).length > 0 ? { collapsed } : {}),
+        ...(panelSizes && Object.keys(panelSizes).length > 0 ? { panelSizes } : {}),
+        ...(typeof r.selectedLeafId === "string" &&
+            r.selectedLeafId.length > 0 &&
+            children.some((child) => child.id === r.selectedLeafId)
+            ? { selectedLeafId: r.selectedLeafId }
+            : {}),
+        children,
+    };
+}
+function normalizeTabsChild(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (r.type === "sidebar-group")
+        return normalizeSidebarGroup(raw);
+    return normalizeLeaf(raw);
+}
+function normalizeTabs(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (r.type !== "tabs")
+        return null;
+    const children = (Array.isArray(r.children) ? r.children : [])
+        .map(normalizeTabsChild)
+        .filter((c) => c !== null);
+    const rawIndex = r.currentTab;
+    const currentTab = typeof rawIndex === "number" &&
+        Number.isInteger(rawIndex) &&
+        rawIndex >= 0 &&
+        rawIndex < children.length
+        ? rawIndex
+        : 0;
+    return {
+        id: ensureId(r.id),
+        type: "tabs",
+        stacked: r.stacked === true,
+        children,
+        currentTab,
+    };
+}
+function normalizeSplitChild(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (r.type === "split")
+        return normalizeSplitInner(raw);
+    if (r.type === "tabs")
+        return normalizeTabs(raw);
+    return null;
+}
+function normalizeSplitInner(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (r.type !== "split")
+        return null;
+    const direction = ensureDirection(r.direction);
+    const children = (Array.isArray(r.children) ? r.children : [])
+        .map(normalizeSplitChild)
+        .filter((c) => c !== null);
+    if (children.length === 0)
+        return null;
+    return {
+        id: ensureId(r.id),
+        type: "split",
+        direction,
+        sizes: repairSizes(r.sizes, children.length),
+        children,
+    };
+}
+function normalizeRootSplit(raw) {
+    const result = normalizeSplitInner(raw);
+    if (result)
+        return result;
+    // Fallback: a single empty-children tabs group. WorkspaceTabs.loadJson
+    // creates an empty leaf automatically when children is empty.
+    return {
+        id: uniqueId(),
+        type: "split",
+        direction: "vertical",
+        sizes: [100],
+        children: [
+            {
+                id: uniqueId(),
+                type: "tabs",
+                stacked: false,
+                children: [],
+                currentTab: 0,
+            },
+        ],
+    };
+}
+function normalizeSidedock(raw, defaultWidth) {
+    const width = raw && typeof raw === "object" && typeof raw.width === "string"
+        ? raw.width
+        : defaultWidth;
+    const result = normalizeSplitInner(raw);
+    if (result)
+        return { ...result, width };
+    // Fallback: empty sidedock. WorkspaceSidedock.loadJson tolerates no children.
+    return {
+        id: uniqueId(),
+        type: "split",
+        direction: "vertical",
+        sizes: [],
+        children: [],
+        width,
+    };
+}
+function normalizeBottomPanel(raw) {
+    const input = raw && typeof raw === "object" ? raw : {};
+    const tabs = normalizeTabs(raw) ?? {
+        id: typeof input.id === "string" && input.id.length > 0
+            ? input.id
+            : "bottom-panel",
+        type: "tabs",
+        stacked: false,
+        children: [],
+        currentTab: 0,
+    };
+    return {
+        ...tabs,
+        height: typeof input.height === "string" &&
+            /^(?:\d+(?:\.\d+)?)(?:px|rem|em|%)?$/iu.test(input.height.trim())
+            ? input.height
+            : "0px",
+    };
+}
+function normalizeFloatingWindow(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (r.type !== "floating")
+        return null;
+    // Popout windows cannot be restored across sessions — drop them.
+    if (r.mode === "popout")
+        return null;
+    const children = (Array.isArray(r.children) ? r.children : [])
+        .map(normalizeSplitChild)
+        .filter((c) => c !== null);
+    // Drop windows with no leaf content.
+    if (!hasAnyLeaf(children))
+        return null;
+    const toNum = (v, fallback) => typeof v === "number" && isFinite(v) ? v : fallback;
+    const rawDisplayState = r.displayState;
+    const displayState = rawDisplayState === "collapsed" || rawDisplayState === "minimized"
+        ? rawDisplayState
+        : undefined;
+    return {
+        id: ensureId(r.id),
+        type: "floating",
+        mode: "floating",
+        ...(displayState !== undefined ? { displayState } : {}),
+        direction: ensureDirection(r.direction),
+        sizes: repairSizes(r.sizes, children.length),
+        x: toNum(r.x, 100),
+        y: toNum(r.y, 100),
+        width: toNum(r.width, 800),
+        height: toNum(r.height, 600),
+        children,
+    };
+}
+function hasAnyLeaf(nodes) {
+    for (const node of nodes) {
+        if (node.type === "tabs") {
+            if (node.children.length > 0)
+                return true;
+        }
+        else {
+            if (hasAnyLeaf(node.children))
+                return true;
+        }
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Normalizes raw workspace layout JSON before it is loaded into the live
+ * workspace model.
+ *
+ * Always returns a structurally valid {@link WorkspaceJson} even when the input
+ * is `null`, empty, partial, or corrupted.
+ */
+export function normalizeWorkspaceJson(raw) {
+    const r = raw && typeof raw === "object" ? raw : {};
+    const floating = Array.isArray(r.floating)
+        ? r.floating
+            .map(normalizeFloatingWindow)
+            .filter((w) => w !== null)
+        : [];
+    return {
+        main: normalizeRootSplit(r.main),
+        left: normalizeSidedock(r.left, "22rem"),
+        right: normalizeSidedock(r.right, "0px"),
+        bottom: normalizeBottomPanel(r.bottom),
+        ...(floating.length > 0 ? { floating } : {}),
+        ...(typeof r.active === "string" && r.active ? { active: r.active } : {}),
+    };
+}

package/dist/workspace-layouts.d.ts

@@ -0,0 +1,7 @@
+export declare const NAMED_WORKSPACES_FILE = "workspaces.json";
+export interface NamedWorkspaceStore {
+    workspaces: Record<string, unknown>;
+    active?: string;
+}
+export declare function parseNamedWorkspaceStore(raw: string): NamedWorkspaceStore;
+export declare function serializeNamedWorkspaceStore(store: NamedWorkspaceStore): string;

package/dist/workspace-layouts.js

@@ -0,0 +1,23 @@
+export const NAMED_WORKSPACES_FILE = "workspaces.json";
+export function parseNamedWorkspaceStore(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        const workspaces = parsed.workspaces &&
+            typeof parsed.workspaces === "object" &&
+            !Array.isArray(parsed.workspaces)
+            ? parsed.workspaces
+            : {};
+        return {
+            workspaces,
+            ...(typeof parsed.active === "string" && parsed.active
+                ? { active: parsed.active }
+                : {}),
+        };
+    }
+    catch {
+        return { workspaces: {} };
+    }
+}
+export function serializeNamedWorkspaceStore(store) {
+    return `${JSON.stringify(store, null, 2)}\n`;
+}

package/dist/workspace-trust.d.ts

@@ -0,0 +1,32 @@
+import { EventDispatcher } from "./events";
+import { type DataAdapter, type KeyValueStore } from "./storage";
+export interface WorkspaceTrustState {
+    trusted: boolean;
+    identity: string;
+    updatedAt: number | null;
+}
+export interface WorkspaceTrustRequest {
+    reason?: string;
+    pluginId?: string | null;
+    capability?: string | null;
+}
+type WorkspaceTrustEvents = {
+    changed: [state: WorkspaceTrustState];
+    requested: [request: WorkspaceTrustRequest];
+};
+export declare class WorkspaceTrustService extends EventDispatcher<WorkspaceTrustEvents> {
+    readonly identity: string;
+    private readonly storage;
+    private readyPromise;
+    private state;
+    constructor(adapter: DataAdapter, store?: KeyValueStore);
+    get trusted(): boolean;
+    getState(): WorkspaceTrustState;
+    ready(): Promise<WorkspaceTrustState>;
+    grant(): Promise<WorkspaceTrustState>;
+    revoke(): Promise<WorkspaceTrustState>;
+    request(request?: WorkspaceTrustRequest): Promise<boolean>;
+    private load;
+    private updateState;
+}
+export {};

package/dist/workspace-trust.js

@@ -0,0 +1,72 @@
+import { EventDispatcher } from "./events";
+import { getAdapterVaultId, getDefaultVaultStateStore, ScopedVaultStore, } from "./storage";
+const WORKSPACE_TRUST_KEY = "state";
+export class WorkspaceTrustService extends EventDispatcher {
+    identity;
+    storage;
+    readyPromise = null;
+    state;
+    constructor(adapter, store = getDefaultVaultStateStore()) {
+        super();
+        this.identity = getAdapterVaultId(adapter);
+        this.storage = new ScopedVaultStore(this.identity, "workspace-trust", store);
+        this.state = {
+            trusted: true,
+            identity: this.identity,
+            updatedAt: null,
+        };
+    }
+    get trusted() {
+        return this.state.trusted;
+    }
+    getState() {
+        return { ...this.state };
+    }
+    async ready() {
+        this.readyPromise ??= this.load();
+        return this.readyPromise;
+    }
+    async grant() {
+        await this.ready();
+        return this.updateState(true);
+    }
+    async revoke() {
+        await this.ready();
+        return this.updateState(false);
+    }
+    async request(request = {}) {
+        await this.ready();
+        if (this.state.trusted) {
+            return true;
+        }
+        this.emit("requested", {
+            reason: request.reason,
+            pluginId: request.pluginId ?? null,
+            capability: request.capability ?? null,
+        });
+        return false;
+    }
+    async load() {
+        const persisted = await this.storage.get(WORKSPACE_TRUST_KEY);
+        this.state = {
+            trusted: persisted?.trusted !== false,
+            identity: this.identity,
+            updatedAt: typeof persisted?.updatedAt === "number" ? persisted.updatedAt : null,
+        };
+        return this.getState();
+    }
+    async updateState(trusted) {
+        const next = {
+            trusted,
+            identity: this.identity,
+            updatedAt: Date.now(),
+        };
+        await this.storage.set(WORKSPACE_TRUST_KEY, {
+            trusted: next.trusted,
+            updatedAt: next.updatedAt,
+        });
+        this.state = next;
+        this.emit("changed", this.getState());
+        return this.getState();
+    }
+}