@mnaoumov/obsidian-lib 6.2.1 → 7.0.0

package/dist/lib/esm/data-stores/data-store-transport.mjs

@@ -0,0 +1,259 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { Notice } from "obsidian";
+import { getObsidianLibDebugger } from "../debug.mjs";
+const DEFAULT_MAX_FILE_BYTES = 1e6;
+const MIN_FILE_BYTES = 256;
+const MAX_FILE_BYTES = 4e6;
+const DOCUMENT_PREFIX = "```json\n";
+const DOCUMENT_SUFFIX = "\n```\n";
+const BISECTION_DIVISOR = 2;
+const HEX_RADIX = 16;
+const HEX_BYTE_LENGTH = 2;
+class DataStoreTransport {
+  /**
+   * Creates a bounded vault transport.
+   *
+   * @param params - Adapter, identity and file bounds.
+   */
+  constructor(params) {
+    this.params = params;
+    this.adapter = params.adapter;
+    const folder = params.folder ?? "Plugin data";
+    if (!folder || folder.split("/").some((part) => !part || part.startsWith(".") || part.includes("\\")) || !/^[\w-]+$/.test(params.pluginId) || !/^[\w-]+$/.test(params.storeId)) {
+      throw new Error("Data store requires a non-dot vault folder and safe plugin/store ids");
+    }
+    this.root = `${folder}/${params.pluginId}/${params.storeId}`;
+    this.maxFileBytes = params.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    if (!Number.isSafeInteger(this.maxFileBytes) || this.maxFileBytes < MIN_FILE_BYTES || this.maxFileBytes > MAX_FILE_BYTES) {
+      throw new Error("Data-store file limit must be between 256 and 4000000 bytes");
+    }
+  }
+  params;
+  /**
+   * Maximum encoded bytes per document.
+   */
+  maxFileBytes;
+  /**
+   * Full vault-relative store root.
+   */
+  root;
+  /**
+   * Vault adapter used by this transport.
+   */
+  adapter;
+  /**
+   * Tests the complete encoded size without writing.
+   *
+   * @param value - JSON payload.
+   * @returns Whether its document fits the configured cap.
+   */
+  fits(value) {
+    return new TextEncoder().encode(this.encode(value)).length <= this.maxFileBytes;
+  }
+  /**
+   * Lists the store's files recursively, never leaving its folder.
+   *
+   * @returns Vault-relative paths.
+   */
+  async list() {
+    if (!await this.adapter.exists(this.root)) {
+      return [];
+    }
+    const pending = [this.root];
+    const files = [];
+    while (pending.length > 0) {
+      const folder = ensureNonNullable(pending.shift());
+      const children = await this.adapter.list(folder);
+      files.push(...children.files.filter((path) => path.startsWith(`${folder}/`)));
+      pending.push(...children.folders.filter((path) => path.startsWith(`${folder}/`)));
+    }
+    return files.sort();
+  }
+  /**
+   * Reads a complete fenced JSON document. Partial or not-yet-delivered documents are ignored.
+   *
+   * @param path - Vault-relative file within this store.
+   * @returns Parsed JSON, or `undefined` for an incomplete document.
+   */
+  async read(path) {
+    this.checkPath(path);
+    if (!await this.adapter.exists(path)) {
+      return void 0;
+    }
+    let text;
+    try {
+      text = await this.adapter.read(path);
+    } catch (error) {
+      if (!await this.adapter.exists(path)) {
+        return void 0;
+      }
+      throw error;
+    }
+    this.checkSize(text);
+    if (!text.startsWith(DOCUMENT_PREFIX) || !text.endsWith(DOCUMENT_SUFFIX)) {
+      return void 0;
+    }
+    const parsed = JSON.parse(text.slice(DOCUMENT_PREFIX.length, -DOCUMENT_SUFFIX.length));
+    return parsed;
+  }
+  /**
+   * Reads a snapshot only after every numbered chunk arrives and passes its SHA-256 check.
+   *
+   * @param path - Vault-relative manifest path.
+   * @returns Its payload, or `undefined` while delivery is incomplete.
+   */
+  async readSnapshot(path) {
+    const manifest = await this.read(path);
+    if (typeof manifest !== "object" || manifest === null || !("format" in manifest) || manifest.format !== 1 || !("hashes" in manifest) || !Array.isArray(manifest.hashes) || manifest.hashes.length === 0 || manifest.hashes.some((hash) => typeof hash !== "string")) {
+      return void 0;
+    }
+    const chunks = [];
+    for (const [index, hash] of manifest.hashes.entries()) {
+      const chunk = await this.read(`${path.slice(0, -".md".length)}-${String(index)}.md`);
+      if (typeof chunk !== "string" || await digest(chunk) !== hash) {
+        return void 0;
+      }
+      chunks.push(chunk);
+    }
+    const parsed = JSON.parse(chunks.join(""));
+    return parsed;
+  }
+  /**
+   * Removes a document owned by the caller's device.
+   *
+   * @param path - Vault-relative file within this store.
+   * @returns A promise that resolves after removal.
+   */
+  async remove(path) {
+    this.checkPath(path);
+    await this.adapter.remove(path);
+  }
+  /**
+   * Writes a complete document, refusing an oversized write before adapter mutation.
+   *
+   * @param path - Vault-relative file within this store.
+   * @param value - JSON-compatible payload.
+   * @returns A promise that resolves once the adapter finishes writing.
+   */
+  async write(path, value) {
+    this.checkPath(path);
+    const text = this.encode(value);
+    this.checkSize(text);
+    const parts = path.split("/");
+    parts.pop();
+    let folder = "";
+    for (const part of parts) {
+      folder = folder ? `${folder}/${part}` : part;
+      if (!await this.adapter.exists(folder)) {
+        try {
+          await this.adapter.mkdir(folder);
+        } catch (error) {
+          if (!await this.adapter.exists(folder)) {
+            throw error;
+          }
+        }
+      }
+    }
+    await this.adapter.write(path, text);
+  }
+  /**
+   * Publishes bounded immutable chunks before their manifest. Readers verify delivery completeness.
+   *
+   * @param params - Unique base path and snapshot payload.
+   * @returns A promise that resolves when the manifest has been published.
+   */
+  async writeSnapshot(params) {
+    const payload = JSON.stringify(params.payload);
+    if (payload === void 0) {
+      throw new Error("Snapshot must be JSON-compatible");
+    }
+    const chunks = [];
+    let offset = 0;
+    while (offset < payload.length) {
+      let low = 1;
+      let high = Math.min(payload.length - offset, this.maxFileBytes);
+      while (low < high) {
+        const middle = Math.ceil((low + high) / BISECTION_DIVISOR);
+        if (this.fits(payload.slice(offset, offset + middle))) {
+          low = middle;
+        } else {
+          high = middle - 1;
+        }
+      }
+      chunks.push(payload.slice(offset, offset + low));
+      offset += low;
+    }
+    const hashes = [];
+    for (const chunk of chunks) {
+      hashes.push(await digest(chunk));
+    }
+    const manifest = { format: 1, hashes };
+    this.checkSize(this.encode(manifest));
+    for (const [index, chunk] of chunks.entries()) {
+      await this.write(`${params.base}-${String(index)}.md`, chunk);
+    }
+    await this.write(`${params.base}.md`, manifest);
+  }
+  checkPath(path) {
+    if (!path.startsWith(`${this.root}/`) || path.split("/").some((part) => !part || part.startsWith(".") || part.includes("\\"))) {
+      throw new Error("Data-store path leaves its configured folder");
+    }
+  }
+  checkSize(text) {
+    const size = new TextEncoder().encode(text).length;
+    if (size <= this.maxFileBytes) {
+      return;
+    }
+    const message = `Plugin data store: ${String(size)} bytes exceeds the ${String(this.maxFileBytes)} byte file limit.`;
+    new Notice(message);
+    getObsidianLibDebugger("DataStore")(message);
+    throw new Error(message);
+  }
+  encode(value) {
+    const json = JSON.stringify(value);
+    if (json === void 0) {
+      throw new Error("Data-store payload must be JSON-compatible");
+    }
+    return `${DOCUMENT_PREFIX}${json}${DOCUMENT_SUFFIX}`;
+  }
+}
+async function digest(text) {
+  const hash = await window.crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return [...new Uint8Array(hash)].map((byte) => byte.toString(HEX_RADIX).padStart(HEX_BYTE_LENGTH, "0")).join("");
+}
+export {
+  DataStoreTransport
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/data-stores/data-store-transport.ts"],"sourcesContent":["/* eslint-disable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n/**\n * @file\n *\n * Size-bounded Markdown transport carried by vault synchronization with default file types.\n */\n\nimport type { DataAdapter } from 'obsidian';\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { Notice } from 'obsidian';\n\nimport { getObsidianLibDebugger } from '../debug.ts';\n\nconst DEFAULT_MAX_FILE_BYTES = 1_000_000;\nconst MIN_FILE_BYTES = 256;\nconst MAX_FILE_BYTES = 4_000_000;\nconst DOCUMENT_PREFIX = '```json\\n';\nconst DOCUMENT_SUFFIX = '\\n```\\n';\nconst BISECTION_DIVISOR = 2;\nconst HEX_RADIX = 16;\nconst HEX_BYTE_LENGTH = 2;\n\n/**\n * Parameters for the shared-store vault transport.\n */\nexport interface DataStoreTransportConstructorParams {\n  /**\n   * Vault adapter; no desktop filesystem APIs are used.\n   */\n  readonly adapter: DataAdapter;\n  /**\n   * Configurable non-dot vault folder.\n   *\n   * @default `'Plugin data'`\n   */\n  readonly folder?: string;\n  /**\n   * Maximum UTF-8 bytes in any file, including its Markdown wrapper.\n   *\n   * @default `1000000`\n   */\n  readonly maxFileBytes?: number;\n  /**\n   * Plugin manifest id.\n   */\n  readonly pluginId: string;\n  /**\n   * Store name including its consumer schema version.\n   */\n  readonly storeId: string;\n}\n\n/**\n * Parameters for publishing a chunked snapshot.\n */\nexport interface DataStoreTransportWriteSnapshotParams {\n  /**\n   * Vault-relative base path without the `.md` extension. Use a fresh unique name for every publication.\n   */\n  readonly base: string;\n  /**\n   * JSON-compatible snapshot, including its consumer schema and coverage metadata.\n   */\n  readonly payload: unknown;\n}\n\n/**\n * A store-scoped transport. Every published document is immutable except device acknowledgements.\n */\nexport class DataStoreTransport {\n  /**\n   * Maximum encoded bytes per document.\n   */\n  public readonly maxFileBytes: number;\n  /**\n   * Full vault-relative store root.\n   */\n  public readonly root: string;\n  /**\n   * Vault adapter used by this transport.\n   */\n  protected readonly adapter: DataAdapter;\n\n  /**\n   * Creates a bounded vault transport.\n   *\n   * @param params - Adapter, identity and file bounds.\n   */\n  public constructor(protected readonly params: DataStoreTransportConstructorParams) {\n    this.adapter = params.adapter;\n    const folder = params.folder ?? 'Plugin data';\n    if (\n      !folder || folder.split('/').some((part) => !part || part.startsWith('.') || part.includes('\\\\'))\n      || !/^[\\w-]+$/.test(params.pluginId) || !/^[\\w-]+$/.test(params.storeId)\n    ) {\n      throw new Error('Data store requires a non-dot vault folder and safe plugin/store ids');\n    }\n    this.root = `${folder}/${params.pluginId}/${params.storeId}`;\n    this.maxFileBytes = params.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;\n    if (!Number.isSafeInteger(this.maxFileBytes) || this.maxFileBytes < MIN_FILE_BYTES || this.maxFileBytes > MAX_FILE_BYTES) {\n      throw new Error('Data-store file limit must be between 256 and 4000000 bytes');\n    }\n  }\n\n  /**\n   * Tests the complete encoded size without writing.\n   *\n   * @param value - JSON payload.\n   * @returns Whether its document fits the configured cap.\n   */\n  public fits(value: unknown): boolean {\n    return new TextEncoder().encode(this.encode(value)).length <= this.maxFileBytes;\n  }\n\n  /**\n   * Lists the store's files recursively, never leaving its folder.\n   *\n   * @returns Vault-relative paths.\n   */\n  public async list(): Promise<string[]> {\n    if (!await this.adapter.exists(this.root)) {\n      return [];\n    }\n    const pending = [this.root];\n    const files: string[] = [];\n    while (pending.length > 0) {\n      const folder = ensureNonNullable(pending.shift());\n      const children = await this.adapter.list(folder);\n      files.push(...children.files.filter((path) => path.startsWith(`${folder}/`)));\n      pending.push(...children.folders.filter((path) => path.startsWith(`${folder}/`)));\n    }\n    return files.sort();\n  }\n\n  /**\n   * Reads a complete fenced JSON document. Partial or not-yet-delivered documents are ignored.\n   *\n   * @param path - Vault-relative file within this store.\n   * @returns Parsed JSON, or `undefined` for an incomplete document.\n   */\n  public async read(path: string): Promise<unknown> {\n    this.checkPath(path);\n    if (!await this.adapter.exists(path)) {\n      return undefined;\n    }\n    let text: string;\n    try {\n      text = await this.adapter.read(path);\n    } catch (error) {\n      if (!await this.adapter.exists(path)) {\n        return undefined;\n      }\n      throw error;\n    }\n    this.checkSize(text);\n    if (!text.startsWith(DOCUMENT_PREFIX) || !text.endsWith(DOCUMENT_SUFFIX)) {\n      return undefined;\n    }\n    const parsed: unknown = JSON.parse(text.slice(DOCUMENT_PREFIX.length, -DOCUMENT_SUFFIX.length));\n    return parsed;\n  }\n\n  /**\n   * Reads a snapshot only after every numbered chunk arrives and passes its SHA-256 check.\n   *\n   * @param path - Vault-relative manifest path.\n   * @returns Its payload, or `undefined` while delivery is incomplete.\n   */\n  public async readSnapshot(path: string): Promise<unknown> {\n    const manifest = await this.read(path);\n    if (\n      typeof manifest !== 'object' || manifest === null || !('format' in manifest) || manifest.format !== 1\n      || !('hashes' in manifest) || !Array.isArray(manifest.hashes)\n      || manifest.hashes.length === 0 || manifest.hashes.some((hash: unknown) => typeof hash !== 'string')\n    ) {\n      return undefined;\n    }\n    const chunks: string[] = [];\n    for (const [index, hash] of manifest.hashes.entries()) {\n      const chunk = await this.read(`${path.slice(0, -'.md'.length)}-${String(index)}.md`);\n      if (typeof chunk !== 'string' || await digest(chunk) !== hash) {\n        return undefined;\n      }\n      chunks.push(chunk);\n    }\n    const parsed: unknown = JSON.parse(chunks.join(''));\n    return parsed;\n  }\n\n  /**\n   * Removes a document owned by the caller's device.\n   *\n   * @param path - Vault-relative file within this store.\n   * @returns A promise that resolves after removal.\n   */\n  public async remove(path: string): Promise<void> {\n    this.checkPath(path);\n    await this.adapter.remove(path);\n  }\n\n  /**\n   * Writes a complete document, refusing an oversized write before adapter mutation.\n   *\n   * @param path - Vault-relative file within this store.\n   * @param value - JSON-compatible payload.\n   * @returns A promise that resolves once the adapter finishes writing.\n   */\n  public async write(path: string, value: unknown): Promise<void> {\n    this.checkPath(path);\n    const text = this.encode(value);\n    this.checkSize(text);\n    const parts = path.split('/');\n    parts.pop();\n    let folder = '';\n    for (const part of parts) {\n      folder = folder ? `${folder}/${part}` : part;\n      if (!await this.adapter.exists(folder)) {\n        try {\n          await this.adapter.mkdir(folder);\n        } catch (error) {\n          if (!await this.adapter.exists(folder)) {\n            throw error;\n          }\n        }\n      }\n    }\n    await this.adapter.write(path, text);\n  }\n\n  /**\n   * Publishes bounded immutable chunks before their manifest. Readers verify delivery completeness.\n   *\n   * @param params - Unique base path and snapshot payload.\n   * @returns A promise that resolves when the manifest has been published.\n   */\n  public async writeSnapshot(params: DataStoreTransportWriteSnapshotParams): Promise<void> {\n    const payload = JSON.stringify(params.payload);\n    if (payload === undefined) {\n      throw new Error('Snapshot must be JSON-compatible');\n    }\n    const chunks: string[] = [];\n    let offset = 0;\n    while (offset < payload.length) {\n      let low = 1;\n      let high = Math.min(payload.length - offset, this.maxFileBytes);\n      while (low < high) {\n        const middle = Math.ceil((low + high) / BISECTION_DIVISOR);\n        if (this.fits(payload.slice(offset, offset + middle))) {\n          low = middle;\n        } else {\n          high = middle - 1;\n        }\n      }\n      chunks.push(payload.slice(offset, offset + low));\n      offset += low;\n    }\n    const hashes: string[] = [];\n    for (const chunk of chunks) {\n      hashes.push(await digest(chunk));\n    }\n    const manifest = { format: 1, hashes };\n    this.checkSize(this.encode(manifest));\n    for (const [index, chunk] of chunks.entries()) {\n      await this.write(`${params.base}-${String(index)}.md`, chunk);\n    }\n    await this.write(`${params.base}.md`, manifest);\n  }\n\n  private checkPath(path: string): void {\n    if (!path.startsWith(`${this.root}/`) || path.split('/').some((part) => !part || part.startsWith('.') || part.includes('\\\\'))) {\n      throw new Error('Data-store path leaves its configured folder');\n    }\n  }\n\n  private checkSize(text: string): void {\n    const size = new TextEncoder().encode(text).length;\n    if (size <= this.maxFileBytes) {\n      return;\n    }\n    const message = `Plugin data store: ${String(size)} bytes exceeds the ${String(this.maxFileBytes)} byte file limit.`;\n    new Notice(message);\n    getObsidianLibDebugger('DataStore')(message);\n    throw new Error(message);\n  }\n\n  private encode(value: unknown): string {\n    const json = JSON.stringify(value);\n    if (json === undefined) {\n      throw new Error('Data-store payload must be JSON-compatible');\n    }\n    return `${DOCUMENT_PREFIX}${json}${DOCUMENT_SUFFIX}`;\n  }\n}\n\nasync function digest(text: string): Promise<string> {\n  const hash = await window.crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));\n  return [...new Uint8Array(hash)].map((byte) => byte.toString(HEX_RADIX).padStart(HEX_BYTE_LENGTH, '0')).join('');\n}\n\n/* eslint-enable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n"],"mappings":"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","names":[]}

package/dist/lib/esm/data-stores/index.d.mts

@@ -0,0 +1,6 @@
+/// <reference path="../library-references.d.mts" />
+export * as 'data-store-replica' from './data-store-replica.mjs';
+export * as 'data-store-seeds' from './data-store-seeds.mjs';
+export * as 'data-store-transport' from './data-store-transport.mjs';
+export * as 'local-data-store' from './local-data-store.mjs';
+export * as 'shared-data-store' from './shared-data-store.mjs';

package/dist/lib/esm/data-stores/index.mjs

@@ -0,0 +1,18 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import * as data_store_replica from "./data-store-replica.mjs";
+import * as data_store_seeds from "./data-store-seeds.mjs";
+import * as data_store_transport from "./data-store-transport.mjs";
+import * as local_data_store from "./local-data-store.mjs";
+import * as shared_data_store from "./shared-data-store.mjs";
+export {
+  data_store_replica as "data-store-replica",
+  data_store_seeds as "data-store-seeds",
+  data_store_transport as "data-store-transport",
+  local_data_store as "local-data-store",
+  shared_data_store as "shared-data-store"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2RhdGEtc3RvcmVzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2RhdGEtc3RvcmUtcmVwbGljYScgZnJvbSAnLi9kYXRhLXN0b3JlLXJlcGxpY2EudHMnO1xuZXhwb3J0ICogYXMgJ2RhdGEtc3RvcmUtc2VlZHMnIGZyb20gJy4vZGF0YS1zdG9yZS1zZWVkcy50cyc7XG5leHBvcnQgKiBhcyAnZGF0YS1zdG9yZS10cmFuc3BvcnQnIGZyb20gJy4vZGF0YS1zdG9yZS10cmFuc3BvcnQudHMnO1xuZXhwb3J0ICogYXMgJ2xvY2FsLWRhdGEtc3RvcmUnIGZyb20gJy4vbG9jYWwtZGF0YS1zdG9yZS50cyc7XG5leHBvcnQgKiBhcyAnc2hhcmVkLWRhdGEtc3RvcmUnIGZyb20gJy4vc2hhcmVkLWRhdGEtc3RvcmUudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFFQSxZQUFZQSx3QkFBMEI7QUFDdEMsWUFBWUMsc0JBQXdCO0FBQ3BDLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyxzQkFBd0I7QUFDcEMsWUFBWUMsdUJBQXlCOyIsCiAgIm5hbWVzIjogWyJkYXRhLXN0b3JlLXJlcGxpY2EiLCAiZGF0YS1zdG9yZS1zZWVkcyIsICJkYXRhLXN0b3JlLXRyYW5zcG9ydCIsICJsb2NhbC1kYXRhLXN0b3JlIiwgInNoYXJlZC1kYXRhLXN0b3JlIl0KfQo=

package/dist/lib/esm/data-stores/local-data-store.d.mts

@@ -0,0 +1,119 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Record-based device-local persistence, isolated by vault, plugin and store.
+ */
+/**
+ * Atomic mutations of a local record store.
+ */
+export interface LocalDataStoreCommitParams {
+    /**
+     * Key/value pairs to write.
+     */
+    readonly entries: readonly (readonly [string, unknown])[];
+    /**
+     * Keys removed in the same transaction as the writes.
+     *
+     * @default `[]`
+     */
+    readonly removedKeys?: readonly string[];
+}
+/**
+ * Parameters for opening a local store.
+ */
+export interface LocalDataStoreOpenParams {
+    /**
+     * IndexedDB implementation, injectable for tests.
+     */
+    readonly factory?: IDBFactory;
+    /**
+     * Plugin manifest id.
+     */
+    readonly pluginId: string;
+    /**
+     * Store name and schema version chosen by the consumer.
+     */
+    readonly storeId: string;
+    /**
+     * Stable, device-local vault identity; never the vault display name.
+     */
+    readonly vaultId: string;
+}
+/**
+ * A local store holds structured-cloneable values; it never writes to the vault.
+ */
+export declare class LocalDataStore {
+    private readonly database;
+    private constructor();
+    /**
+     * Opens an isolated database. Writes resolve only once their transaction commits.
+     *
+     * @param params - Store identity and optional IndexedDB implementation.
+     * @returns The connected store; close it when its owner unloads.
+     */
+    static open(params: LocalDataStoreOpenParams): Promise<LocalDataStore>;
+    /**
+     * Deletes every record in this store only.
+     *
+     * @returns A promise that resolves after commit.
+     */
+    clear(): Promise<void>;
+    /**
+     * Closes this connection without deleting its records.
+     */
+    close(): void;
+    /**
+     * Commits several record changes atomically without serializing the rest of the database.
+     *
+     * @param params - Writes and deletions in one transaction.
+     * @returns A promise that resolves only after all changes commit.
+     */
+    commit(params: LocalDataStoreCommitParams): Promise<void>;
+    /**
+     * Deletes a record.
+     *
+     * @param key - Record key.
+     * @returns A promise that resolves after commit.
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Reads all records in key order.
+     *
+     * @returns Detached key/value pairs.
+     */
+    entries(): Promise<[string, unknown][]>;
+    /**
+     * Serializes a shared-store operation across connections, windows and bundled library copies.
+     *
+     * @typeParam T - Callback result.
+     * @param callback - Work performed while holding this database's Web Lock.
+     * @returns The callback result after releasing the lock.
+     */
+    exclusive<T>(callback: () => Promise<T>): Promise<T>;
+    /**
+     * Reads a record.
+     *
+     * @param key - Record key.
+     * @returns Its value, or `undefined` when absent.
+     */
+    get(key: string): Promise<unknown>;
+    /**
+     * Initializes a record once, atomically across connections.
+     *
+     * @param key - Record key.
+     * @param value - Value used only when the key is absent.
+     * @returns The existing or newly committed value.
+     */
+    getOrCreate(key: string, value: unknown): Promise<unknown>;
+    /**
+     * Writes a structured-cloneable value.
+     *
+     * @param key - Record key.
+     * @param value - Value to persist.
+     * @returns A promise that resolves after commit.
+     */
+    set(key: string, value: unknown): Promise<void>;
+    private run;
+}

package/dist/lib/esm/data-stores/local-data-store.mjs

@@ -0,0 +1,170 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+class LocalDataStore {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  /**
+   * Opens an isolated database. Writes resolve only once their transaction commits.
+   *
+   * @param params - Store identity and optional IndexedDB implementation.
+   * @returns The connected store; close it when its owner unloads.
+   */
+  static async open(params) {
+    const name = `obsidian-lib:${JSON.stringify([params.vaultId, params.pluginId, params.storeId])}`;
+    const request = (params.factory ?? indexedDB).open(name, 1);
+    return await new Promise((resolve, reject) => {
+      request.onupgradeneeded = () => {
+        request.result.createObjectStore("records");
+      };
+      request.addEventListener("error", () => {
+        reject(new Error("Could not open local data store", { cause: request.error }));
+      });
+      request.onsuccess = () => {
+        const database = request.result;
+        database.onversionchange = () => {
+          database.close();
+        };
+        resolve(new LocalDataStore(database));
+      };
+    });
+  }
+  /**
+   * Deletes every record in this store only.
+   *
+   * @returns A promise that resolves after commit.
+   */
+  async clear() {
+    await this.run("readwrite", (store) => store.clear());
+  }
+  /**
+   * Closes this connection without deleting its records.
+   */
+  close() {
+    this.database.close();
+  }
+  /**
+   * Commits several record changes atomically without serializing the rest of the database.
+   *
+   * @param params - Writes and deletions in one transaction.
+   * @returns A promise that resolves only after all changes commit.
+   */
+  async commit(params) {
+    await this.run("readwrite", (store) => {
+      for (const key of params.removedKeys ?? []) {
+        store.delete(key);
+      }
+      for (const [key, value] of params.entries) {
+        store.put(value, key);
+      }
+      return store.count();
+    });
+  }
+  /**
+   * Deletes a record.
+   *
+   * @param key - Record key.
+   * @returns A promise that resolves after commit.
+   */
+  async delete(key) {
+    await this.run("readwrite", (store) => store.delete(key));
+  }
+  /**
+   * Reads all records in key order.
+   *
+   * @returns Detached key/value pairs.
+   */
+  async entries() {
+    const records = [];
+    await this.run("readonly", (store) => {
+      const request = store.openCursor();
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) {
+          return;
+        }
+        if (typeof cursor.key !== "string") {
+          throw new TypeError("Local data-store key is not a string");
+        }
+        records.push([cursor.key, cursor.value]);
+        cursor.continue();
+      };
+      return request;
+    });
+    return records;
+  }
+  /**
+   * Serializes a shared-store operation across connections, windows and bundled library copies.
+   *
+   * @typeParam T - Callback result.
+   * @param callback - Work performed while holding this database's Web Lock.
+   * @returns The callback result after releasing the lock.
+   */
+  async exclusive(callback) {
+    return await window.navigator.locks.request(this.database.name, callback);
+  }
+  /**
+   * Reads a record.
+   *
+   * @param key - Record key.
+   * @returns Its value, or `undefined` when absent.
+   */
+  async get(key) {
+    return await this.run("readonly", (store) => store.get(key));
+  }
+  /**
+   * Initializes a record once, atomically across connections.
+   *
+   * @param key - Record key.
+   * @param value - Value used only when the key is absent.
+   * @returns The existing or newly committed value.
+   */
+  async getOrCreate(key, value) {
+    return await this.run("readwrite", (store) => {
+      const request = store.get(key);
+      request.onsuccess = () => {
+        if (request.result === void 0) {
+          store.put(value, key);
+        }
+      };
+      return request;
+    }).then((existing) => existing === void 0 ? value : existing);
+  }
+  /**
+   * Writes a structured-cloneable value.
+   *
+   * @param key - Record key.
+   * @param value - Value to persist.
+   * @returns A promise that resolves after commit.
+   */
+  async set(key, value) {
+    await this.run("readwrite", (store) => store.put(value, key));
+  }
+  async run(mode, action) {
+    return await new Promise((resolve, reject) => {
+      const transaction = this.database.transaction("records", mode);
+      let request;
+      try {
+        request = action(transaction.objectStore("records"));
+      } catch (error) {
+        transaction.abort();
+        reject(error instanceof Error ? error : new Error("Local data-store transaction failed", { cause: error }));
+        return;
+      }
+      transaction.oncomplete = () => {
+        resolve(request.result);
+      };
+      transaction.addEventListener("abort", () => {
+        reject(new Error("Local data-store transaction aborted", { cause: transaction.error }));
+      });
+    });
+  }
+}
+export {
+  LocalDataStore
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/data-stores/local-data-store.ts"],
  "sourcesContent": ["/* eslint-disable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n/**\n * @file\n *\n * Record-based device-local persistence, isolated by vault, plugin and store.\n */\n\n/**\n * Atomic mutations of a local record store.\n */\nexport interface LocalDataStoreCommitParams {\n  /**\n   * Key/value pairs to write.\n   */\n  readonly entries: readonly (readonly [string, unknown])[];\n  /**\n   * Keys removed in the same transaction as the writes.\n   *\n   * @default `[]`\n   */\n  readonly removedKeys?: readonly string[];\n}\n\n/**\n * Parameters for opening a local store.\n */\nexport interface LocalDataStoreOpenParams {\n  /**\n   * IndexedDB implementation, injectable for tests.\n   */\n  readonly factory?: IDBFactory;\n  /**\n   * Plugin manifest id.\n   */\n  readonly pluginId: string;\n  /**\n   * Store name and schema version chosen by the consumer.\n   */\n  readonly storeId: string;\n  /**\n   * Stable, device-local vault identity; never the vault display name.\n   */\n  readonly vaultId: string;\n}\n\n/**\n * A local store holds structured-cloneable values; it never writes to the vault.\n */\nexport class LocalDataStore {\n  private constructor(private readonly database: IDBDatabase) {}\n\n  /**\n   * Opens an isolated database. Writes resolve only once their transaction commits.\n   *\n   * @param params - Store identity and optional IndexedDB implementation.\n   * @returns The connected store; close it when its owner unloads.\n   */\n  public static async open(params: LocalDataStoreOpenParams): Promise<LocalDataStore> {\n    const name = `obsidian-lib:${JSON.stringify([params.vaultId, params.pluginId, params.storeId])}`;\n    const request = (params.factory ?? indexedDB).open(name, 1);\n    return await new Promise((resolve, reject) => {\n      request.onupgradeneeded = (): void => {\n        request.result.createObjectStore('records');\n      };\n      request.addEventListener('error', (): void => {\n        reject(new Error('Could not open local data store', { cause: request.error }));\n      });\n      request.onsuccess = (): void => {\n        const database = request.result;\n        database.onversionchange = (): void => {\n          database.close();\n        };\n        resolve(new LocalDataStore(database));\n      };\n    });\n  }\n\n  /**\n   * Deletes every record in this store only.\n   *\n   * @returns A promise that resolves after commit.\n   */\n  public async clear(): Promise<void> {\n    await this.run('readwrite', (store) => store.clear());\n  }\n\n  /**\n   * Closes this connection without deleting its records.\n   */\n  public close(): void {\n    this.database.close();\n  }\n\n  /**\n   * Commits several record changes atomically without serializing the rest of the database.\n   *\n   * @param params - Writes and deletions in one transaction.\n   * @returns A promise that resolves only after all changes commit.\n   */\n  public async commit(params: LocalDataStoreCommitParams): Promise<void> {\n    await this.run('readwrite', (store) => {\n      for (const key of params.removedKeys ?? []) {\n        store.delete(key);\n      }\n      for (const [key, value] of params.entries) {\n        store.put(value, key);\n      }\n      return store.count();\n    });\n  }\n\n  /**\n   * Deletes a record.\n   *\n   * @param key - Record key.\n   * @returns A promise that resolves after commit.\n   */\n  public async delete(key: string): Promise<void> {\n    await this.run('readwrite', (store) => store.delete(key));\n  }\n\n  /**\n   * Reads all records in key order.\n   *\n   * @returns Detached key/value pairs.\n   */\n  public async entries(): Promise<[string, unknown][]> {\n    const records: [string, unknown][] = [];\n    await this.run('readonly', (store) => {\n      const request = store.openCursor();\n      request.onsuccess = (): void => {\n        const cursor = request.result;\n        if (!cursor) {\n          return;\n        }\n\n        if (typeof cursor.key !== 'string') {\n          throw new TypeError('Local data-store key is not a string');\n        }\n        records.push([cursor.key, cursor.value]);\n        cursor.continue();\n      };\n      return request;\n    });\n    return records;\n  }\n\n  /**\n   * Serializes a shared-store operation across connections, windows and bundled library copies.\n   *\n   * @typeParam T - Callback result.\n   * @param callback - Work performed while holding this database's Web Lock.\n   * @returns The callback result after releasing the lock.\n   */\n  public async exclusive<T>(callback: () => Promise<T>): Promise<T> {\n    return await window.navigator.locks.request(this.database.name, callback);\n  }\n\n  /**\n   * Reads a record.\n   *\n   * @param key - Record key.\n   * @returns Its value, or `undefined` when absent.\n   */\n  public async get(key: string): Promise<unknown> {\n    return await this.run<unknown>('readonly', (store) => store.get(key));\n  }\n\n  /**\n   * Initializes a record once, atomically across connections.\n   *\n   * @param key - Record key.\n   * @param value - Value used only when the key is absent.\n   * @returns The existing or newly committed value.\n   */\n  public async getOrCreate(key: string, value: unknown): Promise<unknown> {\n    return await this.run<unknown>('readwrite', (store) => {\n      const request = store.get(key);\n      request.onsuccess = (): void => {\n        if (request.result === undefined) {\n          store.put(value, key);\n        }\n      };\n      return request;\n    }).then((existing) => existing === undefined ? value : existing);\n  }\n\n  /**\n   * Writes a structured-cloneable value.\n   *\n   * @param key - Record key.\n   * @param value - Value to persist.\n   * @returns A promise that resolves after commit.\n   */\n  public async set(key: string, value: unknown): Promise<void> {\n    await this.run('readwrite', (store) => store.put(value, key));\n  }\n\n  private async run<T>(mode: IDBTransactionMode, action: (store: IDBObjectStore) => IDBRequest<T>): Promise<T> {\n    return await new Promise((resolve, reject) => {\n      const transaction = this.database.transaction('records', mode);\n      let request: IDBRequest<T>;\n      try {\n        request = action(transaction.objectStore('records'));\n      } catch (error) {\n        transaction.abort();\n        reject(error instanceof Error ? error : new Error('Local data-store transaction failed', { cause: error }));\n        return;\n      }\n      transaction.oncomplete = (): void => {\n        resolve(request.result);\n      };\n      transaction.addEventListener('abort', (): void => {\n        reject(new Error('Local data-store transaction aborted', { cause: transaction.error }));\n      });\n    });\n  }\n}\n\n/* eslint-enable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n"],
  "mappings": "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",
  "names": []
}
