obsidian-dev-utils 83.2.0 → 84.0.0

package/dist/lib/cjs/obsidian/resource-lock.d.cts

@@ -0,0 +1,227 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Path-scoped resource locking for vault files and folders, with three enforcement layers over one
+ * shared locked-path set:
+ *
+ * 1. **Editor read-only** — while a path is locked, every current and future {@link MarkdownView} of
+ *    that note (in any window, including popouts) is made read-only and shows a lock indicator in its
+ *    tab header, its view action bar, and the status bar; a note inside a `subtree`-locked folder is
+ *    covered too. Locks are reference-counted per locking plugin (the indicators' tooltip lists which
+ *    plugins hold a lock), so nested/concurrent operations are safe — the path is unlocked only when
+ *    the last lock is released.
+ * 2. **Vault-mutation blocking** (opt-in via `shouldBlockMutations`) — any edit/delete/rename/move/
+ *    create of a locked path through the `Vault`/`FileManager` API throws {@link ResourceLockedError},
+ *    unless the owning operation has opened a {@link ResourceLockComponent.bypassBlockedMutations} scope
+ *    over that path.
+ * 3. **External-change detection** — a vault/metadata event on a locked path that no bypass scope
+ *    covers is treated as an intruder (Sync / raw filesystem / another plugin) and aborts the owning
+ *    operation's {@link AbortController}.
+ *
+ * The acquirers return a {@link Disposable}, so the preferred call style is a `using` declaration that
+ * releases automatically at scope exit (including on throw):
+ *
+ * ```ts
+ * using _lock = lockResourceForPath(app, path, this.manifest.id);
+ * // ... long-running work (process, processFrontMatter, merge/split) ...
+ * // auto-unlocked at scope exit
+ * ```
+ *
+ * The explicit {@link unlockResourceForPath} pair remains available for non-`using` call sites.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { PathOrFile } from './file-system.cjs';
+import { ComponentEx } from './components/component-ex.cjs';
+/**
+ * Options for {@link ResourceLockComponent.lockForPath}.
+ */
+export interface ResourceLockComponentLockForPathOptions {
+    /**
+     * An optional {@link AbortController} associated with the lock. When the lock indicator is
+     * right-clicked and the user confirms an unlock (or {@link requestResourceUnlockForPath} is called for
+     * the path), this controller is aborted so the operation holding the lock can cancel itself and
+     * release the lock in its own cleanup.
+     */
+    readonly abortController?: AbortController;
+    /**
+     * The lock scope. `'subtree'` also locks every descendant of a folder path; `'file'` locks only the
+     * exact path. A `subtree` lock must be released via the returned {@link Disposable} (not the
+     * explicit {@link ResourceLockComponent.unlockForPath}).
+     *
+     * @default `'file'`
+     */
+    readonly mode?: ResourceLockMode;
+    /**
+     * When `true`, the lock also **blocks vault mutations** of the covered path(s): any attempt to edit,
+     * delete, rename, move, or (re)create the resource through the `Vault`/`FileManager` API throws a
+     * {@link ResourceLockedError}. Installed lazily on the first such lock and removed when the last one
+     * is released. When `false` (the default) the lock only makes the editor read-only — legacy behavior,
+     * so existing consumers that write to a note they hold an editor lock on are unaffected.
+     *
+     * @default `false`
+     */
+    readonly shouldBlockMutations?: boolean;
+}
+/**
+ * The scope of a lock.
+ *
+ * - `'file'` locks only the exact path.
+ * - `'subtree'` locks the path and every descendant under it (its whole folder subtree), so a file
+ *   inside a `subtree`-locked folder is treated as locked too.
+ */
+export type ResourceLockMode = 'file' | 'subtree';
+/**
+ * A per-plugin handle for path-scoped resource locking (editor read-only, optional vault-mutation
+ * blocking, and external-change detection — see the file overview). Add it as a child of your plugin
+ * (`this.addChild(new ResourceLockComponent(this.app))`) so that any locks it still holds are released
+ * automatically when the plugin unloads — a resource can never be left stuck locked because the plugin
+ * that locked it was disabled or reloaded mid-operation.
+ *
+ * Locks are reference-counted and attributed to this plugin, so the lock indicators' tooltip names it
+ * among the plugins currently holding a lock.
+ */
+export declare class ResourceLockComponent extends ComponentEx {
+    private readonly app;
+    private readonly pluginId;
+    /**
+     * Creates an resource-lock handle owned by a plugin.
+     *
+     * @param app - The Obsidian app instance.
+     * @param pluginId - The id of the owning plugin (e.g. its `manifest.id`). Locks are attributed to
+     * it for reference-counting and the indicators' "locked by" tooltip.
+     */
+    constructor(app: App, pluginId: string);
+    /**
+     * Opens an **ambient bypass scope**: while the returned {@link Disposable} is not disposed, this
+     * plugin's own mutations of the given paths (and, for a folder, its whole subtree) pass through the
+     * mutation blocker instead of throwing {@link ResourceLockedError}. Any mutation of a blocked path
+     * NOT covered by an active bypass scope is still rejected. Use it with a `using` declaration around
+     * the operation that legitimately mutates resources it has locked with
+     * {@link ResourceLockComponentLockForPathOptions.shouldBlockMutations}:
+     *
+     * ```ts
+     * using _bypass = component.bypassBlockedMutations([sourceFile, targetFile]);
+     * // ... the operation's own vault mutations of those paths are allowed ...
+     * // scope end: the paths are enforced again
+     * ```
+     *
+     * @param pathsOrFiles - The paths (or files/folders) whose mutation by this operation is sanctioned.
+     * @returns A {@link Disposable} that ends the bypass scope when disposed.
+     */
+    bypassBlockedMutations(pathsOrFiles: readonly PathOrFile[]): Disposable;
+    /**
+     * Checks whether the path is locked directly or lies under a `subtree`-locked ancestor folder.
+     *
+     * @param pathOrFile - The path or file to check.
+     * @returns `true` if the path is itself locked or is covered by a `subtree` lock on an ancestor.
+     */
+    isLockedByAncestorForPath(pathOrFile: PathOrFile): boolean;
+    /**
+     * Checks whether the note at the given path is currently locked by any plugin.
+     *
+     * @param pathOrFile - The path or file of the note to check.
+     * @returns `true` if the note has at least one active lock, `false` otherwise.
+     */
+    isLockedForPath(pathOrFile: PathOrFile): boolean;
+    /**
+     * Checks whether a vault mutation of the path is currently blocked by a `shouldBlockMutations` lock
+     * on the path itself or on a `subtree`-locked ancestor folder.
+     *
+     * @param pathOrFile - The path or file to check.
+     * @returns `true` if editing/deleting/renaming/moving/creating the path would throw a
+     * {@link ResourceLockedError}.
+     */
+    isMutationBlockedByAncestorForPath(pathOrFile: PathOrFile): boolean;
+    /**
+     * Locks the note at the given path on behalf of this plugin, making it read-only in every current
+     * and future {@link MarkdownView} until the lock is released. Reference-counted: balance each call
+     * with a dispose of the returned {@link Disposable} (ideally via `using`) or {@link unlockForPath}.
+     *
+     * @param pathOrFile - The path or file of the note to lock.
+     * @param options - Optional locking options. Pass an
+     * {@link ResourceLockComponentLockForPathOptions.abortController} to make the lock cancelable via the
+     * indicator's right-click "unlock" menu or {@link requestResourceUnlockForPath}.
+     * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+     */
+    lockForPath(pathOrFile: PathOrFile, options?: ResourceLockComponentLockForPathOptions): Disposable;
+    /**
+     * Releases every lock still held by this plugin when the component (and thus the plugin) unloads,
+     * so no note is left stuck read-only by an operation that never completed.
+     */
+    onunload(): void;
+    /**
+     * Releases one lock previously acquired for the note at the given path via {@link lockForPath}.
+     *
+     * @param pathOrFile - The path or file of the note to unlock.
+     */
+    unlockForPath(pathOrFile: PathOrFile): void;
+}
+/**
+ * Thrown by the vault-mutation blocker when a plugin tries to edit, delete, rename, move, or create a
+ * resource whose path is covered by a lock taken with
+ * {@link ResourceLockComponentLockForPathOptions.shouldBlockMutations}.
+ */
+export declare class ResourceLockedError extends Error {
+    /**
+     * The vault path whose mutation was blocked.
+     */
+    readonly path: string;
+    /**
+     * Creates a {@link ResourceLockedError}.
+     *
+     * @param path - The vault path whose mutation was blocked.
+     */
+    constructor(path: string);
+}
+/**
+ * Checks whether the note at the given path is currently locked.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to check.
+ * @returns `true` if the note has at least one active lock, `false` otherwise.
+ */
+export declare function isResourceLockedForPath(app: App, pathOrFile: PathOrFile): boolean;
+/**
+ * Locks the note at the given path, making it read-only in every current and future
+ * {@link MarkdownView} until the lock is released, and showing a lock indicator in the tab header,
+ * view action bar, and (while active) the status bar. The indicators' tooltip lists the plugins
+ * that currently hold a lock on the note.
+ *
+ * The lock is reference-counted per calling plugin: each call must be balanced by exactly one
+ * release (either disposing the returned {@link Disposable} — ideally via a `using` declaration — or
+ * a matching {@link unlockResourceForPath} call).
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to lock.
+ * @param pluginId - The id of the locking plugin (e.g. its `manifest.id`). The lock is attributed to
+ * it for reference-counting and the indicators' "locked by" tooltip.
+ * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+ */
+export declare function lockResourceForPath(app: App, pathOrFile: PathOrFile, pluginId: string): Disposable;
+/**
+ * Requests an unlock of the note at the given path by aborting every {@link AbortController} that was
+ * associated with a lock on it (via {@link ResourceLockComponent.lockForPath}'s
+ * {@link ResourceLockComponentLockForPathOptions.abortController}). The operations holding the lock
+ * observe the abort and release their own locks. A no-op when no abortable lock is registered for the
+ * path.
+ *
+ * This lets a consuming plugin wire its own "unlock active note" command without reaching into the
+ * lock manager directly.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to request an unlock for.
+ */
+export declare function requestResourceUnlockForPath(app: App, pathOrFile: PathOrFile): void;
+/**
+ * Releases one lock previously acquired for the note at the given path via {@link lockResourceForPath}.
+ *
+ * When the last lock is released the note becomes fully editable again and its lock indicators are
+ * removed. Calling this when the note is not locked is a no-op.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to unlock.
+ * @param pluginId - The id of the plugin that holds the lock (e.g. its `manifest.id`); one of its
+ * locks on the note is released.
+ */
+export declare function unlockResourceForPath(app: App, pathOrFile: PathOrFile, pluginId: string): void;

package/dist/lib/cjs/obsidian/vault-transaction.cjs

@@ -0,0 +1,371 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vault_transaction_exports = {};
+__export(vault_transaction_exports, {
+  VaultTransaction: () => VaultTransaction
+});
+module.exports = __toCommonJS(vault_transaction_exports);
+var import_type_guards = require('../type-guards.cjs');
+var import_file_system = require('./file-system.cjs');
+var import_vault = require('./vault.cjs');
+const DEFAULT_STAGING_FOLDER_PATH = ".obsidian-dev-utils-temp";
+class VaultTransaction {
+  app;
+  hasStagingFolder = false;
+  mutationBypass = null;
+  stagedTrashPaths = [];
+  stagingFolderPath;
+  state = "open";
+  undoSteps = [];
+  /**
+   * Creates a new vault transaction.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    this.app = params.app;
+    this.stagingFolderPath = params.stagingFolderPath ?? DEFAULT_STAGING_FOLDER_PATH;
+    this.mutationBypass = params.openMutationBypass?.() ?? null;
+  }
+  /**
+   * Commits the transaction: finalizes soft-deletes by trashing the staged resources for real and
+   * removes the staging folder. After this the transaction can no longer be mutated or rolled back.
+   *
+   * @returns A {@link Promise} that resolves when the commit completes.
+   */
+  async commit() {
+    this.assertOpen();
+    this.state = "committed";
+    const adapter = this.app.vault.adapter;
+    for (const stagedPath of this.stagedTrashPaths) {
+      const wasTrashedToSystem = await adapter.trashSystem(stagedPath);
+      if (!wasTrashedToSystem) {
+        await adapter.trashLocal(stagedPath);
+      }
+    }
+    await this.removeStagingFolder();
+    this.disposeMutationBypass();
+  }
+  /**
+   * Creates a file with the given content, recording its removal as the inverse.
+   *
+   * @param path - The path of the file to create.
+   * @param data - The content of the file.
+   * @returns A {@link Promise} resolving to the created {@link TFile}.
+   */
+  async create(path, data) {
+    this.assertOpen();
+    const file = await this.app.vault.create(path, data);
+    const createdPath = file.path;
+    this.pushUndo(async () => {
+      await this.hardDelete(createdPath);
+    });
+    return file;
+  }
+  /**
+   * Creates a folder (including missing ancestors), recording its removal as the inverse. A no-op if
+   * the folder already exists.
+   *
+   * @param path - The path of the folder to create.
+   * @returns A {@link Promise} that resolves when the folder exists.
+   */
+  async createFolder(path) {
+    this.assertOpen();
+    const wasCreated = await (0, import_vault.createFolderSafe)(this.app, path);
+    if (wasCreated) {
+      this.pushUndo(async () => {
+        await this.hardDelete(path);
+      });
+    }
+  }
+  /**
+   * Replaces the content of a file, capturing the old content so it can be restored on rollback.
+   *
+   * @param pathOrFile - The path or file to modify.
+   * @param newContent - The new content.
+   * @returns A {@link Promise} that resolves when the file is modified.
+   */
+  async modify(pathOrFile, newContent) {
+    await this.process(pathOrFile, () => newContent);
+  }
+  /**
+   * Transforms the content of a file, capturing the old content so it can be restored on rollback.
+   *
+   * @param pathOrFile - The path or file to process.
+   * @param newContentProvider - Maps the current content to the new content.
+   * @returns A {@link Promise} that resolves when the file is processed.
+   */
+  async process(pathOrFile, newContentProvider) {
+    this.assertOpen();
+    const path = (0, import_file_system.getPath)(this.app, pathOrFile);
+    const oldContent = await (0, import_vault.readSafe)(this.app, path);
+    await (0, import_vault.process)({
+      app: this.app,
+      newContentProvider: ({ content }) => newContentProvider(content),
+      pathOrFile: path,
+      resourceLockComponent: null
+    });
+    (0, import_type_guards.assertNonNullable)(oldContent);
+    this.pushUndo(async () => {
+      await (0, import_vault.process)({
+        app: this.app,
+        newContentProvider: oldContent,
+        pathOrFile: path,
+        resourceLockComponent: null
+      });
+    });
+  }
+  /**
+   * Renames or moves a resource, recording the reverse rename as the inverse.
+   *
+   * @param oldPathOrFile - The resource to rename.
+   * @param newPath - The desired new path (an available path is chosen if it is taken).
+   * @returns A {@link Promise} resolving to the actual new path.
+   */
+  async rename(oldPathOrFile, newPath) {
+    this.assertOpen();
+    const oldPath = (0, import_file_system.getPath)(this.app, oldPathOrFile);
+    const actualNewPath = await (0, import_vault.renameSafe)({ app: this.app, newPath, oldPathOrAbstractFile: oldPathOrFile });
+    this.pushUndo(async () => {
+      await (0, import_vault.renameSafe)({ app: this.app, newPath: oldPath, oldPathOrAbstractFile: actualNewPath });
+    });
+    return actualNewPath;
+  }
+  /**
+   * Rolls back the transaction: undoes the completed steps in reverse order and removes the staging
+   * folder. Idempotent.
+   *
+   * @returns A {@link Promise} that resolves when the rollback completes.
+   */
+  async rollback() {
+    if (this.state === "rolledBack") {
+      return;
+    }
+    this.assertNotCommitted();
+    this.state = "rolledBack";
+    for (const step of [...this.undoSteps].reverse()) {
+      await step.undo();
+    }
+    await this.removeStagingFolder();
+    this.disposeMutationBypass();
+  }
+  /**
+   * Rolls back the transaction on disposal unless it was already committed or rolled back.
+   */
+  async [Symbol.asyncDispose]() {
+    if (this.state === "open") {
+      await this.rollback();
+    }
+  }
+  /**
+   * Soft-deletes a resource by moving it into the staging folder, recording the move-back as the
+   * inverse. The real trash happens on {@link VaultTransaction.commit}. A no-op if the resource does
+   * not exist.
+   *
+   * @param pathOrFile - The path or resource to trash.
+   * @returns A {@link Promise} that resolves when the resource has been staged.
+   */
+  async trash(pathOrFile) {
+    this.assertOpen();
+    const file = (0, import_file_system.getAbstractFileOrNull)({ app: this.app, pathOrFile });
+    if (!file) {
+      return;
+    }
+    const originalPath = file.path;
+    await this.ensureStagingFolder();
+    const stagedPath = await this.getAvailableStagedPath(file.name);
+    const adapter = this.app.vault.adapter;
+    await adapter.rename(originalPath, stagedPath);
+    this.stagedTrashPaths.push(stagedPath);
+    this.pushUndo(async () => {
+      if (await adapter.exists(stagedPath)) {
+        await adapter.rename(stagedPath, originalPath);
+      }
+    });
+  }
+  assertNotCommitted() {
+    if (this.state === "committed") {
+      throw new Error("Cannot roll back a committed transaction.");
+    }
+  }
+  assertOpen() {
+    if (this.state !== "open") {
+      throw new Error(`Cannot mutate a ${this.state} transaction.`);
+    }
+  }
+  disposeMutationBypass() {
+    this.mutationBypass?.[Symbol.dispose]();
+    this.mutationBypass = null;
+  }
+  async ensureStagingFolder() {
+    if (this.hasStagingFolder) {
+      return;
+    }
+    const adapter = this.app.vault.adapter;
+    if (!await adapter.exists(this.stagingFolderPath)) {
+      await adapter.mkdir(this.stagingFolderPath);
+    }
+    this.hasStagingFolder = true;
+  }
+  async getAvailableStagedPath(name) {
+    const adapter = this.app.vault.adapter;
+    const dotIndex = name.lastIndexOf(".");
+    const hasExtension = dotIndex > 0;
+    const baseName = hasExtension ? name.slice(0, dotIndex) : name;
+    const extension = hasExtension ? name.slice(dotIndex) : "";
+    let candidate = `${this.stagingFolderPath}/${name}`;
+    let counter = 1;
+    while (await adapter.exists(candidate)) {
+      candidate = `${this.stagingFolderPath}/${baseName} ${counter.toString()}${extension}`;
+      counter++;
+    }
+    return candidate;
+  }
+  async hardDelete(path) {
+    const file = (0, import_file_system.getAbstractFileOrNull)({ app: this.app, pathOrFile: path });
+    if (file) {
+      await this.app.vault.delete(file, true);
+    }
+  }
+  pushUndo(undo) {
+    this.undoSteps.push({ undo });
+  }
+  async removeStagingFolder() {
+    if (!this.hasStagingFolder) {
+      return;
+    }
+    this.hasStagingFolder = false;
+    const adapter = this.app.vault.adapter;
+    if (await adapter.exists(this.stagingFolderPath)) {
+      await adapter.rmdir(this.stagingFolderPath, true);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VaultTransaction
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/vault-transaction.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A reversible, transactional log of vault mutations. Each mutation records how to undo itself;\n * {@link VaultTransaction.rollback} reverses the completed steps in reverse order and\n * {@link VaultTransaction.commit} finalizes them. It is built on the `*Safe` vault wrappers so it\n * inherits their case-insensitive / retry / missing-file handling.\n *\n * A deletion is performed as a **soft-delete**: the resource is moved aside into a dot-prefixed\n * staging folder (a folder moves its whole subtree in a single rename, so subtree rollback is cheap\n * and faithful). Because Obsidian's vault file-tree and file watcher ignore any `.`-prefixed path,\n * staged resources are **untracked** \u2014 they do not churn the metadata cache, flash in the file\n * explorer, or get propagated by sync while the transaction is in flight. The flip side is that\n * `vault.*` methods cannot see the staging area, so ALL staging I/O goes through\n * {@link App.vault.adapter} (`mkdir`/`rename`/`exists`/`trashSystem`/`rmdir`).\n * {@link VaultTransaction.commit} then trashes the staged resources for real; {@link VaultTransaction.rollback}\n * moves them back.\n */\n\nimport type {\n  App,\n  TFile\n} from 'obsidian';\n\nimport type { PathOrAbstractFile } from './file-system.ts';\n\nimport { assertNonNullable } from '../type-guards.ts';\nimport {\n  getAbstractFileOrNull,\n  getPath\n} from './file-system.ts';\nimport {\n  createFolderSafe,\n  process,\n  readSafe,\n  renameSafe\n} from './vault.ts';\n\nconst DEFAULT_STAGING_FOLDER_PATH = '.obsidian-dev-utils-temp';\n\n/**\n * Parameters for the {@link VaultTransaction} constructor.\n */\nexport interface VaultTransactionConstructorParams {\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * Opens an ambient mutation-bypass scope covering the paths this transaction touches, so the\n   * transaction's own writes pass a `shouldBlockMutations` lock that the owning operation holds. It is\n   * called once when the transaction is constructed, and the returned {@link Disposable} is disposed\n   * when the transaction settles (on `commit`, `rollback`, or `await using` disposal) \u2014 so the bypass\n   * stays active through rollback, including auto-rollback, which a caller managing the scope itself\n   * could easily get wrong. Typically\n   * `() => resourceLockComponent.bypassBlockedMutations(lockedPathsOrFiles)`. Omit it for the common\n   * standalone case where the transaction operates on unlocked paths.\n   *\n   * @returns A {@link Disposable} that ends the bypass scope.\n   */\n  openMutationBypass?(this: void): Disposable;\n\n  /**\n   * The dot-prefixed folder that soft-deleted resources are moved into until the transaction is\n   * committed or rolled back. It must stay `.`-prefixed so Obsidian leaves the staged resources\n   * untracked.\n   *\n   * @default `'.obsidian-dev-utils-temp'`\n   */\n  readonly stagingFolderPath?: string;\n}\n\ntype TransactionState = 'committed' | 'open' | 'rolledBack';\n\ninterface UndoStep {\n  undo(this: void): Promise<void>;\n}\n\n/**\n * A reversible log of vault mutations. Perform mutations through its methods, then call\n * {@link VaultTransaction.commit} on success or {@link VaultTransaction.rollback} on failure. It is\n * `await using`-friendly: if neither is called, disposal rolls back.\n */\nexport class VaultTransaction {\n  private readonly app: App;\n  private hasStagingFolder = false;\n  private mutationBypass: Disposable | null = null;\n  private readonly stagedTrashPaths: string[] = [];\n  private readonly stagingFolderPath: string;\n  private state: TransactionState = 'open';\n  private readonly undoSteps: UndoStep[] = [];\n\n  /**\n   * Creates a new vault transaction.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: VaultTransactionConstructorParams) {\n    this.app = params.app;\n    this.stagingFolderPath = params.stagingFolderPath ?? DEFAULT_STAGING_FOLDER_PATH;\n    this.mutationBypass = params.openMutationBypass?.() ?? null;\n  }\n\n  /**\n   * Commits the transaction: finalizes soft-deletes by trashing the staged resources for real and\n   * removes the staging folder. After this the transaction can no longer be mutated or rolled back.\n   *\n   * @returns A {@link Promise} that resolves when the commit completes.\n   */\n  public async commit(): Promise<void> {\n    this.assertOpen();\n    this.state = 'committed';\n    const adapter = this.app.vault.adapter;\n    for (const stagedPath of this.stagedTrashPaths) {\n      const wasTrashedToSystem = await adapter.trashSystem(stagedPath);\n      if (!wasTrashedToSystem) {\n        await adapter.trashLocal(stagedPath);\n      }\n    }\n    await this.removeStagingFolder();\n    this.disposeMutationBypass();\n  }\n\n  /**\n   * Creates a file with the given content, recording its removal as the inverse.\n   *\n   * @param path - The path of the file to create.\n   * @param data - The content of the file.\n   * @returns A {@link Promise} resolving to the created {@link TFile}.\n   */\n  public async create(path: string, data: string): Promise<TFile> {\n    this.assertOpen();\n    const file = await this.app.vault.create(path, data);\n    const createdPath = file.path;\n    this.pushUndo(async () => {\n      await this.hardDelete(createdPath);\n    });\n    return file;\n  }\n\n  /**\n   * Creates a folder (including missing ancestors), recording its removal as the inverse. A no-op if\n   * the folder already exists.\n   *\n   * @param path - The path of the folder to create.\n   * @returns A {@link Promise} that resolves when the folder exists.\n   */\n  public async createFolder(path: string): Promise<void> {\n    this.assertOpen();\n    const wasCreated = await createFolderSafe(this.app, path);\n    if (wasCreated) {\n      this.pushUndo(async () => {\n        await this.hardDelete(path);\n      });\n    }\n  }\n\n  /**\n   * Replaces the content of a file, capturing the old content so it can be restored on rollback.\n   *\n   * @param pathOrFile - The path or file to modify.\n   * @param newContent - The new content.\n   * @returns A {@link Promise} that resolves when the file is modified.\n   */\n  public async modify(pathOrFile: PathOrAbstractFile, newContent: string): Promise<void> {\n    await this.process(pathOrFile, () => newContent);\n  }\n\n  /**\n   * Transforms the content of a file, capturing the old content so it can be restored on rollback.\n   *\n   * @param pathOrFile - The path or file to process.\n   * @param newContentProvider - Maps the current content to the new content.\n   * @returns A {@link Promise} that resolves when the file is processed.\n   */\n  public async process(pathOrFile: PathOrAbstractFile, newContentProvider: (content: string) => string): Promise<void> {\n    this.assertOpen();\n    const path = getPath(this.app, pathOrFile);\n    const oldContent = await readSafe(this.app, path);\n    await process({\n      app: this.app,\n      newContentProvider: ({ content }) => newContentProvider(content),\n      pathOrFile: path,\n      resourceLockComponent: null\n    });\n    // Reaching this line means `process` succeeded. A missing file would have thrown above (its\n    // `shouldFailOnMissingFile` default), so the pre-image was captured and can be restored on rollback.\n    assertNonNullable(oldContent);\n    this.pushUndo(async () => {\n      await process({\n        app: this.app,\n        newContentProvider: oldContent,\n        pathOrFile: path,\n        resourceLockComponent: null\n      });\n    });\n  }\n\n  /**\n   * Renames or moves a resource, recording the reverse rename as the inverse.\n   *\n   * @param oldPathOrFile - The resource to rename.\n   * @param newPath - The desired new path (an available path is chosen if it is taken).\n   * @returns A {@link Promise} resolving to the actual new path.\n   */\n  public async rename(oldPathOrFile: PathOrAbstractFile, newPath: string): Promise<string> {\n    this.assertOpen();\n    const oldPath = getPath(this.app, oldPathOrFile);\n    const actualNewPath = await renameSafe({ app: this.app, newPath, oldPathOrAbstractFile: oldPathOrFile });\n    this.pushUndo(async () => {\n      await renameSafe({ app: this.app, newPath: oldPath, oldPathOrAbstractFile: actualNewPath });\n    });\n    return actualNewPath;\n  }\n\n  /**\n   * Rolls back the transaction: undoes the completed steps in reverse order and removes the staging\n   * folder. Idempotent.\n   *\n   * @returns A {@link Promise} that resolves when the rollback completes.\n   */\n  public async rollback(): Promise<void> {\n    if (this.state === 'rolledBack') {\n      return;\n    }\n    this.assertNotCommitted();\n    this.state = 'rolledBack';\n    for (const step of [...this.undoSteps].reverse()) {\n      await step.undo();\n    }\n    await this.removeStagingFolder();\n    this.disposeMutationBypass();\n  }\n\n  /**\n   * Rolls back the transaction on disposal unless it was already committed or rolled back.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (this.state === 'open') {\n      await this.rollback();\n    }\n  }\n\n  /**\n   * Soft-deletes a resource by moving it into the staging folder, recording the move-back as the\n   * inverse. The real trash happens on {@link VaultTransaction.commit}. A no-op if the resource does\n   * not exist.\n   *\n   * @param pathOrFile - The path or resource to trash.\n   * @returns A {@link Promise} that resolves when the resource has been staged.\n   */\n  public async trash(pathOrFile: PathOrAbstractFile): Promise<void> {\n    this.assertOpen();\n    const file = getAbstractFileOrNull({ app: this.app, pathOrFile });\n    if (!file) {\n      return;\n    }\n    const originalPath = file.path;\n    await this.ensureStagingFolder();\n    const stagedPath = await this.getAvailableStagedPath(file.name);\n    const adapter = this.app.vault.adapter;\n    // Move through the adapter, not `vault.rename`: the staging folder is dot-prefixed and therefore\n    // Untracked, so a `vault.*` move cannot target it (nor should it rewrite links to a soft-delete).\n    await adapter.rename(originalPath, stagedPath);\n    this.stagedTrashPaths.push(stagedPath);\n    this.pushUndo(async () => {\n      if (await adapter.exists(stagedPath)) {\n        await adapter.rename(stagedPath, originalPath);\n      }\n    });\n  }\n\n  private assertNotCommitted(): void {\n    if (this.state === 'committed') {\n      throw new Error('Cannot roll back a committed transaction.');\n    }\n  }\n\n  private assertOpen(): void {\n    if (this.state !== 'open') {\n      throw new Error(`Cannot mutate a ${this.state} transaction.`);\n    }\n  }\n\n  private disposeMutationBypass(): void {\n    this.mutationBypass?.[Symbol.dispose]();\n    this.mutationBypass = null;\n  }\n\n  private async ensureStagingFolder(): Promise<void> {\n    if (this.hasStagingFolder) {\n      return;\n    }\n    const adapter = this.app.vault.adapter;\n    if (!await adapter.exists(this.stagingFolderPath)) {\n      await adapter.mkdir(this.stagingFolderPath);\n    }\n    this.hasStagingFolder = true;\n  }\n\n  private async getAvailableStagedPath(name: string): Promise<string> {\n    const adapter = this.app.vault.adapter;\n    const dotIndex = name.lastIndexOf('.');\n    const hasExtension = dotIndex > 0;\n    const baseName = hasExtension ? name.slice(0, dotIndex) : name;\n    const extension = hasExtension ? name.slice(dotIndex) : '';\n    let candidate = `${this.stagingFolderPath}/${name}`;\n    let counter = 1;\n    while (await adapter.exists(candidate)) {\n      candidate = `${this.stagingFolderPath}/${baseName} ${counter.toString()}${extension}`;\n      counter++;\n    }\n    return candidate;\n  }\n\n  private async hardDelete(path: string): Promise<void> {\n    const file = getAbstractFileOrNull({ app: this.app, pathOrFile: path });\n    if (file) {\n      // eslint-disable-next-line obsidianmd/prefer-file-manager-trash-file -- Undoing a transaction-local create must vanish it entirely, not land it in the user's trash.\n      await this.app.vault.delete(file, true);\n    }\n  }\n\n  private pushUndo(undo: () => Promise<void>): void {\n    this.undoSteps.push({ undo });\n  }\n\n  private async removeStagingFolder(): Promise<void> {\n    if (!this.hasStagingFolder) {\n      return;\n    }\n    this.hasStagingFolder = false;\n    const adapter = this.app.vault.adapter;\n    if (await adapter.exists(this.stagingFolderPath)) {\n      await adapter.rmdir(this.stagingFolderPath, true);\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": []
}
