@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/vault-delete.d.cts

@@ -0,0 +1,82 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * This module provides deletion utilities that require metadata cache access.
+ */
+import type { App, TAbstractFile, TFile } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { PluginNoticeComponent } from './components/plugin-notice-component.cjs';
+import type { PathOrAbstractFile } from './file-system.cjs';
+/**
+ * The result of {@link deleteIfNotUsed}.
+ */
+export declare enum DeleteIfNotUsedResult {
+    /**
+     * The file/folder was deleted.
+     */
+    Deleted = "deleted",
+    /**
+     * The file/folder was not deleted.
+     */
+    NotDeleted = "not-deleted",
+    /**
+     * The file was still used, and {@link DeleteIfNotUsedParams.rescueStillUsedFile} moved it out of the way
+     * instead of it being deleted or left where it was.
+     */
+    Rescued = "rescued"
+}
+/**
+ * Parameters passed to {@link DeleteIfNotUsedParams.rescueStillUsedFile}.
+ */
+export interface RescueStillUsedFileParams {
+    /**
+     * The file that is about to be kept because other notes still reference it.
+     */
+    readonly file: TFile;
+    /**
+     * The paths of the notes that still reference the file once everything being deleted alongside it is
+     * gone. Never empty.
+     */
+    readonly survivingNotePaths: readonly string[];
+}
+interface DeleteIfNotUsedParams {
+    readonly app: App;
+    readonly deleteAbstractFile?: (file: TAbstractFile) => Promise<void>;
+    readonly deletedNotePath?: string;
+    readonly deletedNotePaths?: readonly string[];
+    readonly pathOrFile: PathOrAbstractFile;
+    readonly pluginNoticeComponent?: PluginNoticeComponent;
+    readonly rescueStillUsedFile?: (params: RescueStillUsedFileParams) => Promise<boolean>;
+    readonly shouldDeleteEmptyFolders?: boolean;
+    readonly shouldProtectIfStillUsed?: (file: TFile) => boolean;
+}
+/**
+ * Deletes an abstract file safely from the vault, but only if it is not referenced by other notes.
+ *
+ * Backlinks originating from {@link DeleteIfNotUsedParams.deletedNotePath} and
+ * {@link DeleteIfNotUsedParams.deletedNotePaths} are discounted before deciding whether a file is still
+ * used — a note that is itself going away cannot keep an attachment alive. Deleting a single note needs
+ * only the former; deleting a folder needs the latter, because every note inside it disappears at once.
+ *
+ * {@link DeleteIfNotUsedParams.shouldProtectIfStillUsed} narrows which files that protection covers; a file
+ * it rejects is deleted no matter how many notes link to it. Deleting a whole folder of notes uses this to
+ * exempt the notes themselves — leaving a dangling link behind is what Obsidian normally does, so keeping
+ * every linked-to note would make folder deletion impossible. By default every still-used file is kept.
+ *
+ * A kept file is stranded: it survives in a folder whose owning note is gone, while the note still
+ * referencing it lives elsewhere. {@link DeleteIfNotUsedParams.rescueStillUsedFile} is the seam that lets
+ * the caller relocate it instead, since where it belongs is the caller's attachment-path policy, not this
+ * function's. Without that callback the file is simply kept, exactly as before.
+ *
+ * The actual removal goes through {@link DeleteIfNotUsedParams.deleteAbstractFile} when supplied,
+ * otherwise through {@link trashSafe}. A caller that intercepted a specific deletion primitive passes its
+ * unpatched original here, so the user's chosen semantics (permanent delete vs trash) survive the detour.
+ *
+ * @param params - The parameters for the function.
+ * @returns A {@link Promise} that resolves to {@link DeleteIfNotUsedResult.Deleted} if the abstract file
+ * was deleted, {@link DeleteIfNotUsedResult.Rescued} if it was moved away by
+ * {@link DeleteIfNotUsedParams.rescueStillUsedFile}, or {@link DeleteIfNotUsedResult.NotDeleted} if it was
+ * kept where it was.
+ */
+export declare function deleteIfNotUsed(params: DeleteIfNotUsedParams): Promise<DeleteIfNotUsedResult>;
+export {};

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

@@ -0,0 +1,412 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@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.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    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_disposable = require('@mnaoumov/typescript-lib/disposable');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_editor = require('./editor.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 {
+  /**
+   * The Obsidian application instance the transaction mutates.
+   */
+  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();
+  }
+  /**
+   * Copies a file or folder, recording the removal of the copy as the inverse. A folder is copied with
+   * its whole subtree, so the single recorded removal undoes the whole tree. Unlike
+   * {@link VaultTransaction.create}, the content is copied byte for byte, so a binary resource
+   * round-trips faithfully.
+   *
+   * Parent folders that had to be created for the destination are NOT undone individually, matching
+   * {@link VaultTransaction.create} and {@link VaultTransaction.rename}.
+   *
+   * @param oldPathOrFile - The path, file or folder to copy.
+   * @param newPath - The desired new path (an available path is chosen if it is taken).
+   * @returns A {@link Promise} resolving to the actual path of the copy.
+   */
+  async copy(oldPathOrFile, newPath) {
+    this.assertOpen();
+    const oldPath = (0, import_file_system.getPath)(this.app, oldPathOrFile);
+    const actualNewPath = await (0, import_vault.copySafe)({ app: this.app, newPath, oldPathOrFile });
+    if (actualNewPath !== oldPath) {
+      this.pushUndo(async () => {
+        await this.hardDelete(actualNewPath);
+      });
+    }
+    return actualNewPath;
+  }
+  /**
+   * 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 result = await (0, import_vault.createFolderSafe)(this.app, path);
+    if (result === import_vault.CreateFolderSafeResult.Created) {
+      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,
+      pluginNoticeComponent: null,
+      resourceLockComponent: null
+    });
+    (0, import_type_guards.assertNonNullable)(oldContent);
+    this.pushUndo(async () => {
+      await (0, import_vault.process)({
+        app: this.app,
+        newContentProvider: oldContent,
+        pathOrFile: path,
+        pluginNoticeComponent: null,
+        resourceLockComponent: null
+      });
+      (0, import_editor.syncOpenEditorBuffersForPath)(this.app, path, oldContent);
+    });
+  }
+  /**
+   * 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() {
+    if (this.mutationBypass) {
+      (0, import_disposable.dispose)(this.mutationBypass);
+    }
+    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/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 { dispose } from '@mnaoumov/typescript-lib/disposable';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nimport type { PathOrAbstractFile } from './file-system.ts';\n\nimport { syncOpenEditorBuffersForPath } from './editor.ts';\nimport {\n  getAbstractFileOrNull,\n  getPath\n} from './file-system.ts';\nimport {\n  copySafe,\n  createFolderSafe,\n  CreateFolderSafeResult,\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  readonly openMutationBypass?: () => 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: () => 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  /**\n   * The Obsidian application instance the transaction mutates.\n   */\n  protected 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   * Copies a file or folder, recording the removal of the copy as the inverse. A folder is copied with\n   * its whole subtree, so the single recorded removal undoes the whole tree. Unlike\n   * {@link VaultTransaction.create}, the content is copied byte for byte, so a binary resource\n   * round-trips faithfully.\n   *\n   * Parent folders that had to be created for the destination are NOT undone individually, matching\n   * {@link VaultTransaction.create} and {@link VaultTransaction.rename}.\n   *\n   * @param oldPathOrFile - The path, file or folder to copy.\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 path of the copy.\n   */\n  public async copy(oldPathOrFile: PathOrAbstractFile, newPath: string): Promise<string> {\n    this.assertOpen();\n    const oldPath = getPath(this.app, oldPathOrFile);\n    const actualNewPath = await copySafe({ app: this.app, newPath, oldPathOrFile });\n    // When source and destination are identical, `copySafe` returns the source path and copies nothing.\n    // Recording an undo here would make `rollback` delete the caller's ORIGINAL resource.\n    if (actualNewPath !== oldPath) {\n      this.pushUndo(async () => {\n        await this.hardDelete(actualNewPath);\n      });\n    }\n    return actualNewPath;\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 result = await createFolderSafe(this.app, path);\n    if (result === CreateFolderSafeResult.Created) {\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      pluginNoticeComponent: null,\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        pluginNoticeComponent: null,\n        resourceLockComponent: null\n      });\n      // A consumer may have edited this note through the editor, leaving a dirty buffer.\n      // Its pending autosave could re-write that stale buffer over the disk restore above and clobber it.\n      // Resetting the open editor's buffer to the restored content keeps its next save a no-op.\n      // Only the view still showing this path is touched.\n      // VaultTransaction already flushes via `saveNote`, so this reset is belt-and-suspenders.\n      syncOpenEditorBuffersForPath(this.app, path, oldContent);\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    if (this.mutationBypass) {\n      dispose(this.mutationBypass);\n    }\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": []
}
