@mnaoumov/obsidian-lib 10.3.0 → 10.4.1

package/dist/lib/esm/components/bulk-operation-commit-component.d.mts

@@ -0,0 +1,152 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Contains class {@link BulkOperationCommitComponent} that wraps a plugin's bulk operations in git commits, so
+ * `git revert` undoes one.
+ */
+import type { App } from 'obsidian';
+import type { Promisable } from 'type-fest';
+import type { PluginNoticeComponent } from './plugin-notice-component.mjs';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * Constructor parameters for {@link BulkOperationCommitComponent}.
+ */
+export interface BulkOperationCommitComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * Whether the plugin's opt-in setting for bulk-operation commits is on. Read on every operation, so a settings
+     * change applies to the next one.
+     */
+    readonly isEnabled: () => boolean;
+    /**
+     * The longest the settle step waits for the vault to go quiet after an operation.
+     *
+     * @default `60_000`
+     */
+    readonly maxSettleTimeInMilliseconds?: number;
+    /**
+     * The id of the plugin whose operations are committed.
+     */
+    readonly pluginId: string;
+    /**
+     * The notice component used to report problems.
+     */
+    readonly pluginNoticeComponent: PluginNoticeComponent;
+    /**
+     * How long the vault must go without a change after an operation before its commit is made.
+     *
+     * @default `2000`
+     */
+    readonly quietPeriodInMilliseconds?: number;
+}
+/**
+ * Parameters for {@link BulkOperationCommitComponent.runBulkOperation}.
+ *
+ * @typeParam T - The type of the operation's result.
+ */
+export interface BulkOperationCommitComponentRunBulkOperationParams<T> {
+    /**
+     * Runs the bulk operation.
+     *
+     * @returns The operation's result.
+     */
+    readonly operation: () => Promisable<T>;
+    /**
+     * A one-line description of the operation, used in the commit subject, such as `Collect attachments in Notes`.
+     */
+    readonly summary: string;
+}
+/**
+ * Wraps a plugin's bulk operations in git commits, so `git revert` of one commit undoes one operation.
+ *
+ * @remarks
+ * Opt-in through the plugin's own setting, and active only on desktop, for a vault inside a git work tree. When it
+ * is not active, {@link runBulkOperation} simply runs the operation. When it is, the operation runs between a
+ * `chore: before OP<n>` commit of whatever was pending and an `OP<n>: <summary>` commit of what it changed, under
+ * a lease lock in the repo's git directory that the scheduled vault autocommit honors. The lock's heartbeat
+ * is refreshed by the operation's progress: every `loop()` item, or an explicit `reportBulkOperationProgress()`.
+ *
+ * On load it recovers a lock left stale by a crash, committing the leftovers as `OP<n> interrupted`.
+ *
+ * Pair it with `UndoBulkOperationCommandHandler`, which lists the plugin's operations and reverts one.
+ *
+ * @example
+ * ```ts
+ * this.bulkOperationCommitComponent = this.addChild(new BulkOperationCommitComponent({
+ *   app: this.app,
+ *   isEnabled: () => this.settings.shouldCommitBulkOperations,
+ *   pluginId: this.manifest.id,
+ *   pluginNoticeComponent: this.pluginNoticeComponent
+ * }));
+ *
+ * await this.bulkOperationCommitComponent.runBulkOperation({
+ *   operation: () => collectAttachmentsInFolder(folder),
+ *   summary: `Collect attachments in ${folder.path}`
+ * });
+ * ```
+ */
+export declare class BulkOperationCommitComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * Whether the plugin's opt-in setting is on.
+     */
+    protected readonly isEnabled: () => boolean;
+    /**
+     * The id of the plugin whose operations are committed.
+     */
+    protected readonly pluginId: string;
+    /**
+     * The notice component used to report problems.
+     */
+    protected readonly pluginNoticeComponent: PluginNoticeComponent;
+    private readonly maxSettleTimeInMilliseconds;
+    private readonly quietPeriodInMilliseconds;
+    private repoPromise;
+    /**
+     * Creates a new instance.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: BulkOperationCommitComponentConstructorParams);
+    /**
+     * Checks whether bulk operations are currently committed: the setting is on, the app is desktop and the vault is
+     * inside a git work tree.
+     *
+     * @returns Whether bulk operations are committed.
+     */
+    checkActive(): Promise<boolean>;
+    /**
+     * Recovers a stale lock left by a crashed operation once the component loads.
+     */
+    onload(): void;
+    /**
+     * Runs a bulk operation, wrapped in git commits when bulk-operation commits are active.
+     *
+     * @typeParam T - The type of the operation's result.
+     * @param params - The parameters.
+     * @returns The operation's result.
+     */
+    runBulkOperation<T>(params: BulkOperationCommitComponentRunBulkOperationParams<T>): Promise<T>;
+    /**
+     * Lets the user pick one of the plugin's bulk operations and reverts its commit.
+     *
+     * A conflict is reported and left for the user to resolve; the revert is never aborted.
+     *
+     * @param operationId - The operation to undo, such as `OP12`. When omitted, the user picks from every operation
+     * of the plugin. When two commits share the id (two machines minted it before syncing), the user picks between
+     * them.
+     */
+    undoBulkOperation(operationId?: string): Promise<void>;
+    private findRepo;
+    private getRepo;
+    private recoverStaleLock;
+    private settle;
+    private waitForQuietVault;
+}

package/dist/lib/esm/components/bulk-operation-commit-component.mjs

@@ -0,0 +1,245 @@
+/*
+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 {
+  invokeAsyncSafely,
+  setTimeoutAsync
+} from "@mnaoumov/typescript-lib/async";
+import { errorToString } from "@mnaoumov/typescript-lib/error";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  FileSystemAdapter,
+  Platform
+} from "obsidian";
+import { reportBulkOperationProgress } from "../bulk-operation-progress.mjs";
+import { getObsidianLibDebugger } from "../debug.mjs";
+import { waitForPendingLinkUpdates } from "../file-manager.mjs";
+import { t } from "../i18n/i18n.mjs";
+import { ensureMetadataCacheReady } from "../metadata-cache.mjs";
+import { selectItem } from "../modals/select-item.mjs";
+import { flushQueue } from "../queue.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+const DEFAULT_MAX_SETTLE_TIME_IN_MILLISECONDS = 6e4;
+const DEFAULT_QUIET_PERIOD_IN_MILLISECONDS = 2e3;
+const SHORT_SHA_LENGTH = 8;
+class BulkOperationCommitComponent extends ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * Whether the plugin's opt-in setting is on.
+   */
+  isEnabled;
+  /**
+   * The id of the plugin whose operations are committed.
+   */
+  pluginId;
+  /**
+   * The notice component used to report problems.
+   */
+  pluginNoticeComponent;
+  maxSettleTimeInMilliseconds;
+  quietPeriodInMilliseconds;
+  repoPromise = null;
+  /**
+   * Creates a new instance.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.isEnabled = params.isEnabled;
+    this.pluginId = params.pluginId;
+    this.pluginNoticeComponent = params.pluginNoticeComponent;
+    this.maxSettleTimeInMilliseconds = params.maxSettleTimeInMilliseconds ?? DEFAULT_MAX_SETTLE_TIME_IN_MILLISECONDS;
+    this.quietPeriodInMilliseconds = params.quietPeriodInMilliseconds ?? DEFAULT_QUIET_PERIOD_IN_MILLISECONDS;
+  }
+  /**
+   * Checks whether bulk operations are currently committed: the setting is on, the app is desktop and the vault is
+   * inside a git work tree.
+   *
+   * @returns Whether bulk operations are committed.
+   */
+  async checkActive() {
+    return await this.getRepo() !== null;
+  }
+  /**
+   * Recovers a stale lock left by a crashed operation once the component loads.
+   */
+  onload() {
+    super.onload();
+    invokeAsyncSafely(() => this.recoverStaleLock());
+  }
+  /**
+   * Runs a bulk operation, wrapped in git commits when bulk-operation commits are active.
+   *
+   * @typeParam T - The type of the operation's result.
+   * @param params - The parameters.
+   * @returns The operation's result.
+   */
+  async runBulkOperation(params) {
+    const repo = await this.getRepo();
+    if (!repo) {
+      return await params.operation();
+    }
+    const { commitSha, operationId, result } = await repo.runBulkOperation({
+      operation: async () => await params.operation(),
+      pluginId: this.pluginId,
+      settle: () => this.settle(),
+      summary: params.summary
+    });
+    getObsidianLibDebugger("BulkOperationCommitComponent")(
+      commitSha === null ? `${operationId} changed nothing` : `${operationId} committed as ${commitSha}`
+    );
+    return result;
+  }
+  /**
+   * Lets the user pick one of the plugin's bulk operations and reverts its commit.
+   *
+   * A conflict is reported and left for the user to resolve; the revert is never aborted.
+   *
+   * @param operationId - The operation to undo, such as `OP12`. When omitted, the user picks from every operation
+   * of the plugin. When two commits share the id (two machines minted it before syncing), the user picks between
+   * them.
+   */
+  async undoBulkOperation(operationId) {
+    const repo = await this.getRepo();
+    if (!repo) {
+      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.notActive));
+      return;
+    }
+    let commits = await repo.listBulkOperationCommits(this.pluginId);
+    if (operationId !== void 0) {
+      commits = commits.filter((commit2) => commit2.operationId === operationId);
+    }
+    if (commits.length === 0) {
+      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.noOperations));
+      return;
+    }
+    const commit = commits.length === 1 && operationId !== void 0 ? ensureNonNullable(commits[0]) : await selectItem({
+      app: this.app,
+      items: commits,
+      itemTextFunction: formatCommit,
+      placeholder: t(($) => $.obsidianLib.bulkOperation.selectOperation)
+    });
+    if (!commit) {
+      return;
+    }
+    let revertResult;
+    try {
+      revertResult = await repo.revertBulkOperationCommit(commit);
+    } catch (error) {
+      this.pluginNoticeComponent.showNotice(
+        t(($) => $.obsidianLib.bulkOperation.revertFailed, { error: errorToString(error), operationId: commit.operationId })
+      );
+      return;
+    }
+    if (revertResult.isConflict) {
+      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.revertConflict, { operationId: commit.operationId }), {
+        isPermanent: true
+      });
+      return;
+    }
+    this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.reverted, { operationId: commit.operationId }));
+  }
+  async findRepo() {
+    if (!Platform.isDesktopApp) {
+      return null;
+    }
+    const adapter = this.app.vault.adapter;
+    if (!(adapter instanceof FileSystemAdapter)) {
+      return null;
+    }
+    const { BulkOperationGitRepo: GitRepo } = await import("../desktop-bulk-operation-git.mjs");
+    return await GitRepo.open(adapter.getBasePath());
+  }
+  async getRepo() {
+    if (!this.isEnabled()) {
+      return null;
+    }
+    this.repoPromise ??= this.findRepo();
+    return await this.repoPromise;
+  }
+  async recoverStaleLock() {
+    const repo = await this.getRepo();
+    if (!repo) {
+      return;
+    }
+    const operationId = await repo.recoverStaleLock();
+    if (operationId !== null) {
+      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.recoveredInterrupted, { operationId }));
+    }
+  }
+  async settle() {
+    await flushQueue();
+    await waitForPendingLinkUpdates(this.app);
+    await ensureMetadataCacheReady(this.app);
+    await this.waitForQuietVault();
+  }
+  async waitForQuietVault() {
+    let lastChangeAt = performance.now();
+    const deadline = lastChangeAt + this.maxSettleTimeInMilliseconds;
+    function onChange() {
+      lastChangeAt = performance.now();
+    }
+    const eventRefs = [
+      this.app.vault.on("create", onChange),
+      this.app.vault.on("delete", onChange),
+      this.app.vault.on("modify", onChange),
+      this.app.vault.on("rename", onChange)
+    ];
+    try {
+      for (; ; ) {
+        const now = performance.now();
+        const quietRemaining = lastChangeAt + this.quietPeriodInMilliseconds - now;
+        if (quietRemaining <= 0 || now >= deadline) {
+          return;
+        }
+        reportBulkOperationProgress();
+        await setTimeoutAsync(Math.min(quietRemaining, deadline - now));
+      }
+    } finally {
+      for (const eventRef of eventRefs) {
+        this.app.vault.offref(eventRef);
+      }
+    }
+  }
+}
+function formatCommit(commit) {
+  return `${commit.subject} (${commit.date}, ${commit.sha.slice(0, SHORT_SHA_LENGTH)})`;
+}
+export {
+  BulkOperationCommitComponent
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/bulk-operation-commit-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Contains class {@link BulkOperationCommitComponent} that wraps a plugin's bulk operations in git commits, so\n * `git revert` undoes one.\n */\n\nimport type {\n  App,\n  EventRef\n} from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  invokeAsyncSafely,\n  setTimeoutAsync\n} from '@mnaoumov/typescript-lib/async';\nimport { errorToString } from '@mnaoumov/typescript-lib/error';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport {\n  FileSystemAdapter,\n  Platform\n} from 'obsidian';\n\nimport type { BulkOperationCommit } from '../bulk-operation.ts';\nimport type { BulkOperationGitRepo } from '../desktop-bulk-operation-git.ts';\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\n\nimport { reportBulkOperationProgress } from '../bulk-operation-progress.ts';\nimport { getObsidianLibDebugger } from '../debug.ts';\nimport { waitForPendingLinkUpdates } from '../file-manager.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { ensureMetadataCacheReady } from '../metadata-cache.ts';\nimport { selectItem } from '../modals/select-item.ts';\nimport { flushQueue } from '../queue.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * Constructor parameters for {@link BulkOperationCommitComponent}.\n */\nexport interface BulkOperationCommitComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether the plugin's opt-in setting for bulk-operation commits is on. Read on every operation, so a settings\n   * change applies to the next one.\n   */\n  readonly isEnabled: () => boolean;\n\n  /**\n   * The longest the settle step waits for the vault to go quiet after an operation.\n   *\n   * @default `60_000`\n   */\n  readonly maxSettleTimeInMilliseconds?: number;\n\n  /**\n   * The id of the plugin whose operations are committed.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The notice component used to report problems.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * How long the vault must go without a change after an operation before its commit is made.\n   *\n   * @default `2000`\n   */\n  readonly quietPeriodInMilliseconds?: number;\n}\n\n/**\n * Parameters for {@link BulkOperationCommitComponent.runBulkOperation}.\n *\n * @typeParam T - The type of the operation's result.\n */\nexport interface BulkOperationCommitComponentRunBulkOperationParams<T> {\n  /**\n   * Runs the bulk operation.\n   *\n   * @returns The operation's result.\n   */\n  readonly operation: () => Promisable<T>;\n\n  /**\n   * A one-line description of the operation, used in the commit subject, such as `Collect attachments in Notes`.\n   */\n  readonly summary: string;\n}\n\nconst DEFAULT_MAX_SETTLE_TIME_IN_MILLISECONDS = 60_000;\nconst DEFAULT_QUIET_PERIOD_IN_MILLISECONDS = 2000;\nconst SHORT_SHA_LENGTH = 8;\n\n/**\n * Wraps a plugin's bulk operations in git commits, so `git revert` of one commit undoes one operation.\n *\n * @remarks\n * Opt-in through the plugin's own setting, and active only on desktop, for a vault inside a git work tree. When it\n * is not active, {@link runBulkOperation} simply runs the operation. When it is, the operation runs between a\n * `chore: before OP<n>` commit of whatever was pending and an `OP<n>: <summary>` commit of what it changed, under\n * a lease lock in the repo's git directory that the scheduled vault autocommit honors. The lock's heartbeat\n * is refreshed by the operation's progress: every `loop()` item, or an explicit `reportBulkOperationProgress()`.\n *\n * On load it recovers a lock left stale by a crash, committing the leftovers as `OP<n> interrupted`.\n *\n * Pair it with `UndoBulkOperationCommandHandler`, which lists the plugin's operations and reverts one.\n *\n * @example\n * ```ts\n * this.bulkOperationCommitComponent = this.addChild(new BulkOperationCommitComponent({\n *   app: this.app,\n *   isEnabled: () => this.settings.shouldCommitBulkOperations,\n *   pluginId: this.manifest.id,\n *   pluginNoticeComponent: this.pluginNoticeComponent\n * }));\n *\n * await this.bulkOperationCommitComponent.runBulkOperation({\n *   operation: () => collectAttachmentsInFolder(folder),\n *   summary: `Collect attachments in ${folder.path}`\n * });\n * ```\n */\nexport class BulkOperationCommitComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * Whether the plugin's opt-in setting is on.\n   */\n  protected readonly isEnabled: () => boolean;\n\n  /**\n   * The id of the plugin whose operations are committed.\n   */\n  protected readonly pluginId: string;\n\n  /**\n   * The notice component used to report problems.\n   */\n  protected readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  private readonly maxSettleTimeInMilliseconds: number;\n  private readonly quietPeriodInMilliseconds: number;\n  private repoPromise: null | Promise<BulkOperationGitRepo | null> = null;\n\n  /**\n   * Creates a new instance.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: BulkOperationCommitComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.isEnabled = params.isEnabled;\n    this.pluginId = params.pluginId;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.maxSettleTimeInMilliseconds = params.maxSettleTimeInMilliseconds ?? DEFAULT_MAX_SETTLE_TIME_IN_MILLISECONDS;\n    this.quietPeriodInMilliseconds = params.quietPeriodInMilliseconds ?? DEFAULT_QUIET_PERIOD_IN_MILLISECONDS;\n  }\n\n  /**\n   * Checks whether bulk operations are currently committed: the setting is on, the app is desktop and the vault is\n   * inside a git work tree.\n   *\n   * @returns Whether bulk operations are committed.\n   */\n  public async checkActive(): Promise<boolean> {\n    return await this.getRepo() !== null;\n  }\n\n  /**\n   * Recovers a stale lock left by a crashed operation once the component loads.\n   */\n  public override onload(): void {\n    super.onload();\n    invokeAsyncSafely(() => this.recoverStaleLock());\n  }\n\n  /**\n   * Runs a bulk operation, wrapped in git commits when bulk-operation commits are active.\n   *\n   * @typeParam T - The type of the operation's result.\n   * @param params - The parameters.\n   * @returns The operation's result.\n   */\n  public async runBulkOperation<T>(params: BulkOperationCommitComponentRunBulkOperationParams<T>): Promise<T> {\n    const repo = await this.getRepo();\n    if (!repo) {\n      return await params.operation();\n    }\n\n    const { commitSha, operationId, result } = await repo.runBulkOperation({\n      operation: async () => await params.operation(),\n      pluginId: this.pluginId,\n      settle: () => this.settle(),\n      summary: params.summary\n    });\n    getObsidianLibDebugger('BulkOperationCommitComponent')(\n      commitSha === null ? `${operationId} changed nothing` : `${operationId} committed as ${commitSha}`\n    );\n    return result;\n  }\n\n  /**\n   * Lets the user pick one of the plugin's bulk operations and reverts its commit.\n   *\n   * A conflict is reported and left for the user to resolve; the revert is never aborted.\n   *\n   * @param operationId - The operation to undo, such as `OP12`. When omitted, the user picks from every operation\n   * of the plugin. When two commits share the id (two machines minted it before syncing), the user picks between\n   * them.\n   */\n  public async undoBulkOperation(operationId?: string): Promise<void> {\n    const repo = await this.getRepo();\n    if (!repo) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.notActive));\n      return;\n    }\n\n    let commits = await repo.listBulkOperationCommits(this.pluginId);\n    if (operationId !== undefined) {\n      commits = commits.filter((commit) => commit.operationId === operationId);\n    }\n\n    if (commits.length === 0) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.noOperations));\n      return;\n    }\n\n    const commit = commits.length === 1 && operationId !== undefined\n      ? ensureNonNullable(commits[0])\n      : await selectItem({\n        app: this.app,\n        items: commits,\n        itemTextFunction: formatCommit,\n        placeholder: t(($) => $.obsidianLib.bulkOperation.selectOperation)\n      });\n    if (!commit) {\n      return;\n    }\n\n    let revertResult;\n    try {\n      revertResult = await repo.revertBulkOperationCommit(commit);\n    } catch (error) {\n      this.pluginNoticeComponent.showNotice(\n        t(($) => $.obsidianLib.bulkOperation.revertFailed, { error: errorToString(error), operationId: commit.operationId })\n      );\n      return;\n    }\n\n    if (revertResult.isConflict) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.revertConflict, { operationId: commit.operationId }), {\n        isPermanent: true\n      });\n      return;\n    }\n\n    this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.reverted, { operationId: commit.operationId }));\n  }\n\n  private async findRepo(): Promise<BulkOperationGitRepo | null> {\n    if (!Platform.isDesktopApp) {\n      return null;\n    }\n    const adapter = this.app.vault.adapter;\n    if (!(adapter instanceof FileSystemAdapter)) {\n      return null;\n    }\n    // Conditional import of the desktop-only git layer; this runs only on desktop, keeping its Node builtins off\n    // the mobile load path.\n    const { BulkOperationGitRepo: GitRepo } = await import('../desktop-bulk-operation-git.ts');\n    return await GitRepo.open(adapter.getBasePath());\n  }\n\n  private async getRepo(): Promise<BulkOperationGitRepo | null> {\n    if (!this.isEnabled()) {\n      return null;\n    }\n    this.repoPromise ??= this.findRepo();\n    return await this.repoPromise;\n  }\n\n  private async recoverStaleLock(): Promise<void> {\n    const repo = await this.getRepo();\n    if (!repo) {\n      return;\n    }\n    const operationId = await repo.recoverStaleLock();\n    if (operationId !== null) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianLib.bulkOperation.recoveredInterrupted, { operationId }));\n    }\n  }\n\n  private async settle(): Promise<void> {\n    await flushQueue();\n    await waitForPendingLinkUpdates(this.app);\n    await ensureMetadataCacheReady(this.app);\n    await this.waitForQuietVault();\n  }\n\n  private async waitForQuietVault(): Promise<void> {\n    let lastChangeAt = performance.now();\n    const deadline = lastChangeAt + this.maxSettleTimeInMilliseconds;\n    function onChange(): void {\n      lastChangeAt = performance.now();\n    }\n    const eventRefs: EventRef[] = [\n      this.app.vault.on('create', onChange),\n      this.app.vault.on('delete', onChange),\n      this.app.vault.on('modify', onChange),\n      this.app.vault.on('rename', onChange)\n    ];\n    try {\n      for (;;) {\n        const now = performance.now();\n        const quietRemaining = lastChangeAt + this.quietPeriodInMilliseconds - now;\n        if (quietRemaining <= 0 || now >= deadline) {\n          return;\n        }\n        reportBulkOperationProgress();\n        await setTimeoutAsync(Math.min(quietRemaining, deadline - now));\n      }\n    } finally {\n      for (const eventRef of eventRefs) {\n        this.app.vault.offref(eventRef);\n      }\n    }\n  }\n}\n\nfunction formatCommit(commit: BulkOperationCommit): string {\n  return `${commit.subject} (${commit.date}, ${commit.sha.slice(0, SHORT_SHA_LENGTH)})`;\n}\n"],"mappings":"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","names":["commit"]}

package/dist/lib/esm/components/index.d.mts

@@ -3,6 +3,7 @@ export * as 'abort-signal-component' from './abort-signal-component.mjs';
 export * as 'all-windows-event-component' from './all-windows-event-component.mjs';
 export * as 'async-error-handler-component' from './async-error-handler-component.mjs';
 export * as 'async-events-component' from './async-events-component.mjs';
+export * as 'bulk-operation-commit-component' from './bulk-operation-commit-component.mjs';
 export * as 'case-insensitive-file-index-component' from './case-insensitive-file-index-component.mjs';
 export * as 'component-ex' from './component-ex.mjs';
 export * as 'console-debug-component' from './console-debug-component.mjs';

package/dist/lib/esm/components/index.mjs

@@ -7,6 +7,7 @@ import * as abort_signal_component from "./abort-signal-component.mjs";
 import * as all_windows_event_component from "./all-windows-event-component.mjs";
 import * as async_error_handler_component from "./async-error-handler-component.mjs";
 import * as async_events_component from "./async-events-component.mjs";
+import * as bulk_operation_commit_component from "./bulk-operation-commit-component.mjs";
 import * as case_insensitive_file_index_component from "./case-insensitive-file-index-component.mjs";
 import * as component_ex from "./component-ex.mjs";
 import * as console_debug_component from "./console-debug-component.mjs";
@@ -39,6 +40,7 @@ export {
   all_windows_event_component as "all-windows-event-component",
   async_error_handler_component as "async-error-handler-component",
   async_events_component as "async-events-component",
+  bulk_operation_commit_component as "bulk-operation-commit-component",
   case_insensitive_file_index_component as "case-insensitive-file-index-component",
   component_ex as "component-ex",
   console_debug_component as "console-debug-component",
@@ -67,4 +69,4 @@ export {
   syntax_highlighting_component as "syntax-highlighting-component",
   templates_language_component as "templates-language-component"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvbXBvbmVudHMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnYWJvcnQtc2lnbmFsLWNvbXBvbmVudCcgZnJvbSAnLi9hYm9ydC1zaWduYWwtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdhbGwtd2luZG93cy1ldmVudC1jb21wb25lbnQnIGZyb20gJy4vYWxsLXdpbmRvd3MtZXZlbnQtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdhc3luYy1lcnJvci1oYW5kbGVyLWNvbXBvbmVudCcgZnJvbSAnLi9hc3luYy1lcnJvci1oYW5kbGVyLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnYXN5bmMtZXZlbnRzLWNvbXBvbmVudCcgZnJvbSAnLi9hc3luYy1ldmVudHMtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdidWxrLW9wZXJhdGlvbi1jb21taXQtY29tcG9uZW50JyBmcm9tICcuL2J1bGstb3BlcmF0aW9uLWNvbW1pdC1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ2Nhc2UtaW5zZW5zaXRpdmUtZmlsZS1pbmRleC1jb21wb25lbnQnIGZyb20gJy4vY2FzZS1pbnNlbnNpdGl2ZS1maWxlLWluZGV4LWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnY29tcG9uZW50LWV4JyBmcm9tICcuL2NvbXBvbmVudC1leC50cyc7XG5leHBvcnQgKiBhcyAnY29uc29sZS1kZWJ1Zy1jb21wb25lbnQnIGZyb20gJy4vY29uc29sZS1kZWJ1Zy1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ2NvcmUtcGx1Z2luLXRvZ2dsZS1jb21wb25lbnQnIGZyb20gJy4vY29yZS1wbHVnaW4tdG9nZ2xlLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnZGlzcG9zYWJsZS1jb21wb25lbnQnIGZyb20gJy4vZGlzcG9zYWJsZS1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ2VtYmVkLWV4dGVuc2lvbnMtY29tcG9uZW50JyBmcm9tICcuL2VtYmVkLWV4dGVuc2lvbnMtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdmaWxlLWV4cGxvcmVyLXJvb3QtbWVudS1jb21wb25lbnQnIGZyb20gJy4vZmlsZS1leHBsb3Jlci1yb290LW1lbnUtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdnZW5lcmF0ZS1tYXJrZG93bi1saW5rLWRlZmF1bHQtcGFyYW1zLWNvbXBvbmVudCcgZnJvbSAnLi9nZW5lcmF0ZS1tYXJrZG93bi1saW5rLWRlZmF1bHQtcGFyYW1zLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnaW5jcmVtZW50YWwtZmlsZS1pbmRleC1jb21wb25lbnQnIGZyb20gJy4vaW5jcmVtZW50YWwtZmlsZS1pbmRleC1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ2xheW91dC1yZWFkeS1jb21wb25lbnQnIGZyb20gJy4vbGF5b3V0LXJlYWR5LWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnbWVudS1ldmVudC1yZWdpc3RyYXItY29tcG9uZW50JyBmcm9tICcuL21lbnUtZXZlbnQtcmVnaXN0cmFyLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnbW9ua2V5LWFyb3VuZC1jb21wb25lbnQnIGZyb20gJy4vbW9ua2V5LWFyb3VuZC1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ25vdGVib29rLW5hdmlnYXRvci1tZW51LWV2ZW50LXJlZ2lzdHJhci1jb21wb25lbnQnIGZyb20gJy4vbm90ZWJvb2stbmF2aWdhdG9yLW1lbnUtZXZlbnQtcmVnaXN0cmFyLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWNvbnRleHQtY29tcG9uZW50JyBmcm9tICcuL3BsdWdpbi1jb250ZXh0LWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWdhdGUtY29tcG9uZW50JyBmcm9tICcuL3BsdWdpbi1nYXRlLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLW5vdGljZS1jb21wb25lbnQnIGZyb20gJy4vcGx1Z2luLW5vdGljZS1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1zZXR0aW5ncy1jb21wb25lbnQnIGZyb20gJy4vcGx1Z2luLXNldHRpbmdzLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLXNldHRpbmdzLXRhYi1jb21wb25lbnQnIGZyb20gJy4vcGx1Z2luLXNldHRpbmdzLXRhYi1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1zdWdnZXN0aW9uLWNvbXBvbmVudCcgZnJvbSAnLi9wbHVnaW4tc3VnZ2VzdGlvbi1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ3BvaW50ZXItcG9zaXRpb24tY29tcG9uZW50JyBmcm9tICcuL3BvaW50ZXItcG9zaXRpb24tY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdyZWdpc3RyeS1jb21wb25lbnQnIGZyb20gJy4vcmVnaXN0cnktY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdyZWxlYXNlLW5vdGVzLWNvbXBvbmVudCcgZnJvbSAnLi9yZWxlYXNlLW5vdGVzLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAncmVuYW1lLWRlbGV0ZS1oYW5kbGVyLWNvbXBvbmVudCcgZnJvbSAnLi9yZW5hbWUtZGVsZXRlLWhhbmRsZXItY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdybWRpci1ndWFyZC1jb21wb25lbnQnIGZyb20gJy4vcm1kaXItZ3VhcmQtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdzZXR0aW5ncy1taWdyYXRpb24tY29tcG9uZW50JyBmcm9tICcuL3NldHRpbmdzLW1pZ3JhdGlvbi1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ3N5bnRheC1oaWdobGlnaHRpbmctY29tcG9uZW50JyBmcm9tICcuL3N5bnRheC1oaWdobGlnaHRpbmctY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICd0ZW1wbGF0ZXMtbGFuZ3VhZ2UtY29tcG9uZW50JyBmcm9tICcuL3RlbXBsYXRlcy1sYW5ndWFnZS1jb21wb25lbnQudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFFQSxZQUFZQSw0QkFBOEI7QUFDMUMsWUFBWUMsaUNBQW1DO0FBQy9DLFlBQVlDLG1DQUFxQztBQUNqRCxZQUFZQyw0QkFBOEI7QUFDMUMsWUFBWUMscUNBQXVDO0FBQ25ELFlBQVlDLDJDQUE2QztBQUN6RCxZQUFZQyxrQkFBb0I7QUFDaEMsWUFBWUMsNkJBQStCO0FBQzNDLFlBQVlDLGtDQUFvQztBQUNoRCxZQUFZQywwQkFBNEI7QUFDeEMsWUFBWUMsZ0NBQWtDO0FBQzlDLFlBQVlDLHVDQUF5QztBQUNyRCxZQUFZQyxxREFBdUQ7QUFDbkUsWUFBWUMsc0NBQXdDO0FBQ3BELFlBQVlDLDRCQUE4QjtBQUMxQyxZQUFZQyxvQ0FBc0M7QUFDbEQsWUFBWUMsNkJBQStCO0FBQzNDLFlBQVlDLHVEQUF5RDtBQUNyRSxZQUFZQyw4QkFBZ0M7QUFDNUMsWUFBWUMsMkJBQTZCO0FBQ3pDLFlBQVlDLDZCQUErQjtBQUMzQyxZQUFZQywrQkFBaUM7QUFDN0MsWUFBWUMsbUNBQXFDO0FBQ2pELFlBQVlDLGlDQUFtQztBQUMvQyxZQUFZQyxnQ0FBa0M7QUFDOUMsWUFBWUMsd0JBQTBCO0FBQ3RDLFlBQVlDLDZCQUErQjtBQUMzQyxZQUFZQyxxQ0FBdUM7QUFDbkQsWUFBWUMsMkJBQTZCO0FBQ3pDLFlBQVlDLGtDQUFvQztBQUNoRCxZQUFZQyxtQ0FBcUM7QUFDakQsWUFBWUMsa0NBQW9DOyIsCiAgIm5hbWVzIjogWyJhYm9ydC1zaWduYWwtY29tcG9uZW50IiwgImFsbC13aW5kb3dzLWV2ZW50LWNvbXBvbmVudCIsICJhc3luYy1lcnJvci1oYW5kbGVyLWNvbXBvbmVudCIsICJhc3luYy1ldmVudHMtY29tcG9uZW50IiwgImJ1bGstb3BlcmF0aW9uLWNvbW1pdC1jb21wb25lbnQiLCAiY2FzZS1pbnNlbnNpdGl2ZS1maWxlLWluZGV4LWNvbXBvbmVudCIsICJjb21wb25lbnQtZXgiLCAiY29uc29sZS1kZWJ1Zy1jb21wb25lbnQiLCAiY29yZS1wbHVnaW4tdG9nZ2xlLWNvbXBvbmVudCIsICJkaXNwb3NhYmxlLWNvbXBvbmVudCIsICJlbWJlZC1leHRlbnNpb25zLWNvbXBvbmVudCIsICJmaWxlLWV4cGxvcmVyLXJvb3QtbWVudS1jb21wb25lbnQiLCAiZ2VuZXJhdGUtbWFya2Rvd24tbGluay1kZWZhdWx0LXBhcmFtcy1jb21wb25lbnQiLCAiaW5jcmVtZW50YWwtZmlsZS1pbmRleC1jb21wb25lbnQiLCAibGF5b3V0LXJlYWR5LWNvbXBvbmVudCIsICJtZW51LWV2ZW50LXJlZ2lzdHJhci1jb21wb25lbnQiLCAibW9ua2V5LWFyb3VuZC1jb21wb25lbnQiLCAibm90ZWJvb2stbmF2aWdhdG9yLW1lbnUtZXZlbnQtcmVnaXN0cmFyLWNvbXBvbmVudCIsICJwbHVnaW4tY29udGV4dC1jb21wb25lbnQiLCAicGx1Z2luLWdhdGUtY29tcG9uZW50IiwgInBsdWdpbi1ub3RpY2UtY29tcG9uZW50IiwgInBsdWdpbi1zZXR0aW5ncy1jb21wb25lbnQiLCAicGx1Z2luLXNldHRpbmdzLXRhYi1jb21wb25lbnQiLCAicGx1Z2luLXN1Z2dlc3Rpb24tY29tcG9uZW50IiwgInBvaW50ZXItcG9zaXRpb24tY29tcG9uZW50IiwgInJlZ2lzdHJ5LWNvbXBvbmVudCIsICJyZWxlYXNlLW5vdGVzLWNvbXBvbmVudCIsICJyZW5hbWUtZGVsZXRlLWhhbmRsZXItY29tcG9uZW50IiwgInJtZGlyLWd1YXJkLWNvbXBvbmVudCIsICJzZXR0aW5ncy1taWdyYXRpb24tY29tcG9uZW50IiwgInN5bnRheC1oaWdobGlnaHRpbmctY29tcG9uZW50IiwgInRlbXBsYXRlcy1sYW5ndWFnZS1jb21wb25lbnQiXQp9Cg==

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

@@ -64,7 +64,6 @@ class LocalDataStore {
       for (const [key, value] of params.entries) {
         store.put(value, key);
       }
-      return store.count();
     });
   }
   /**
@@ -159,7 +158,7 @@ class LocalDataStore {
         return;
       }
       transaction.oncomplete = () => {
-        resolve(request.result);
+        resolve(request?.result);
       };
       transaction.addEventListener("abort", () => {
         reject(new Error("Local data-store transaction aborted", { cause: transaction.error }));
@@ -170,4 +169,4 @@ class LocalDataStore {
 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   * 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      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    // 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>): 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": []
}

+//# 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": []
}
