@bpmnkit/plugins 0.0.8

package/dist/storage/db.d.ts

@@ -0,0 +1,99 @@
+import type { FileContentRecord, FileRecord, ProjectMruRecord, ProjectRecord, WorkspaceRecord } from "./types.js";
+export declare const db: {
+    workspaces: {
+        get(key: string): Promise<WorkspaceRecord | undefined>;
+        add(record: WorkspaceRecord): Promise<void>;
+        update(key: string, changes: Partial<WorkspaceRecord>): Promise<void>;
+        delete(key: string): Promise<void>;
+        orderBy(field: string): {
+            toArray: () => Promise<WorkspaceRecord[]>;
+        };
+        where(index: string): {
+            equals: (value: string) => {
+                toArray: () => Promise<WorkspaceRecord[]>;
+                sortBy: (field: string) => Promise<WorkspaceRecord[]>;
+                delete: () => Promise<void>;
+            };
+        };
+        filter: (pred: (item: WorkspaceRecord) => boolean) => {
+            toArray: () => Promise<WorkspaceRecord[]>;
+        };
+    };
+    projects: {
+        get(key: string): Promise<ProjectRecord | undefined>;
+        add(record: ProjectRecord): Promise<void>;
+        update(key: string, changes: Partial<ProjectRecord>): Promise<void>;
+        delete(key: string): Promise<void>;
+        orderBy(field: string): {
+            toArray: () => Promise<ProjectRecord[]>;
+        };
+        where(index: string): {
+            equals: (value: string) => {
+                toArray: () => Promise<ProjectRecord[]>;
+                sortBy: (field: string) => Promise<ProjectRecord[]>;
+                delete: () => Promise<void>;
+            };
+        };
+        filter: (pred: (item: ProjectRecord) => boolean) => {
+            toArray: () => Promise<ProjectRecord[]>;
+        };
+    };
+    files: {
+        get(key: string): Promise<FileRecord | undefined>;
+        add(record: FileRecord): Promise<void>;
+        update(key: string, changes: Partial<FileRecord>): Promise<void>;
+        delete(key: string): Promise<void>;
+        orderBy(field: string): {
+            toArray: () => Promise<FileRecord[]>;
+        };
+        where(index: string): {
+            equals: (value: string) => {
+                toArray: () => Promise<FileRecord[]>;
+                sortBy: (field: string) => Promise<FileRecord[]>;
+                delete: () => Promise<void>;
+            };
+        };
+        filter: (pred: (item: FileRecord) => boolean) => {
+            toArray: () => Promise<FileRecord[]>;
+        };
+    };
+    fileContents: {
+        get(key: string): Promise<FileContentRecord | undefined>;
+        add(record: FileContentRecord): Promise<void>;
+        update(key: string, changes: Partial<FileContentRecord>): Promise<void>;
+        delete(key: string): Promise<void>;
+        orderBy(field: string): {
+            toArray: () => Promise<FileContentRecord[]>;
+        };
+        where(index: string): {
+            equals: (value: string) => {
+                toArray: () => Promise<FileContentRecord[]>;
+                sortBy: (field: string) => Promise<FileContentRecord[]>;
+                delete: () => Promise<void>;
+            };
+        };
+        filter: (pred: (item: FileContentRecord) => boolean) => {
+            toArray: () => Promise<FileContentRecord[]>;
+        };
+    };
+    projectMru: {
+        get(key: string): Promise<ProjectMruRecord | undefined>;
+        add(record: ProjectMruRecord): Promise<void>;
+        update(key: string, changes: Partial<ProjectMruRecord>): Promise<void>;
+        delete(key: string): Promise<void>;
+        orderBy(field: string): {
+            toArray: () => Promise<ProjectMruRecord[]>;
+        };
+        where(index: string): {
+            equals: (value: string) => {
+                toArray: () => Promise<ProjectMruRecord[]>;
+                sortBy: (field: string) => Promise<ProjectMruRecord[]>;
+                delete: () => Promise<void>;
+            };
+        };
+        filter: (pred: (item: ProjectMruRecord) => boolean) => {
+            toArray: () => Promise<ProjectMruRecord[]>;
+        };
+    };
+};
+//# sourceMappingURL=db.d.ts.map

package/dist/storage/db.js

@@ -0,0 +1,116 @@
+const DB_NAME = "bpmn-sdk-storage";
+// Dexie 4.x internally stored version 10 for user-space version 1.
+// Use 12 to add the projectMru object store.
+const DB_VERSION = 12;
+let _db = null;
+function openDb() {
+    return new Promise((resolve, reject) => {
+        const r = indexedDB.open(DB_NAME, DB_VERSION);
+        r.onupgradeneeded = () => {
+            const d = r.result;
+            // Guard each store: Dexie may have already created them at version 10.
+            if (!d.objectStoreNames.contains("workspaces")) {
+                const ws = d.createObjectStore("workspaces", { keyPath: "id" });
+                ws.createIndex("name", "name");
+            }
+            if (!d.objectStoreNames.contains("projects")) {
+                const prj = d.createObjectStore("projects", { keyPath: "id" });
+                prj.createIndex("workspaceId", "workspaceId");
+            }
+            if (!d.objectStoreNames.contains("files")) {
+                const fl = d.createObjectStore("files", { keyPath: "id" });
+                fl.createIndex("projectId", "projectId");
+                fl.createIndex("workspaceId", "workspaceId");
+            }
+            if (!d.objectStoreNames.contains("fileContents")) {
+                d.createObjectStore("fileContents", { keyPath: "fileId" });
+            }
+            if (!d.objectStoreNames.contains("projectMru")) {
+                d.createObjectStore("projectMru", { keyPath: "projectId" });
+            }
+        };
+        r.onsuccess = () => {
+            _db = r.result;
+            resolve(_db);
+        };
+        r.onerror = () => reject(r.error);
+    });
+}
+function getDb() {
+    return _db !== null ? Promise.resolve(_db) : openDb();
+}
+function wrap(r) {
+    return new Promise((resolve, reject) => {
+        r.onsuccess = () => resolve(r.result);
+        r.onerror = () => reject(r.error);
+    });
+}
+function sorted(items, field) {
+    return [...items].sort((a, b) => {
+        const av = String(a[field] ?? "");
+        const bv = String(b[field] ?? "");
+        return av.localeCompare(bv);
+    });
+}
+function makeTable(name) {
+    async function fetchAll(index, value) {
+        const d = await getDb();
+        const os = d.transaction(name, "readonly").objectStore(name);
+        const r = index !== undefined && value !== undefined ? os.index(index).getAll(value) : os.getAll();
+        return wrap(r);
+    }
+    return {
+        async get(key) {
+            const d = await getDb();
+            return wrap(d.transaction(name, "readonly").objectStore(name).get(key));
+        },
+        async add(record) {
+            const d = await getDb();
+            await wrap(d.transaction(name, "readwrite").objectStore(name).add(record));
+        },
+        async update(key, changes) {
+            const d = await getDb();
+            const tx = d.transaction(name, "readwrite");
+            const os = tx.objectStore(name);
+            const current = await wrap(os.get(key));
+            if (current !== undefined) {
+                await wrap(os.put(Object.assign({}, current, changes)));
+            }
+        },
+        async delete(key) {
+            const d = await getDb();
+            await wrap(d.transaction(name, "readwrite").objectStore(name).delete(key));
+        },
+        orderBy(field) {
+            return {
+                toArray: () => fetchAll().then((items) => sorted(items, field)),
+            };
+        },
+        where(index) {
+            return {
+                equals: (value) => ({
+                    toArray: () => fetchAll(index, value),
+                    sortBy: (field) => fetchAll(index, value).then((items) => sorted(items, field)),
+                    delete: async () => {
+                        const d = await getDb();
+                        const tx = d.transaction(name, "readwrite");
+                        const os = tx.objectStore(name);
+                        const keys = await wrap(os.index(index).getAllKeys(value));
+                        await Promise.all(keys.map((k) => wrap(os.delete(k))));
+                    },
+                }),
+            };
+        },
+        filter: (pred) => ({
+            toArray: () => fetchAll().then((items) => items.filter(pred)),
+        }),
+    };
+}
+export const db = {
+    workspaces: makeTable("workspaces"),
+    projects: makeTable("projects"),
+    files: makeTable("files"),
+    fileContents: makeTable("fileContents"),
+    projectMru: makeTable("projectMru"),
+};
+//# sourceMappingURL=db.js.map

package/dist/storage/dialog.d.ts

@@ -0,0 +1,15 @@
+/** Shows a modal input dialog. Returns the trimmed value or null if cancelled. */
+export declare function showInputDialog(opts: {
+    title: string;
+    defaultValue?: string;
+    placeholder?: string;
+    confirmLabel?: string;
+}): Promise<string | null>;
+/** Shows a modal confirmation dialog. Returns true if confirmed, false if cancelled. */
+export declare function showConfirmDialog(opts: {
+    title: string;
+    message: string;
+    confirmLabel?: string;
+    danger?: boolean;
+}): Promise<boolean>;
+//# sourceMappingURL=dialog.d.ts.map

package/dist/storage/dialog.js

@@ -0,0 +1,201 @@
+const STYLE_ID = "stor-dialog-styles";
+function injectStyles() {
+    if (document.getElementById(STYLE_ID))
+        return;
+    const style = document.createElement("style");
+    style.id = STYLE_ID;
+    style.textContent = `
+.stor-dialog-overlay {
+  position: fixed; inset: 0; z-index: 500;
+  background: rgba(0,0,0,0.5);
+  display: flex; align-items: center; justify-content: center;
+}
+.stor-dialog {
+  background: rgba(22, 22, 30, 0.97);
+  border: 1px solid rgba(255,255,255,0.12);
+  border-radius: 10px;
+  padding: 20px;
+  min-width: 300px; max-width: 90vw;
+  color: rgba(255,255,255,0.85);
+  font-family: system-ui, -apple-system, sans-serif;
+  box-shadow: 0 16px 48px rgba(0,0,0,0.6);
+  display: flex; flex-direction: column; gap: 12px;
+}
+.stor-dialog-title {
+  font-size: 14px; font-weight: 600;
+  color: rgba(255,255,255,0.95);
+}
+.stor-dialog-msg {
+  font-size: 13px; color: rgba(255,255,255,0.65); line-height: 1.4;
+}
+.stor-dialog-input {
+  width: 100%; padding: 6px 10px;
+  background: rgba(255,255,255,0.08);
+  border: 1px solid rgba(255,255,255,0.15);
+  border-radius: 6px;
+  color: rgba(255,255,255,0.9);
+  font-size: 13px;
+  outline: none;
+  box-sizing: border-box;
+}
+.stor-dialog-input:focus { border-color: rgba(60,120,220,0.6); }
+.stor-dialog-actions { display: flex; gap: 8px; justify-content: flex-end; }
+.stor-dialog-btn {
+  font-size: 13px; padding: 6px 14px; border-radius: 6px;
+  cursor: pointer; font-weight: 500;
+  border: 1px solid rgba(255,255,255,0.12);
+  background: rgba(255,255,255,0.06);
+  color: rgba(255,255,255,0.8);
+}
+.stor-dialog-btn:hover { background: rgba(255,255,255,0.1); }
+.stor-dialog-btn--primary {
+  background: rgba(60,120,220,0.5);
+  border-color: rgba(60,120,220,0.7);
+  color: #fff;
+}
+.stor-dialog-btn--primary:hover { background: rgba(60,120,220,0.65); }
+.stor-dialog-btn--danger {
+  background: rgba(200,40,40,0.5);
+  border-color: rgba(200,40,40,0.7);
+  color: #fff;
+}
+.stor-dialog-btn--danger:hover { background: rgba(200,40,40,0.65); }
+/* Light theme */
+[data-bpmnkit-hud-theme="light"] .stor-dialog {
+  background: rgba(252,252,254,0.98);
+  border-color: rgba(0,0,0,0.1);
+  color: rgba(0,0,0,0.8);
+  box-shadow: 0 8px 32px rgba(0,0,0,0.15);
+}
+[data-bpmnkit-hud-theme="light"] .stor-dialog-title { color: rgba(0,0,0,0.88); }
+[data-bpmnkit-hud-theme="light"] .stor-dialog-msg { color: rgba(0,0,0,0.55); }
+[data-bpmnkit-hud-theme="light"] .stor-dialog-input {
+  background: rgba(0,0,0,0.04);
+  border-color: rgba(0,0,0,0.15);
+  color: rgba(0,0,0,0.9);
+}
+[data-bpmnkit-hud-theme="light"] .stor-dialog-input:focus { border-color: rgba(0,80,200,0.4); }
+[data-bpmnkit-hud-theme="light"] .stor-dialog-btn {
+  border-color: rgba(0,0,0,0.12);
+  background: rgba(0,0,0,0.04);
+  color: rgba(0,0,0,0.7);
+}
+[data-bpmnkit-hud-theme="light"] .stor-dialog-btn:hover { background: rgba(0,0,0,0.08); }
+[data-bpmnkit-hud-theme="light"] .stor-dialog-btn--primary {
+  background: rgba(0,80,200,0.85);
+  border-color: rgba(0,80,200,0.9);
+  color: #fff;
+}
+[data-bpmnkit-hud-theme="light"] .stor-dialog-btn--primary:hover { background: rgba(0,80,200,1); }
+[data-bpmnkit-hud-theme="light"] .stor-dialog-btn--danger {
+  background: rgba(180,30,30,0.85);
+  border-color: rgba(180,30,30,0.9);
+  color: #fff;
+}
+[data-bpmnkit-hud-theme="light"] .stor-dialog-btn--danger:hover { background: rgba(180,30,30,1); }
+`;
+    document.head.appendChild(style);
+}
+/** Shows a modal input dialog. Returns the trimmed value or null if cancelled. */
+export function showInputDialog(opts) {
+    return new Promise((resolve) => {
+        injectStyles();
+        const overlay = document.createElement("div");
+        overlay.className = "stor-dialog-overlay";
+        const dialog = document.createElement("div");
+        dialog.className = "stor-dialog";
+        const titleEl = document.createElement("div");
+        titleEl.className = "stor-dialog-title";
+        titleEl.textContent = opts.title;
+        const input = document.createElement("input");
+        input.type = "text";
+        input.className = "stor-dialog-input";
+        input.value = opts.defaultValue ?? "";
+        if (opts.placeholder)
+            input.placeholder = opts.placeholder;
+        const actions = document.createElement("div");
+        actions.className = "stor-dialog-actions";
+        const cancelBtn = document.createElement("button");
+        cancelBtn.className = "stor-dialog-btn";
+        cancelBtn.textContent = "Cancel";
+        const confirmBtn = document.createElement("button");
+        confirmBtn.className = "stor-dialog-btn stor-dialog-btn--primary";
+        confirmBtn.textContent = opts.confirmLabel ?? "OK";
+        function close(value) {
+            overlay.remove();
+            document.removeEventListener("keydown", handleKey);
+            resolve(value);
+        }
+        cancelBtn.addEventListener("click", () => close(null));
+        confirmBtn.addEventListener("click", () => close(input.value.trim() || null));
+        function handleKey(e) {
+            if (e.key === "Escape")
+                close(null);
+            else if (e.key === "Enter")
+                close(input.value.trim() || null);
+        }
+        document.addEventListener("keydown", handleKey);
+        overlay.addEventListener("click", (e) => {
+            if (e.target === overlay)
+                close(null);
+        });
+        actions.append(cancelBtn, confirmBtn);
+        dialog.append(titleEl, input, actions);
+        overlay.append(dialog);
+        document.body.append(overlay);
+        requestAnimationFrame(() => {
+            input.select();
+            input.focus();
+        });
+    });
+}
+/** Shows a modal confirmation dialog. Returns true if confirmed, false if cancelled. */
+export function showConfirmDialog(opts) {
+    return new Promise((resolve) => {
+        injectStyles();
+        const overlay = document.createElement("div");
+        overlay.className = "stor-dialog-overlay";
+        const dialog = document.createElement("div");
+        dialog.className = "stor-dialog";
+        const titleEl = document.createElement("div");
+        titleEl.className = "stor-dialog-title";
+        titleEl.textContent = opts.title;
+        const msgEl = document.createElement("div");
+        msgEl.className = "stor-dialog-msg";
+        msgEl.textContent = opts.message;
+        const actions = document.createElement("div");
+        actions.className = "stor-dialog-actions";
+        const cancelBtn = document.createElement("button");
+        cancelBtn.className = "stor-dialog-btn";
+        cancelBtn.textContent = "Cancel";
+        const confirmBtn = document.createElement("button");
+        confirmBtn.className = opts.danger
+            ? "stor-dialog-btn stor-dialog-btn--danger"
+            : "stor-dialog-btn stor-dialog-btn--primary";
+        confirmBtn.textContent = opts.confirmLabel ?? "Confirm";
+        function close(result) {
+            overlay.remove();
+            document.removeEventListener("keydown", handleKey);
+            resolve(result);
+        }
+        cancelBtn.addEventListener("click", () => close(false));
+        confirmBtn.addEventListener("click", () => close(true));
+        function handleKey(e) {
+            if (e.key === "Escape")
+                close(false);
+            else if (e.key === "Enter")
+                close(true);
+        }
+        document.addEventListener("keydown", handleKey);
+        overlay.addEventListener("click", (e) => {
+            if (e.target === overlay)
+                close(false);
+        });
+        actions.append(cancelBtn, confirmBtn);
+        dialog.append(titleEl, msgEl, actions);
+        overlay.append(dialog);
+        document.body.append(overlay);
+        requestAnimationFrame(() => confirmBtn.focus());
+    });
+}
+//# sourceMappingURL=dialog.js.map

package/dist/storage/export.d.ts

@@ -0,0 +1,3 @@
+import type { StorageApi } from "./storage-api.js";
+export declare function exportProjectAsZip(api: StorageApi): Promise<void>;
+//# sourceMappingURL=export.d.ts.map

package/dist/storage/export.js

@@ -0,0 +1,137 @@
+// ─── CRC-32 ───────────────────────────────────────────────────────────────────
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let j = 0; j < 8; j++) {
+            c = c & 1 ? (c >>> 1) ^ 0xedb88320 : c >>> 1;
+        }
+        t[i] = c;
+    }
+    return t;
+})();
+function crc32(data) {
+    let crc = 0xffffffff;
+    for (const byte of data) {
+        crc = (crc >>> 8) ^ (CRC_TABLE[(crc ^ byte) & 0xff] ?? 0);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function u16(view, off, v) {
+    view.setUint16(off, v, true);
+}
+function u32(view, off, v) {
+    view.setUint32(off, v, true);
+}
+function buildZip(files) {
+    const enc = new TextEncoder();
+    const entries = [];
+    const localParts = [];
+    let dataOffset = 0;
+    for (const file of files) {
+        const nameBytes = enc.encode(file.name);
+        const crc = crc32(file.data);
+        const headerLen = 30 + nameBytes.length;
+        const header = new Uint8Array(headerLen);
+        const v = new DataView(header.buffer);
+        u32(v, 0, 0x04034b50); // local file signature
+        u16(v, 4, 10); // version needed: 1.0
+        u16(v, 6, 0); // flags
+        u16(v, 8, 0); // STORE
+        u16(v, 10, 0); // last mod time
+        u16(v, 12, 0); // last mod date
+        u32(v, 14, crc);
+        u32(v, 18, file.data.length); // compressed size
+        u32(v, 22, file.data.length); // uncompressed size
+        u16(v, 26, nameBytes.length);
+        u16(v, 28, 0); // extra field length
+        header.set(nameBytes, 30);
+        entries.push({ nameBytes, data: file.data, crc, offset: dataOffset });
+        localParts.push(header, file.data);
+        dataOffset += headerLen + file.data.length;
+    }
+    // Central directory
+    const centralParts = [];
+    let centralSize = 0;
+    for (const e of entries) {
+        const len = 46 + e.nameBytes.length;
+        const cd = new Uint8Array(len);
+        const v = new DataView(cd.buffer);
+        u32(v, 0, 0x02014b50); // central dir signature
+        u16(v, 4, 20); // version made by
+        u16(v, 6, 10); // version needed
+        u16(v, 8, 0); // flags
+        u16(v, 10, 0); // STORE
+        u16(v, 12, 0); // last mod time
+        u16(v, 14, 0); // last mod date
+        u32(v, 16, e.crc);
+        u32(v, 20, e.data.length); // compressed size
+        u32(v, 24, e.data.length); // uncompressed size
+        u16(v, 28, e.nameBytes.length);
+        u16(v, 30, 0); // extra field length
+        u16(v, 32, 0); // file comment length
+        u16(v, 34, 0); // disk number start
+        u16(v, 36, 0); // internal file attributes
+        u32(v, 38, 0); // external file attributes
+        u32(v, 42, e.offset); // relative offset of local header
+        cd.set(e.nameBytes, 46);
+        centralParts.push(cd);
+        centralSize += len;
+    }
+    // End of central directory record
+    const eocd = new Uint8Array(22);
+    const ev = new DataView(eocd.buffer);
+    u32(ev, 0, 0x06054b50);
+    u16(ev, 4, 0);
+    u16(ev, 6, 0);
+    u16(ev, 8, entries.length);
+    u16(ev, 10, entries.length);
+    u32(ev, 12, centralSize);
+    u32(ev, 16, dataOffset);
+    u16(ev, 20, 0);
+    const totalSize = dataOffset + centralSize + 22;
+    const out = new Uint8Array(totalSize);
+    let pos = 0;
+    for (const part of [...localParts, ...centralParts, eocd]) {
+        out.set(part, pos);
+        pos += part.length;
+    }
+    return out;
+}
+// ─── File extension helper ────────────────────────────────────────────────────
+function fileExt(type) {
+    if (type === "bpmn")
+        return ".bpmn";
+    if (type === "dmn")
+        return ".dmn";
+    return ".form";
+}
+// ─── Public ───────────────────────────────────────────────────────────────────
+export async function exportProjectAsZip(api) {
+    const projectId = api.getCurrentProjectId();
+    if (!projectId)
+        return;
+    const projectName = api.getProjectName(projectId) ?? "project";
+    const files = await api.getFiles(projectId);
+    const enc = new TextEncoder();
+    const entries = [];
+    for (const file of files) {
+        const content = await api.getFileContent(file.id);
+        if (content === null)
+            continue;
+        const suffix = fileExt(file.type);
+        const filename = file.name.toLowerCase().endsWith(suffix) ? file.name : `${file.name}${suffix}`;
+        entries.push({ name: filename, data: enc.encode(content) });
+    }
+    if (entries.length === 0)
+        return;
+    const zip = buildZip(entries);
+    const blob = new Blob([zip.buffer], { type: "application/zip" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `${projectName}.zip`;
+    a.click();
+    URL.revokeObjectURL(url);
+}
+//# sourceMappingURL=export.js.map

package/dist/storage/index.d.ts

@@ -0,0 +1,44 @@
+import type { CanvasPlugin } from "@bpmnkit/canvas";
+import type { MainMenuApi } from "../main-menu/index.js";
+import { StorageApi, type StorageApiOptions } from "./storage-api.js";
+import type { FileType } from "./types.js";
+export type { FileType, WorkspaceRecord, ProjectRecord, FileRecord, FileContentRecord, } from "./types.js";
+export { StorageApi } from "./storage-api.js";
+export type { StorageApiOptions } from "./storage-api.js";
+export { showInputDialog, showConfirmDialog } from "./dialog.js";
+/** Options for {@link createStoragePlugin}. */
+export interface StoragePluginOptions extends StorageApiOptions {
+    /** The main menu plugin instance (must have an `api` property). */
+    mainMenu: CanvasPlugin & {
+        api: MainMenuApi;
+    };
+    /** Returns the currently open tabs with their latest content. */
+    getOpenTabs(): Array<{
+        tabId: string;
+        name: string;
+        type: FileType;
+        content: string;
+    }>;
+    /** Title to restore when leaving a project. Defaults to "". */
+    initialTitle?: string;
+    /** Called when the user clicks "Leave" in the project info bar. */
+    onLeaveProject?: () => void;
+    /** Called after the IndexedDB caches have finished loading. Use this to refresh any UI that depends on storage data (e.g. the recent-projects dropdown). */
+    onReady?: () => void;
+    /**
+     * Called when the user renames the current file via the main menu.
+     * Update the corresponding tab's display name from this callback.
+     */
+    onRenameCurrentFile?: (fileId: string, name: string) => void;
+}
+/**
+ * Creates an IndexedDB-backed storage plugin.
+ *
+ * Integrates with the main menu plugin to provide workspace/project navigation
+ * via drill-down menus. Auto-saves BPMN changes with a 500 ms debounce.
+ * Persists the last-opened project across page refreshes.
+ */
+export declare function createStoragePlugin(options: StoragePluginOptions): CanvasPlugin & {
+    api: StorageApi;
+};
+//# sourceMappingURL=index.d.ts.map