@mnaoumov/obsidian-lib 10.3.0 → 10.4.1

package/dist/lib/esm/bulk-operation.d.mts

@@ -0,0 +1,237 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * The platform-neutral half of bulk-operation git commits: the lease-lock record, the `OP<n>` ids and the commit
+ * messages that carry them.
+ *
+ * A bulk operation wrapped by `BulkOperationCommitComponent` lands in the vault's git repo as one commit whose
+ * subject is `OP<n>: <summary>`, preceded (when the tree was dirty) by a `chore: before OP<n>` commit holding
+ * whatever was pending, so `git revert` of the `OP<n>` commit undoes exactly that operation. Everything in this
+ * module is pure, so it is shared by the desktop git layer and by the scheduled autocommit that reads the same lock.
+ *
+ * The lock record and the commit message trailers are a wire format between plugins built on different copies of
+ * this library and the vault autocommit script: fields may be added, never renamed or reinterpreted.
+ */
+/**
+ * The name of the lease-lock file, created inside the repo's git directory so it is never committed or
+ * synced.
+ */
+export declare const BULK_OPERATION_LOCK_FILE_NAME = "obsidian-bulk-operation.json";
+/**
+ * How long a lock may go without a heartbeat before it counts as stale.
+ *
+ * It errs long on purpose: holding a dead lock too long only makes an autocommit skip a tick, while declaring a
+ * live one stale splits its operation across two commits.
+ */
+export declare const BULK_OPERATION_LOCK_STALE_AFTER_IN_MILLISECONDS = 120000;
+/**
+ * The trailer key naming the operation id in a bulk-operation commit body.
+ */
+export declare const OPERATION_TRAILER_KEY = "Obsidian-Bulk-Operation";
+/**
+ * The trailer key naming the plugin in a bulk-operation commit body.
+ */
+export declare const PLUGIN_TRAILER_KEY = "Obsidian-Plugin";
+/**
+ * Parameters for {@link buildOperationCommitMessage}.
+ */
+export interface BuildOperationCommitMessageParams {
+    /**
+     * The number of files the commit changes.
+     */
+    readonly changedFileCount: number;
+    /**
+     * Whether the operation was interrupted.
+     */
+    readonly isInterrupted?: boolean;
+    /**
+     * The operation id, such as `OP12`.
+     */
+    readonly operationId: string;
+    /**
+     * The id of the plugin that ran the operation.
+     */
+    readonly pluginId: string;
+    /**
+     * A one-line description of the operation. Ignored for an interrupted operation.
+     */
+    readonly summary?: string;
+    /**
+     * When the operation ran.
+     */
+    readonly timestamp: Date;
+}
+/**
+ * A bulk-operation commit found in the repo history.
+ */
+export interface BulkOperationCommit {
+    /**
+     * The commit date, as an ISO 8601 string.
+     */
+    readonly date: string;
+    /**
+     * Whether the commit records an interrupted operation rather than a completed one.
+     */
+    readonly isInterrupted: boolean;
+    /**
+     * The operation id, such as `OP12`.
+     */
+    readonly operationId: string;
+    /**
+     * The full commit hash.
+     */
+    readonly sha: string;
+    /**
+     * The commit subject.
+     */
+    readonly subject: string;
+}
+/**
+ * The lease-lock record stored in `.git/obsidian-bulk-operation.json` while a bulk operation runs.
+ */
+export interface BulkOperationLock {
+    /**
+     * When the lock was last refreshed by the operation's progress, as epoch milliseconds.
+     */
+    readonly heartbeatAt: number;
+    /**
+     * The host name of the machine running the operation.
+     */
+    readonly host: string;
+    /**
+     * The operation id, such as `OP12`.
+     */
+    readonly operationId: string;
+    /**
+     * The id of the plugin running the operation.
+     */
+    readonly pluginId: string;
+    /**
+     * The id of the process running Obsidian. Only a fast path for an app crash; staleness never depends on it.
+     */
+    readonly processId: number;
+    /**
+     * When the process running Obsidian started, as epoch milliseconds, so a recycled process id is not mistaken for
+     * the original one.
+     */
+    readonly processStartedAt: number;
+    /**
+     * When the operation started, as epoch milliseconds.
+     */
+    readonly startedAt: number;
+}
+/**
+ * The facts {@link isBulkOperationLockStale} weighs besides the heartbeat.
+ */
+export interface BulkOperationLockStalenessContext {
+    /**
+     * When this machine last booted, as epoch milliseconds, or `null` when unknown.
+     */
+    readonly bootedAt: null | number;
+    /**
+     * The host name of this machine.
+     */
+    readonly host: string;
+    /**
+     * Whether the process recorded in the lock is still running on this machine, or `null` when it cannot be told.
+     */
+    readonly isProcessAlive: (processId: number) => boolean | null;
+    /**
+     * The current time, as epoch milliseconds.
+     */
+    readonly now: number;
+}
+/**
+ * The commit message of one bulk-operation commit.
+ */
+export interface OperationCommitMessage {
+    /**
+     * The commit body: the timestamp, the plugin and the counts, as git trailers.
+     */
+    readonly body: string;
+    /**
+     * The commit subject.
+     */
+    readonly subject: string;
+}
+/**
+ * Parameters for {@link parseBulkOperationCommit}.
+ */
+export interface ParseBulkOperationCommitParams {
+    /**
+     * The commit date, as an ISO 8601 string.
+     */
+    readonly date: string;
+    /**
+     * The full commit hash.
+     */
+    readonly sha: string;
+    /**
+     * The commit subject.
+     */
+    readonly subject: string;
+}
+/**
+ * Builds the subject of the commit that saves whatever was pending before an operation.
+ *
+ * @param operationId - The operation id, such as `OP12`.
+ * @returns The commit subject.
+ */
+export declare function buildBeforeOperationCommitSubject(operationId: string): string;
+/**
+ * Builds the message of the commit recording a bulk operation, or an interrupted one.
+ *
+ * @param params - The parameters.
+ * @returns The commit subject and body.
+ */
+export declare function buildOperationCommitMessage(params: BuildOperationCommitMessageParams): OperationCommitMessage;
+/**
+ * Formats an operation id from its number.
+ *
+ * @param operationNumber - The operation number.
+ * @returns The operation id, such as `OP12`.
+ */
+export declare function formatOperationId(operationNumber: number): string;
+/**
+ * Finds the next operation id from the subjects of the bulk-operation commits already in the history.
+ *
+ * @param subjects - Commit subjects; anything that is not a bulk-operation subject is ignored.
+ * @returns `OP<n>` with n one past the highest number found, or `OP1` when there is none.
+ */
+export declare function getNextOperationId(subjects: readonly string[]): string;
+/**
+ * Checks whether a value has the shape of a {@link BulkOperationLock}.
+ *
+ * @param value - The value read from the lock file.
+ * @returns Whether it is a lock record.
+ */
+export declare function isBulkOperationLock(value: unknown): value is BulkOperationLock;
+/**
+ * Decides whether a lease lock is stale, so whoever finds it may commit the leftovers and remove it.
+ *
+ * The heartbeat is the rule; the reboot and crashed-process checks are only fast paths that shorten the wait, and
+ * neither can make a lock with a fresh heartbeat on another machine stale.
+ *
+ * @param lock - The lock record.
+ * @param context - The facts about this machine.
+ * @returns Whether the lock is stale.
+ */
+export declare function isBulkOperationLockStale(lock: BulkOperationLock, context: BulkOperationLockStalenessContext): boolean;
+/**
+ * Parses a bulk-operation commit subject into the commit it describes, skipping the `chore: before` commits, which
+ * are not operations.
+ *
+ * @param params - The commit's hash, date and subject.
+ * @returns The bulk-operation commit, or `null` when the subject is not one.
+ */
+export declare function parseBulkOperationCommit(params: ParseBulkOperationCommitParams): BulkOperationCommit | null;
+/**
+ * Parses the operation number out of a bulk-operation commit subject.
+ *
+ * Recognizes `OP<n>: <summary>`, `OP<n> interrupted` and `chore: before OP<n>`.
+ *
+ * @param subject - The commit subject.
+ * @returns The operation number, or `null` when the subject is not a bulk-operation subject.
+ */
+export declare function parseOperationNumber(subject: string): null | number;

package/dist/lib/esm/bulk-operation.mjs

@@ -0,0 +1,125 @@
+/*
+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 { getMandatoryNamedGroup } from "@mnaoumov/typescript-lib/reg-exp";
+import {
+  isNumber,
+  isString,
+  objectTypeGuard
+} from "@mnaoumov/typescript-lib/type-guards";
+const BULK_OPERATION_LOCK_FILE_NAME = "obsidian-bulk-operation.json";
+const BULK_OPERATION_LOCK_STALE_AFTER_IN_MILLISECONDS = 12e4;
+const OPERATION_TRAILER_KEY = "Obsidian-Bulk-Operation";
+const PLUGIN_TRAILER_KEY = "Obsidian-Plugin";
+const OPERATION_ID_PREFIX = "OP";
+const isBulkOperationLockImpl = objectTypeGuard({
+  heartbeatAt: isNumber,
+  host: isString,
+  operationId: isString,
+  pluginId: isString,
+  processId: isNumber,
+  processStartedAt: isNumber,
+  startedAt: isNumber
+});
+function buildBeforeOperationCommitSubject(operationId) {
+  return `chore: before ${operationId}`;
+}
+function buildOperationCommitMessage(params) {
+  const subject = params.isInterrupted ? `${params.operationId} interrupted` : `${params.operationId}: ${normalizeSummary(params.summary ?? "")}`;
+  const body = `Timestamp: ${params.timestamp.toISOString()}
+Changed-Files: ${String(params.changedFileCount)}
+${PLUGIN_TRAILER_KEY}: ${params.pluginId}
+${OPERATION_TRAILER_KEY}: ${params.operationId}`;
+  return { body, subject };
+}
+function formatOperationId(operationNumber) {
+  return `${OPERATION_ID_PREFIX}${String(operationNumber)}`;
+}
+function getNextOperationId(subjects) {
+  let maxOperationNumber = 0;
+  for (const subject of subjects) {
+    const operationNumber = parseOperationNumber(subject);
+    if (operationNumber !== null && operationNumber > maxOperationNumber) {
+      maxOperationNumber = operationNumber;
+    }
+  }
+  return formatOperationId(maxOperationNumber + 1);
+}
+function isBulkOperationLock(value) {
+  return isBulkOperationLockImpl(value);
+}
+function isBulkOperationLockStale(lock, context) {
+  if (context.now - lock.heartbeatAt >= BULK_OPERATION_LOCK_STALE_AFTER_IN_MILLISECONDS) {
+    return true;
+  }
+  if (lock.host !== context.host) {
+    return false;
+  }
+  const wasHeartbeatBeforeBoot = context.bootedAt !== null && lock.heartbeatAt < context.bootedAt;
+  return wasHeartbeatBeforeBoot || context.isProcessAlive(lock.processId) === false;
+}
+function parseBulkOperationCommit(params) {
+  const match = /^OP(?<operationNumber>\d+)(?<kind>:| interrupted$)/.exec(params.subject);
+  if (!match) {
+    return null;
+  }
+  return {
+    date: params.date,
+    isInterrupted: getMandatoryNamedGroup(match, "kind") !== ":",
+    operationId: formatOperationId(Number(getMandatoryNamedGroup(match, "operationNumber"))),
+    sha: params.sha,
+    subject: params.subject
+  };
+}
+function parseOperationNumber(subject) {
+  const match = /^(?:chore: before )?OP(?<operationNumber>\d+)(?::| interrupted$|$)/.exec(subject);
+  return match ? Number(getMandatoryNamedGroup(match, "operationNumber")) : null;
+}
+function normalizeSummary(summary) {
+  const normalized = summary.replaceAll(/\s+/g, " ").trim();
+  return normalized || "bulk operation";
+}
+export {
+  BULK_OPERATION_LOCK_FILE_NAME,
+  BULK_OPERATION_LOCK_STALE_AFTER_IN_MILLISECONDS,
+  OPERATION_TRAILER_KEY,
+  PLUGIN_TRAILER_KEY,
+  buildBeforeOperationCommitSubject,
+  buildOperationCommitMessage,
+  formatOperationId,
+  getNextOperationId,
+  isBulkOperationLock,
+  isBulkOperationLockStale,
+  parseBulkOperationCommit,
+  parseOperationNumber
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bulk-operation.ts"],"sourcesContent":["/**\n * @file\n *\n * The platform-neutral half of bulk-operation git commits: the lease-lock record, the `OP<n>` ids and the commit\n * messages that carry them.\n *\n * A bulk operation wrapped by `BulkOperationCommitComponent` lands in the vault's git repo as one commit whose\n * subject is `OP<n>: <summary>`, preceded (when the tree was dirty) by a `chore: before OP<n>` commit holding\n * whatever was pending, so `git revert` of the `OP<n>` commit undoes exactly that operation. Everything in this\n * module is pure, so it is shared by the desktop git layer and by the scheduled autocommit that reads the same lock.\n *\n * The lock record and the commit message trailers are a wire format between plugins built on different copies of\n * this library and the vault autocommit script: fields may be added, never renamed or reinterpreted.\n */\n\nimport { getMandatoryNamedGroup } from '@mnaoumov/typescript-lib/reg-exp';\nimport {\n  isNumber,\n  isString,\n  objectTypeGuard\n} from '@mnaoumov/typescript-lib/type-guards';\n\n/**\n * The name of the lease-lock file, created inside the repo's git directory so it is never committed or\n * synced.\n */\nexport const BULK_OPERATION_LOCK_FILE_NAME = 'obsidian-bulk-operation.json';\n\n/**\n * How long a lock may go without a heartbeat before it counts as stale.\n *\n * It errs long on purpose: holding a dead lock too long only makes an autocommit skip a tick, while declaring a\n * live one stale splits its operation across two commits.\n */\nexport const BULK_OPERATION_LOCK_STALE_AFTER_IN_MILLISECONDS = 120_000;\n\n/**\n * The trailer key naming the operation id in a bulk-operation commit body.\n */\nexport const OPERATION_TRAILER_KEY = 'Obsidian-Bulk-Operation';\n\n/**\n * The trailer key naming the plugin in a bulk-operation commit body.\n */\nexport const PLUGIN_TRAILER_KEY = 'Obsidian-Plugin';\n\nconst OPERATION_ID_PREFIX = 'OP';\n\nconst isBulkOperationLockImpl = objectTypeGuard<BulkOperationLock>({\n  heartbeatAt: isNumber,\n  host: isString,\n  operationId: isString,\n  pluginId: isString,\n  processId: isNumber,\n  processStartedAt: isNumber,\n  startedAt: isNumber\n});\n\n/**\n * Parameters for {@link buildOperationCommitMessage}.\n */\nexport interface BuildOperationCommitMessageParams {\n  /**\n   * The number of files the commit changes.\n   */\n  readonly changedFileCount: number;\n\n  /**\n   * Whether the operation was interrupted.\n   */\n  readonly isInterrupted?: boolean;\n\n  /**\n   * The operation id, such as `OP12`.\n   */\n  readonly operationId: string;\n\n  /**\n   * The id of the plugin that ran the operation.\n   */\n  readonly pluginId: string;\n\n  /**\n   * A one-line description of the operation. Ignored for an interrupted operation.\n   */\n  readonly summary?: string;\n\n  /**\n   * When the operation ran.\n   */\n  readonly timestamp: Date;\n}\n\n/**\n * A bulk-operation commit found in the repo history.\n */\nexport interface BulkOperationCommit {\n  /**\n   * The commit date, as an ISO 8601 string.\n   */\n  readonly date: string;\n\n  /**\n   * Whether the commit records an interrupted operation rather than a completed one.\n   */\n  readonly isInterrupted: boolean;\n\n  /**\n   * The operation id, such as `OP12`.\n   */\n  readonly operationId: string;\n\n  /**\n   * The full commit hash.\n   */\n  readonly sha: string;\n\n  /**\n   * The commit subject.\n   */\n  readonly subject: string;\n}\n\n/**\n * The lease-lock record stored in `.git/obsidian-bulk-operation.json` while a bulk operation runs.\n */\nexport interface BulkOperationLock {\n  /**\n   * When the lock was last refreshed by the operation's progress, as epoch milliseconds.\n   */\n  readonly heartbeatAt: number;\n\n  /**\n   * The host name of the machine running the operation.\n   */\n  readonly host: string;\n\n  /**\n   * The operation id, such as `OP12`.\n   */\n  readonly operationId: string;\n\n  /**\n   * The id of the plugin running the operation.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The id of the process running Obsidian. Only a fast path for an app crash; staleness never depends on it.\n   */\n  readonly processId: number;\n\n  /**\n   * When the process running Obsidian started, as epoch milliseconds, so a recycled process id is not mistaken for\n   * the original one.\n   */\n  readonly processStartedAt: number;\n\n  /**\n   * When the operation started, as epoch milliseconds.\n   */\n  readonly startedAt: number;\n}\n\n/**\n * The facts {@link isBulkOperationLockStale} weighs besides the heartbeat.\n */\nexport interface BulkOperationLockStalenessContext {\n  /**\n   * When this machine last booted, as epoch milliseconds, or `null` when unknown.\n   */\n  readonly bootedAt: null | number;\n\n  /**\n   * The host name of this machine.\n   */\n  readonly host: string;\n\n  /**\n   * Whether the process recorded in the lock is still running on this machine, or `null` when it cannot be told.\n   */\n  readonly isProcessAlive: (processId: number) => boolean | null;\n\n  /**\n   * The current time, as epoch milliseconds.\n   */\n  readonly now: number;\n}\n\n/**\n * The commit message of one bulk-operation commit.\n */\nexport interface OperationCommitMessage {\n  /**\n   * The commit body: the timestamp, the plugin and the counts, as git trailers.\n   */\n  readonly body: string;\n\n  /**\n   * The commit subject.\n   */\n  readonly subject: string;\n}\n\n/**\n * Parameters for {@link parseBulkOperationCommit}.\n */\nexport interface ParseBulkOperationCommitParams {\n  /**\n   * The commit date, as an ISO 8601 string.\n   */\n  readonly date: string;\n\n  /**\n   * The full commit hash.\n   */\n  readonly sha: string;\n\n  /**\n   * The commit subject.\n   */\n  readonly subject: string;\n}\n\n/**\n * Builds the subject of the commit that saves whatever was pending before an operation.\n *\n * @param operationId - The operation id, such as `OP12`.\n * @returns The commit subject.\n */\nexport function buildBeforeOperationCommitSubject(operationId: string): string {\n  return `chore: before ${operationId}`;\n}\n\n/**\n * Builds the message of the commit recording a bulk operation, or an interrupted one.\n *\n * @param params - The parameters.\n * @returns The commit subject and body.\n */\nexport function buildOperationCommitMessage(params: BuildOperationCommitMessageParams): OperationCommitMessage {\n  const subject = params.isInterrupted\n    ? `${params.operationId} interrupted`\n    : `${params.operationId}: ${normalizeSummary(params.summary ?? '')}`;\n  // Git trailers, one per line, so `git log --grep` and `git interpret-trailers` both read them.\n  const body = `Timestamp: ${params.timestamp.toISOString()}\\nChanged-Files: ${String(params.changedFileCount)}\\n`\n    + `${PLUGIN_TRAILER_KEY}: ${params.pluginId}\\n${OPERATION_TRAILER_KEY}: ${params.operationId}`;\n  return { body, subject };\n}\n\n/**\n * Formats an operation id from its number.\n *\n * @param operationNumber - The operation number.\n * @returns The operation id, such as `OP12`.\n */\nexport function formatOperationId(operationNumber: number): string {\n  return `${OPERATION_ID_PREFIX}${String(operationNumber)}`;\n}\n\n/**\n * Finds the next operation id from the subjects of the bulk-operation commits already in the history.\n *\n * @param subjects - Commit subjects; anything that is not a bulk-operation subject is ignored.\n * @returns `OP<n>` with n one past the highest number found, or `OP1` when there is none.\n */\nexport function getNextOperationId(subjects: readonly string[]): string {\n  let maxOperationNumber = 0;\n  for (const subject of subjects) {\n    const operationNumber = parseOperationNumber(subject);\n    if (operationNumber !== null && operationNumber > maxOperationNumber) {\n      maxOperationNumber = operationNumber;\n    }\n  }\n  return formatOperationId(maxOperationNumber + 1);\n}\n\n/**\n * Checks whether a value has the shape of a {@link BulkOperationLock}.\n *\n * @param value - The value read from the lock file.\n * @returns Whether it is a lock record.\n */\nexport function isBulkOperationLock(value: unknown): value is BulkOperationLock {\n  return isBulkOperationLockImpl(value);\n}\n\n/**\n * Decides whether a lease lock is stale, so whoever finds it may commit the leftovers and remove it.\n *\n * The heartbeat is the rule; the reboot and crashed-process checks are only fast paths that shorten the wait, and\n * neither can make a lock with a fresh heartbeat on another machine stale.\n *\n * @param lock - The lock record.\n * @param context - The facts about this machine.\n * @returns Whether the lock is stale.\n */\nexport function isBulkOperationLockStale(lock: BulkOperationLock, context: BulkOperationLockStalenessContext): boolean {\n  if (context.now - lock.heartbeatAt >= BULK_OPERATION_LOCK_STALE_AFTER_IN_MILLISECONDS) {\n    return true;\n  }\n\n  if (lock.host !== context.host) {\n    return false;\n  }\n\n  const wasHeartbeatBeforeBoot = context.bootedAt !== null && lock.heartbeatAt < context.bootedAt;\n  return wasHeartbeatBeforeBoot || context.isProcessAlive(lock.processId) === false;\n}\n\n/**\n * Parses a bulk-operation commit subject into the commit it describes, skipping the `chore: before` commits, which\n * are not operations.\n *\n * @param params - The commit's hash, date and subject.\n * @returns The bulk-operation commit, or `null` when the subject is not one.\n */\nexport function parseBulkOperationCommit(params: ParseBulkOperationCommitParams): BulkOperationCommit | null {\n  const match = /^OP(?<operationNumber>\\d+)(?<kind>:| interrupted$)/.exec(params.subject);\n  if (!match) {\n    return null;\n  }\n  return {\n    date: params.date,\n    isInterrupted: getMandatoryNamedGroup(match, 'kind') !== ':',\n    operationId: formatOperationId(Number(getMandatoryNamedGroup(match, 'operationNumber'))),\n    sha: params.sha,\n    subject: params.subject\n  };\n}\n\n/**\n * Parses the operation number out of a bulk-operation commit subject.\n *\n * Recognizes `OP<n>: <summary>`, `OP<n> interrupted` and `chore: before OP<n>`.\n *\n * @param subject - The commit subject.\n * @returns The operation number, or `null` when the subject is not a bulk-operation subject.\n */\nexport function parseOperationNumber(subject: string): null | number {\n  const match = /^(?:chore: before )?OP(?<operationNumber>\\d+)(?::| interrupted$|$)/.exec(subject);\n  return match ? Number(getMandatoryNamedGroup(match, 'operationNumber')) : null;\n}\n\nfunction normalizeSummary(summary: string): string {\n  const normalized = summary.replaceAll(/\\s+/g, ' ').trim();\n  return normalized || 'bulk operation';\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,SAAS,8BAA8B;AACvC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMA,MAAM,gCAAgC;AAQtC,MAAM,kDAAkD;AAKxD,MAAM,wBAAwB;AAK9B,MAAM,qBAAqB;AAElC,MAAM,sBAAsB;AAE5B,MAAM,0BAA0B,gBAAmC;AAAA,EACjE,aAAa;AAAA,EACb,MAAM;AAAA,EACN,aAAa;AAAA,EACb,UAAU;AAAA,EACV,WAAW;AAAA,EACX,kBAAkB;AAAA,EAClB,WAAW;AACb,CAAC;AA8KM,SAAS,kCAAkC,aAA6B;AAC7E,SAAO,iBAAiB,WAAW;AACrC;AAQO,SAAS,4BAA4B,QAAmE;AAC7G,QAAM,UAAU,OAAO,gBACnB,GAAG,OAAO,WAAW,iBACrB,GAAG,OAAO,WAAW,KAAK,iBAAiB,OAAO,WAAW,EAAE,CAAC;AAEpE,QAAM,OAAO,cAAc,OAAO,UAAU,YAAY,CAAC;AAAA,iBAAoB,OAAO,OAAO,gBAAgB,CAAC;AAAA,EACrG,kBAAkB,KAAK,OAAO,QAAQ;AAAA,EAAK,qBAAqB,KAAK,OAAO,WAAW;AAC9F,SAAO,EAAE,MAAM,QAAQ;AACzB;AAQO,SAAS,kBAAkB,iBAAiC;AACjE,SAAO,GAAG,mBAAmB,GAAG,OAAO,eAAe,CAAC;AACzD;AAQO,SAAS,mBAAmB,UAAqC;AACtE,MAAI,qBAAqB;AACzB,aAAW,WAAW,UAAU;AAC9B,UAAM,kBAAkB,qBAAqB,OAAO;AACpD,QAAI,oBAAoB,QAAQ,kBAAkB,oBAAoB;AACpE,2BAAqB;AAAA,IACvB;AAAA,EACF;AACA,SAAO,kBAAkB,qBAAqB,CAAC;AACjD;AAQO,SAAS,oBAAoB,OAA4C;AAC9E,SAAO,wBAAwB,KAAK;AACtC;AAYO,SAAS,yBAAyB,MAAyB,SAAqD;AACrH,MAAI,QAAQ,MAAM,KAAK,eAAe,iDAAiD;AACrF,WAAO;AAAA,EACT;AAEA,MAAI,KAAK,SAAS,QAAQ,MAAM;AAC9B,WAAO;AAAA,EACT;AAEA,QAAM,yBAAyB,QAAQ,aAAa,QAAQ,KAAK,cAAc,QAAQ;AACvF,SAAO,0BAA0B,QAAQ,eAAe,KAAK,SAAS,MAAM;AAC9E;AASO,SAAS,yBAAyB,QAAoE;AAC3G,QAAM,QAAQ,qDAAqD,KAAK,OAAO,OAAO;AACtF,MAAI,CAAC,OAAO;AACV,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,MAAM,OAAO;AAAA,IACb,eAAe,uBAAuB,OAAO,MAAM,MAAM;AAAA,IACzD,aAAa,kBAAkB,OAAO,uBAAuB,OAAO,iBAAiB,CAAC,CAAC;AAAA,IACvF,KAAK,OAAO;AAAA,IACZ,SAAS,OAAO;AAAA,EAClB;AACF;AAUO,SAAS,qBAAqB,SAAgC;AACnE,QAAM,QAAQ,qEAAqE,KAAK,OAAO;AAC/F,SAAO,QAAQ,OAAO,uBAAuB,OAAO,iBAAiB,CAAC,IAAI;AAC5E;AAEA,SAAS,iBAAiB,SAAyB;AACjD,QAAM,aAAa,QAAQ,WAAW,QAAQ,GAAG,EAAE,KAAK;AACxD,SAAO,cAAc;AACvB;","names":[]}

package/dist/lib/esm/command-handlers/index.d.mts

@@ -8,4 +8,5 @@ export * as 'folder-command-handler' from './folder-command-handler.mjs';
 export * as 'global-command-handler' from './global-command-handler.mjs';
 export * as 'open-demo-vault-command-handler' from './open-demo-vault-command-handler.mjs';
 export * as 'open-settings-command-handler' from './open-settings-command-handler.mjs';
+export * as 'undo-bulk-operation-command-handler' from './undo-bulk-operation-command-handler.mjs';
 export * as 'unlock-active-note-command-handler' from './unlock-active-note-command-handler.mjs';

package/dist/lib/esm/command-handlers/index.mjs

@@ -12,6 +12,7 @@ import * as folder_command_handler from "./folder-command-handler.mjs";
 import * as global_command_handler from "./global-command-handler.mjs";
 import * as open_demo_vault_command_handler from "./open-demo-vault-command-handler.mjs";
 import * as open_settings_command_handler from "./open-settings-command-handler.mjs";
+import * as undo_bulk_operation_command_handler from "./undo-bulk-operation-command-handler.mjs";
 import * as unlock_active_note_command_handler from "./unlock-active-note-command-handler.mjs";
 export {
   abstract_file_command_handler as "abstract-file-command-handler",
@@ -23,6 +24,7 @@ export {
   global_command_handler as "global-command-handler",
   open_demo_vault_command_handler as "open-demo-vault-command-handler",
   open_settings_command_handler as "open-settings-command-handler",
+  undo_bulk_operation_command_handler as "undo-bulk-operation-command-handler",
   unlock_active_note_command_handler as "unlock-active-note-command-handler"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvbW1hbmQtaGFuZGxlcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnYWJzdHJhY3QtZmlsZS1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vYWJzdHJhY3QtZmlsZS1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ2NvbW1hbmQtaGFuZGxlci1jb21wb25lbnQnIGZyb20gJy4vY29tbWFuZC1oYW5kbGVyLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnY29tbWFuZC1oYW5kbGVyJyBmcm9tICcuL2NvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnZWRpdG9yLWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9lZGl0b3ItY29tbWFuZC1oYW5kbGVyLnRzJztcbmV4cG9ydCAqIGFzICdmaWxlLWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9maWxlLWNvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnZm9sZGVyLWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9mb2xkZXItY29tbWFuZC1oYW5kbGVyLnRzJztcbmV4cG9ydCAqIGFzICdnbG9iYWwtY29tbWFuZC1oYW5kbGVyJyBmcm9tICcuL2dsb2JhbC1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ29wZW4tZGVtby12YXVsdC1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vb3Blbi1kZW1vLXZhdWx0LWNvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnb3Blbi1zZXR0aW5ncy1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vb3Blbi1zZXR0aW5ncy1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ3VubG9jay1hY3RpdmUtbm90ZS1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vdW5sb2NrLWFjdGl2ZS1ub3RlLWNvbW1hbmQtaGFuZGxlci50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVlBLG1DQUFxQztBQUNqRCxZQUFZQywrQkFBaUM7QUFDN0MsWUFBWUMscUJBQXVCO0FBQ25DLFlBQVlDLDRCQUE4QjtBQUMxQyxZQUFZQywwQkFBNEI7QUFDeEMsWUFBWUMsNEJBQThCO0FBQzFDLFlBQVlDLDRCQUE4QjtBQUMxQyxZQUFZQyxxQ0FBdUM7QUFDbkQsWUFBWUMsbUNBQXFDO0FBQ2pELFlBQVlDLHdDQUEwQzsiLAogICJuYW1lcyI6IFsiYWJzdHJhY3QtZmlsZS1jb21tYW5kLWhhbmRsZXIiLCAiY29tbWFuZC1oYW5kbGVyLWNvbXBvbmVudCIsICJjb21tYW5kLWhhbmRsZXIiLCAiZWRpdG9yLWNvbW1hbmQtaGFuZGxlciIsICJmaWxlLWNvbW1hbmQtaGFuZGxlciIsICJmb2xkZXItY29tbWFuZC1oYW5kbGVyIiwgImdsb2JhbC1jb21tYW5kLWhhbmRsZXIiLCAib3Blbi1kZW1vLXZhdWx0LWNvbW1hbmQtaGFuZGxlciIsICJvcGVuLXNldHRpbmdzLWNvbW1hbmQtaGFuZGxlciIsICJ1bmxvY2stYWN0aXZlLW5vdGUtY29tbWFuZC1oYW5kbGVyIl0KfQo=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/command-handlers/undo-bulk-operation-command-handler.d.mts

@@ -0,0 +1,51 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Handles the "Undo a bulk operation..." command.
+ */
+import type { BulkOperationCommitComponent } from '../components/bulk-operation-commit-component.mjs';
+import { GlobalCommandHandler } from './global-command-handler.mjs';
+/**
+ * Constructor parameters for {@link UndoBulkOperationCommandHandler}.
+ */
+export interface UndoBulkOperationCommandHandlerConstructorParams {
+    /**
+     * The component that commits the plugin's bulk operations.
+     */
+    readonly bulkOperationCommitComponent: BulkOperationCommitComponent;
+    /**
+     * Whether the plugin's opt-in setting for bulk-operation commits is on. The command is hidden while it is off.
+     */
+    readonly isEnabled: () => boolean;
+}
+/**
+ * A command handler that lists the plugin's bulk operations recorded in the vault repository and reverts the one
+ * the user picks. Available only on desktop, while the plugin's bulk-operation commits are enabled.
+ */
+export declare class UndoBulkOperationCommandHandler extends GlobalCommandHandler {
+    /**
+     * The component that commits the plugin's bulk operations.
+     */
+    protected readonly bulkOperationCommitComponent: BulkOperationCommitComponent;
+    /**
+     * Whether the plugin's opt-in setting for bulk-operation commits is on.
+     */
+    protected readonly isEnabled: () => boolean;
+    /**
+     * Creates a new instance.
+     *
+     * @param params - Constructor parameters.
+     */
+    constructor(params: UndoBulkOperationCommandHandlerConstructorParams);
+    /**
+     * Executes the command, letting the user pick a bulk operation to revert.
+     */
+    execute(): Promise<void>;
+    /**
+     * Checks whether the command can currently execute: on desktop, with bulk-operation commits enabled.
+     *
+     * @returns Whether the command can execute.
+     */
+    protected canExecute(): boolean;
+}

package/dist/lib/esm/command-handlers/undo-bulk-operation-command-handler.mjs

@@ -0,0 +1,76 @@
+/*
+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 { Platform } from "obsidian";
+import { GlobalCommandHandler } from "./global-command-handler.mjs";
+class UndoBulkOperationCommandHandler extends GlobalCommandHandler {
+  /**
+   * The component that commits the plugin's bulk operations.
+   */
+  bulkOperationCommitComponent;
+  /**
+   * Whether the plugin's opt-in setting for bulk-operation commits is on.
+   */
+  isEnabled;
+  /**
+   * Creates a new instance.
+   *
+   * @param params - Constructor parameters.
+   */
+  constructor(params) {
+    super({
+      icon: "undo-2",
+      id: "undo-bulk-operation",
+      name: "Undo a bulk operation..."
+    });
+    this.bulkOperationCommitComponent = params.bulkOperationCommitComponent;
+    this.isEnabled = params.isEnabled;
+  }
+  /**
+   * Executes the command, letting the user pick a bulk operation to revert.
+   */
+  async execute() {
+    await this.bulkOperationCommitComponent.undoBulkOperation();
+  }
+  /**
+   * Checks whether the command can currently execute: on desktop, with bulk-operation commits enabled.
+   *
+   * @returns Whether the command can execute.
+   */
+  canExecute() {
+    return Platform.isDesktopApp && this.isEnabled();
+  }
+}
+export {
+  UndoBulkOperationCommandHandler
+};
+//# sourceMappingURL=data:application/json;base64,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