@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

package/dist/lib/cjs/data-stores/data-store-transport.d.cts

@@ -60,7 +60,8 @@ export interface DataStoreTransportWriteSnapshotParams {
     readonly payload: unknown;
 }
 /**
- * A store-scoped transport. Every published document is immutable except device acknowledgements.
+ * A store-scoped transport. Every published document is immutable except device acknowledgements and append-only
+ * journal segments, which only their own device rewrites and only by extending them.
  */
 export declare class DataStoreTransport {
     protected readonly params: DataStoreTransportConstructorParams;
@@ -108,6 +109,13 @@ export declare class DataStoreTransport {
      * @returns Vault-relative paths.
      */
     list(): Promise<string[]>;
+    /**
+     * Measures the complete encoded size of a new document without writing.
+     *
+     * @param value - JSON payload.
+     * @returns UTF-8 bytes, encoding wrapper included.
+     */
+    measure(value: unknown): number;
     /**
      * Reads complete fenced Markdown JSON or a version-one JSON envelope. Partial documents remain pending.
      *
@@ -137,6 +145,15 @@ export declare class DataStoreTransport {
      * @returns A promise that resolves once the adapter finishes writing.
      */
     write(path: string, value: unknown): Promise<void>;
+    /**
+     * Publishes an append-only document: an occupied path is rewritten only when the new list strictly extends the stored one.
+     * A reader that sees an older copy sees a prefix, so it applies fewer entries and never a different one.
+     *
+     * @param path - Vault-relative destination within this store.
+     * @param values - JSON-compatible entries; the stored entries must be their prefix.
+     * @returns A promise that resolves after publication, or at once when the stored list is already identical.
+     */
+    writeAppendOnly(path: string, values: readonly unknown[]): Promise<void>;
     /**
      * Publishes an immutable document, accepting only byte-identical retries at an occupied path.
      *
@@ -154,6 +171,18 @@ export declare class DataStoreTransport {
     writeSnapshot(params: DataStoreTransportWriteSnapshotParams): Promise<void>;
     private checkPath;
     private checkSize;
+    /**
+     * Reconciles a destination whose bytes differ from the source. Only a journal segment may differ, because it grows
+     * while its device writes it, so either copy may be the older prefix of the other; anything else is a conflict.
+     *
+     * @param target - Destination transport.
+     * @param path - Source path.
+     * @param destination - Destination path.
+     * @param text - Source bytes.
+     * @returns Whether the source was written over the destination, which must then be verified.
+     */
+    private copyOverDifferentHistory;
     private encode;
     private ensureParent;
+    private readStoredList;
 }

package/dist/lib/cjs/data-stores/index.cjs

@@ -105,12 +105,12 @@ __export(data_stores_exports, {
   "shared-data-store": () => shared_data_store
 });
 module.exports = __toCommonJS(data_stores_exports);
-var data_store_locations = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./data-store-locations.cjs')), 1);
-var data_store_replica = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./data-store-replica.cjs')), 1);
-var data_store_seeds = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./data-store-seeds.cjs')), 1);
-var data_store_transport = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./data-store-transport.cjs')), 1);
-var local_data_store = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./local-data-store.cjs')), 1);
-var shared_data_store = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./shared-data-store.cjs')), 1);
+var data_store_locations = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./data-store-locations.cjs")), 1);
+var data_store_replica = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./data-store-replica.cjs")), 1);
+var data_store_seeds = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./data-store-seeds.cjs")), 1);
+var data_store_transport = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./data-store-transport.cjs")), 1);
+var local_data_store = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./local-data-store.cjs")), 1);
+var shared_data_store = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./shared-data-store.cjs")), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   "data-store-locations": null,

package/dist/lib/cjs/data-stores/local-data-store.cjs

@@ -87,14 +87,39 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var local_data_store_exports = {};
 __export(local_data_store_exports, {
-  LocalDataStore: () => LocalDataStore
+  LocalDataStore: () => LocalDataStore,
+  LocalDataStoreCloseReason: () => LocalDataStoreCloseReason,
+  LocalDataStoreClosedError: () => LocalDataStoreClosedError
 });
 module.exports = __toCommonJS(local_data_store_exports);
+var LocalDataStoreCloseReason = /* @__PURE__ */ ((LocalDataStoreCloseReason2) => {
+  LocalDataStoreCloseReason2["ClosedByBrowser"] = "closedByBrowser";
+  LocalDataStoreCloseReason2["ClosedByOwner"] = "closedByOwner";
+  LocalDataStoreCloseReason2["VersionChange"] = "versionChange";
+  return LocalDataStoreCloseReason2;
+})(LocalDataStoreCloseReason || {});
 class LocalDataStore {
   constructor(database) {
     this.database = database;
+    database.onversionchange = () => {
+      this.markClosed("versionChange" /* VersionChange */);
+      database.close();
+    };
+    database.addEventListener("close", () => {
+      this.markClosed("closedByBrowser" /* ClosedByBrowser */);
+    });
   }
   database;
+  /**
+   * Whether the connection is closed or closing, so no further operation can run.
+   *
+   * @returns `true` once {@link LocalDataStore.close} was called, or the browser or a schema upgrade closed the
+   *   connection.
+   */
+  get isClosed() {
+    return this.closeReason !== null;
+  }
+  closeReason = null;
   /**
    * Opens an isolated database. Writes resolve only once their transaction commits.
    *
@@ -112,11 +137,7 @@ class LocalDataStore {
         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));
+        resolve(new LocalDataStore(request.result));
       };
     });
   }
@@ -129,9 +150,11 @@ class LocalDataStore {
     await this.run("readwrite", (store) => store.clear());
   }
   /**
-   * Closes this connection without deleting its records.
+   * Closes this connection without deleting its records. Every later operation rejects with
+   * {@link LocalDataStoreClosedError}. Closing twice is harmless.
    */
   close() {
+    this.markClosed("closedByOwner" /* ClosedByOwner */);
     this.database.close();
   }
   /**
@@ -233,9 +256,22 @@ class LocalDataStore {
   async set(key, value) {
     await this.run("readwrite", (store) => store.put(value, key));
   }
+  markClosed(reason) {
+    this.closeReason ??= reason;
+  }
+  // eslint-disable-next-line typescript-dev-toolkit/no-undefined-return-type -- Mirrors IndexedDB: a missing record reads as `undefined`, which a stored `null` must stay distinct from.
   async run(mode, action) {
     return await new Promise((resolve, reject) => {
-      const transaction = this.database.transaction("records", mode);
+      let transaction;
+      try {
+        if (this.closeReason !== null) {
+          throw new LocalDataStoreClosedError(this.database.name, this.closeReason);
+        }
+        transaction = this.database.transaction("records", mode);
+      } catch (error) {
+        reject(this.toClosedError(error));
+        return;
+      }
       let request;
       try {
         request = action(transaction.objectStore("records"));
@@ -252,9 +288,37 @@ class LocalDataStore {
       });
     });
   }
+  toClosedError(error) {
+    if (error instanceof LocalDataStoreClosedError) {
+      return error;
+    }
+    if (error instanceof Error && error.name === "InvalidStateError") {
+      return new LocalDataStoreClosedError(this.database.name, this.closeReason ?? "closedByBrowser" /* ClosedByBrowser */, { cause: error });
+    }
+    return error instanceof Error ? error : new Error("Local data-store transaction failed", { cause: error });
+  }
+}
+class LocalDataStoreClosedError extends Error {
+  /**
+   * Creates a {@link LocalDataStoreClosedError}.
+   *
+   * @param databaseName - The IndexedDB database name of the store.
+   * @param reason - Why the connection closed.
+   * @param options - The IndexedDB error this one replaces, as its `cause`.
+   */
+  constructor(databaseName, reason, options) {
+    super(`The local data store "${databaseName}" is closed (${reason}), so the operation was not run.`, options);
+    this.databaseName = databaseName;
+    this.reason = reason;
+    this.name = "LocalDataStoreClosedError";
+  }
+  databaseName;
+  reason;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LocalDataStore
+  LocalDataStore,
+  LocalDataStoreCloseReason,
+  LocalDataStoreClosedError
 });
-//# 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   * Deletes every record of this store first, in the same transaction as the writes.\n   *\n   * Either the store is replaced by `entries` as a whole, or, when the transaction fails, every previous record survives.\n   *\n   * @default `false`\n   */\n  readonly shouldClear?: boolean;\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, optionally after clearing the store.\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      if (params.shouldClear) {\n        store.clear();\n      }\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      // No request to resolve with: a closing `store.count()` would walk every record of the store on each commit.\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    // Two bulk reads in one transaction see the same snapshot in the same key order, so they pair up by index.\n    // A cursor dispatches one event per record instead; at 90,000 records in Obsidian it took 1.5 to 2 times as long.\n    await this.run('readonly', (store) => {\n      const keysRequest = store.getAllKeys();\n      const valuesRequest = store.getAll();\n      valuesRequest.onsuccess = (): void => {\n        const keys = keysRequest.result;\n        const values = valuesRequest.result;\n        for (const [index, key] of keys.entries()) {\n          if (typeof key !== 'string') {\n            throw new TypeError('Local data-store key is not a string');\n          }\n          records.push([key, values[index]]);\n        }\n      };\n      return valuesRequest;\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> | undefined): Promise<T | undefined> {\n    return await new Promise((resolve, reject) => {\n      const transaction = this.database.transaction('records', mode);\n      let request: IDBRequest<T> | undefined;\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        // An action that issued no request of its own resolves with `undefined` once its writes commit.\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":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/data-stores/local-data-store.ts"],"sourcesContent":["/**\n * @file\n *\n * Record-based device-local persistence, isolated by vault, plugin and store.\n */\n\n/**\n * Why a {@link LocalDataStore} connection stopped accepting operations.\n */\nexport enum LocalDataStoreCloseReason {\n  /**\n   * The browser closed the connection on its own, for example because the database was deleted or the storage was\n   * cleared.\n   */\n  ClosedByBrowser = 'closedByBrowser',\n  /**\n   * The owner called {@link LocalDataStore.close}, usually because it unloaded.\n   */\n  ClosedByOwner = 'closedByOwner',\n  /**\n   * Another connection asked for a newer schema version, so this one closed to let it upgrade.\n   */\n  VersionChange = 'versionChange'\n}\n\n/**\n * Options of a {@link LocalDataStoreClosedError}.\n */\nexport interface LocalDataStoreClosedErrorConstructorOptions {\n  /**\n   * The IndexedDB error the closed-store error replaces.\n   */\n  readonly cause?: unknown;\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   * Deletes every record of this store first, in the same transaction as the writes.\n   *\n   * Either the store is replaced by `entries` as a whole, or, when the transaction fails, every previous record survives.\n   *\n   * @default `false`\n   */\n  readonly shouldClear?: boolean;\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  /**\n   * Whether the connection is closed or closing, so no further operation can run.\n   *\n   * @returns `true` once {@link LocalDataStore.close} was called, or the browser or a schema upgrade closed the\n   *   connection.\n   */\n  public get isClosed(): boolean {\n    return this.closeReason !== null;\n  }\n\n  private closeReason: LocalDataStoreCloseReason | null = null;\n\n  private constructor(private readonly database: IDBDatabase) {\n    database.onversionchange = (): void => {\n      this.markClosed(LocalDataStoreCloseReason.VersionChange);\n      database.close();\n    };\n    // Fired only when the browser closes the connection abnormally, never after `close()`.\n    database.addEventListener('close', (): void => {\n      this.markClosed(LocalDataStoreCloseReason.ClosedByBrowser);\n    });\n  }\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        resolve(new LocalDataStore(request.result));\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. Every later operation rejects with\n   * {@link LocalDataStoreClosedError}. Closing twice is harmless.\n   */\n  public close(): void {\n    this.markClosed(LocalDataStoreCloseReason.ClosedByOwner);\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, optionally after clearing the store.\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      if (params.shouldClear) {\n        store.clear();\n      }\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      // No request to resolve with: a closing `store.count()` would walk every record of the store on each commit.\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    // Two bulk reads in one transaction see the same snapshot in the same key order, so they pair up by index.\n    // A cursor dispatches one event per record instead; at 90,000 records in Obsidian it took 1.5 to 2 times as long.\n    await this.run('readonly', (store) => {\n      const keysRequest = store.getAllKeys();\n      const valuesRequest = store.getAll();\n      valuesRequest.onsuccess = (): void => {\n        const keys = keysRequest.result;\n        const values = valuesRequest.result;\n        for (const [index, key] of keys.entries()) {\n          if (typeof key !== 'string') {\n            throw new TypeError('Local data-store key is not a string');\n          }\n          records.push([key, values[index]]);\n        }\n      };\n      return valuesRequest;\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 markClosed(reason: LocalDataStoreCloseReason): void {\n    this.closeReason ??= reason;\n  }\n\n  // eslint-disable-next-line typescript-dev-toolkit/no-undefined-return-type -- Mirrors IndexedDB: a missing record reads as `undefined`, which a stored `null` must stay distinct from.\n  private async run<T>(mode: IDBTransactionMode, action: (store: IDBObjectStore) => IDBRequest<T> | undefined): Promise<T | undefined> {\n    return await new Promise((resolve, reject) => {\n      let transaction: IDBTransaction;\n      try {\n        if (this.closeReason !== null) {\n          throw new LocalDataStoreClosedError(this.database.name, this.closeReason);\n        }\n        transaction = this.database.transaction('records', mode);\n      } catch (error) {\n        reject(this.toClosedError(error));\n        return;\n      }\n      let request: IDBRequest<T> | undefined;\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        // An action that issued no request of its own resolves with `undefined` once its writes commit.\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  private toClosedError(error: unknown): Error {\n    if (error instanceof LocalDataStoreClosedError) {\n      return error;\n    }\n    // A closing connection makes `transaction()` throw `InvalidStateError` synchronously.\n    if (error instanceof Error && error.name === 'InvalidStateError') {\n      return new LocalDataStoreClosedError(this.database.name, this.closeReason ?? LocalDataStoreCloseReason.ClosedByBrowser, { cause: error });\n    }\n    return error instanceof Error ? error : new Error('Local data-store transaction failed', { cause: error });\n  }\n}\n\n/**\n * Thrown by every operation of a {@link LocalDataStore} whose connection is closed or closing.\n *\n * It replaces IndexedDB's raw `InvalidStateError` (\"The database connection is closing\"), which names neither the\n * store nor the cause. The usual cause is work that outlived its owner: a debounced or scheduled save that runs after\n * the plugin unloaded and closed its store.\n */\nexport class LocalDataStoreClosedError extends Error {\n  /**\n   * Creates a {@link LocalDataStoreClosedError}.\n   *\n   * @param databaseName - The IndexedDB database name of the store.\n   * @param reason - Why the connection closed.\n   * @param options - The IndexedDB error this one replaces, as its `cause`.\n   */\n  public constructor(\n    public readonly databaseName: string,\n    public readonly reason: LocalDataStoreCloseReason,\n    options?: LocalDataStoreClosedErrorConstructorOptions\n  ) {\n    super(`The local data store \"${databaseName}\" is closed (${reason}), so the operation was not run.`, options);\n    this.name = 'LocalDataStoreClosedError';\n  }\n}\n"],"mappings":"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","names":["LocalDataStoreCloseReason"]}

package/dist/lib/cjs/data-stores/local-data-store.d.cts

@@ -5,6 +5,33 @@
  *
  * Record-based device-local persistence, isolated by vault, plugin and store.
  */
+/**
+ * Why a {@link LocalDataStore} connection stopped accepting operations.
+ */
+export declare enum LocalDataStoreCloseReason {
+    /**
+     * The browser closed the connection on its own, for example because the database was deleted or the storage was
+     * cleared.
+     */
+    ClosedByBrowser = "closedByBrowser",
+    /**
+     * The owner called {@link LocalDataStore.close}, usually because it unloaded.
+     */
+    ClosedByOwner = "closedByOwner",
+    /**
+     * Another connection asked for a newer schema version, so this one closed to let it upgrade.
+     */
+    VersionChange = "versionChange"
+}
+/**
+ * Options of a {@link LocalDataStoreClosedError}.
+ */
+export interface LocalDataStoreClosedErrorConstructorOptions {
+    /**
+     * The IndexedDB error the closed-store error replaces.
+     */
+    readonly cause?: unknown;
+}
 /**
  * Atomic mutations of a local record store.
  */
@@ -54,6 +81,14 @@ export interface LocalDataStoreOpenParams {
  */
 export declare class LocalDataStore {
     private readonly database;
+    /**
+     * Whether the connection is closed or closing, so no further operation can run.
+     *
+     * @returns `true` once {@link LocalDataStore.close} was called, or the browser or a schema upgrade closed the
+     *   connection.
+     */
+    get isClosed(): boolean;
+    private closeReason;
     private constructor();
     /**
      * Opens an isolated database. Writes resolve only once their transaction commits.
@@ -69,7 +104,8 @@ export declare class LocalDataStore {
      */
     clear(): Promise<void>;
     /**
-     * Closes this connection without deleting its records.
+     * Closes this connection without deleting its records. Every later operation rejects with
+     * {@link LocalDataStoreClosedError}. Closing twice is harmless.
      */
     close(): void;
     /**
@@ -123,5 +159,26 @@ export declare class LocalDataStore {
      * @returns A promise that resolves after commit.
      */
     set(key: string, value: unknown): Promise<void>;
+    private markClosed;
     private run;
+    private toClosedError;
+}
+/**
+ * Thrown by every operation of a {@link LocalDataStore} whose connection is closed or closing.
+ *
+ * It replaces IndexedDB's raw `InvalidStateError` ("The database connection is closing"), which names neither the
+ * store nor the cause. The usual cause is work that outlived its owner: a debounced or scheduled save that runs after
+ * the plugin unloaded and closed its store.
+ */
+export declare class LocalDataStoreClosedError extends Error {
+    readonly databaseName: string;
+    readonly reason: LocalDataStoreCloseReason;
+    /**
+     * Creates a {@link LocalDataStoreClosedError}.
+     *
+     * @param databaseName - The IndexedDB database name of the store.
+     * @param reason - Why the connection closed.
+     * @param options - The IndexedDB error this one replaces, as its `cause`.
+     */
+    constructor(databaseName: string, reason: LocalDataStoreCloseReason, options?: LocalDataStoreClosedErrorConstructorOptions);
 }