obsidian-dev-utils 83.2.0 → 84.0.0

package/dist/lib/esm/obsidian/vault-transaction.d.mts

@@ -0,0 +1,146 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * A reversible, transactional log of vault mutations. Each mutation records how to undo itself;
+ * {@link VaultTransaction.rollback} reverses the completed steps in reverse order and
+ * {@link VaultTransaction.commit} finalizes them. It is built on the `*Safe` vault wrappers so it
+ * inherits their case-insensitive / retry / missing-file handling.
+ *
+ * A deletion is performed as a **soft-delete**: the resource is moved aside into a dot-prefixed
+ * staging folder (a folder moves its whole subtree in a single rename, so subtree rollback is cheap
+ * and faithful). Because Obsidian's vault file-tree and file watcher ignore any `.`-prefixed path,
+ * staged resources are **untracked** — they do not churn the metadata cache, flash in the file
+ * explorer, or get propagated by sync while the transaction is in flight. The flip side is that
+ * `vault.*` methods cannot see the staging area, so ALL staging I/O goes through
+ * {@link App.vault.adapter} (`mkdir`/`rename`/`exists`/`trashSystem`/`rmdir`).
+ * {@link VaultTransaction.commit} then trashes the staged resources for real; {@link VaultTransaction.rollback}
+ * moves them back.
+ */
+import type { App, TFile } from 'obsidian';
+import type { PathOrAbstractFile } from './file-system.mjs';
+/**
+ * Parameters for the {@link VaultTransaction} constructor.
+ */
+export interface VaultTransactionConstructorParams {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * Opens an ambient mutation-bypass scope covering the paths this transaction touches, so the
+     * transaction's own writes pass a `shouldBlockMutations` lock that the owning operation holds. It is
+     * called once when the transaction is constructed, and the returned {@link Disposable} is disposed
+     * when the transaction settles (on `commit`, `rollback`, or `await using` disposal) — so the bypass
+     * stays active through rollback, including auto-rollback, which a caller managing the scope itself
+     * could easily get wrong. Typically
+     * `() => resourceLockComponent.bypassBlockedMutations(lockedPathsOrFiles)`. Omit it for the common
+     * standalone case where the transaction operates on unlocked paths.
+     *
+     * @returns A {@link Disposable} that ends the bypass scope.
+     */
+    openMutationBypass?(this: void): Disposable;
+    /**
+     * The dot-prefixed folder that soft-deleted resources are moved into until the transaction is
+     * committed or rolled back. It must stay `.`-prefixed so Obsidian leaves the staged resources
+     * untracked.
+     *
+     * @default `'.obsidian-dev-utils-temp'`
+     */
+    readonly stagingFolderPath?: string;
+}
+/**
+ * A reversible log of vault mutations. Perform mutations through its methods, then call
+ * {@link VaultTransaction.commit} on success or {@link VaultTransaction.rollback} on failure. It is
+ * `await using`-friendly: if neither is called, disposal rolls back.
+ */
+export declare class VaultTransaction {
+    private readonly app;
+    private hasStagingFolder;
+    private mutationBypass;
+    private readonly stagedTrashPaths;
+    private readonly stagingFolderPath;
+    private state;
+    private readonly undoSteps;
+    /**
+     * Creates a new vault transaction.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: VaultTransactionConstructorParams);
+    /**
+     * 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.
+     */
+    commit(): Promise<void>;
+    /**
+     * 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}.
+     */
+    create(path: string, data: string): Promise<TFile>;
+    /**
+     * 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.
+     */
+    createFolder(path: string): Promise<void>;
+    /**
+     * 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.
+     */
+    modify(pathOrFile: PathOrAbstractFile, newContent: string): Promise<void>;
+    /**
+     * 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.
+     */
+    process(pathOrFile: PathOrAbstractFile, newContentProvider: (content: string) => string): Promise<void>;
+    /**
+     * 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.
+     */
+    rename(oldPathOrFile: PathOrAbstractFile, newPath: string): Promise<string>;
+    /**
+     * 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.
+     */
+    rollback(): Promise<void>;
+    /**
+     * Rolls back the transaction on disposal unless it was already committed or rolled back.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * 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.
+     */
+    trash(pathOrFile: PathOrAbstractFile): Promise<void>;
+    private assertNotCommitted;
+    private assertOpen;
+    private disposeMutationBypass;
+    private ensureStagingFolder;
+    private getAvailableStagedPath;
+    private hardDelete;
+    private pushUndo;
+    private removeStagingFolder;
+}

package/dist/lib/esm/obsidian/vault-transaction.mjs

@@ -0,0 +1,271 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { assertNonNullable } from "../type-guards.mjs";
+import {
+  getAbstractFileOrNull,
+  getPath
+} from "./file-system.mjs";
+import {
+  createFolderSafe,
+  process,
+  readSafe,
+  renameSafe
+} from "./vault.mjs";
+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 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 = getPath(this.app, pathOrFile);
+    const oldContent = await readSafe(this.app, path);
+    await process({
+      app: this.app,
+      newContentProvider: ({ content }) => newContentProvider(content),
+      pathOrFile: path,
+      resourceLockComponent: null
+    });
+    assertNonNullable(oldContent);
+    this.pushUndo(async () => {
+      await 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 = getPath(this.app, oldPathOrFile);
+    const actualNewPath = await renameSafe({ app: this.app, newPath, oldPathOrAbstractFile: oldPathOrFile });
+    this.pushUndo(async () => {
+      await 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 = 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 = 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);
+    }
+  }
+}
+export {
+  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": []
}


package/dist/lib/esm/obsidian/vault.d.mts

@@ -8,8 +8,8 @@ import type { App, ListedFiles } from 'obsidian';
 import { TAbstractFile, TFile, TFolder } from 'obsidian';
 import type { RetryOptions } from '../async.mjs';
 import type { ValueProvider } from '../value-provider.mjs';
-import type { EditorLockComponent } from './editor-lock.mjs';
 import type { PathOrAbstractFile, PathOrFile, PathOrFolder } from './file-system.mjs';
+import type { ResourceLockComponent } from './resource-lock.mjs';
 import { FileSystemType } from './file-system.mjs';
 /**
  * Arguments for {@link process}.
@@ -143,11 +143,11 @@ export interface IsChildParams {
  */
 export interface ProcessOptions extends RetryOptions {
     /**
-     * An editor-lock component used to lock the file's editor read-only for the duration of
+     * An resource-lock component used to lock the file's editor read-only for the duration of
      * processing. The lock is reference-counted, so it composes with any outer operation-level lock
      * on the same note.
      */
-    readonly editorLockComponent: EditorLockComponent | null;
+    readonly resourceLockComponent: null | ResourceLockComponent;
     /**
      * Whether to fail if the file is missing or deleted.
      *