obsidian-dev-utils 3.21.0 → 3.23.0

package/dist/lib/obsidian/RenameDeleteHandler.cjs

@@ -30,11 +30,11 @@ __export(RenameDeleteHandler_exports, {
 module.exports = __toCommonJS(RenameDeleteHandler_exports);
 var import_obsidian = require('obsidian');
 var import_implementations = require('obsidian-typings/implementations');
-var import_Async = require('../Async.cjs');
 var import_Object = require('../Object.cjs');
 var import_Path = require('../Path.cjs');
 var import_App = require('./App.cjs');
 var import_AttachmentPath = require('./AttachmentPath.cjs');
+var import_ChainedPromise = require('./ChainedPromise.cjs');
 var import_Link = require('./Link.cjs');
 var import_MetadataCache = require('./MetadataCache.cjs');
 var import_TAbstractFile = require('./TAbstractFile.cjs');
@@ -60,13 +60,12 @@ function registerRenameDeleteHandlers(plugin, settingsBuilder) {
     logPluginSettingsOrder(plugin.app);
   });
   const app = plugin.app;
-  const renameDeleteHandler = new RenameDeleteHandler(app);
   plugin.registerEvent(
     app.vault.on("delete", (file) => {
       if (!shouldInvokeHandler(app, pluginId, "Delete")) {
         return;
       }
-      (0, import_Async.invokeAsyncSafely)(renameDeleteHandler.handleDelete(file));
+      (0, import_ChainedPromise.chainAsyncFn)(app, () => handleDelete(app, file));
     })
   );
   plugin.registerEvent(
@@ -74,7 +73,7 @@ function registerRenameDeleteHandlers(plugin, settingsBuilder) {
       if (!shouldInvokeHandler(app, pluginId, "Rename")) {
         return;
       }
-      (0, import_Async.invokeAsyncSafely)(renameDeleteHandler.handleRename(file, oldPath));
+      (0, import_ChainedPromise.chainAsyncFn)(app, () => handleRename(app, file, oldPath));
     })
   );
 }
@@ -87,275 +86,239 @@ function shouldInvokeHandler(app, pluginId, handlerType) {
   }
   return true;
 }
-class RenameDeleteHandler {
-  constructor(app) {
-    this.app = app;
+function getRenameDeleteHandlersMap(app) {
+  return (0, import_App.getObsidianDevUtilsState)(app, "renameDeleteHandlersMap", /* @__PURE__ */ new Map()).value;
+}
+function logPluginSettingsOrder(app) {
+  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);
+  console.debug(`Rename/delete handlers will use plugin settings in the following order: ${Array.from(renameDeleteHandlersMap.keys()).join(", ")}`);
+}
+const specialRenames = [];
+async function handleRename(app, file, oldPath) {
+  console.debug(`Handle Rename ${oldPath} -> ${file.path}`);
+  if (!(file instanceof import_obsidian.TFile)) {
+    return;
   }
-  renamingPaths = /* @__PURE__ */ new Set();
-  specialRenames = [];
-  async handleRename(file, oldPath) {
-    console.debug(`Handle Rename ${oldPath} -> ${file.path}`);
-    if (this.renamingPaths.has(oldPath)) {
-      return;
-    }
-    if (!(file instanceof import_obsidian.TFile)) {
-      return;
-    }
-    const specialRename = this.specialRenames.find((x) => x.oldPath === file.path);
-    if (specialRename) {
-      await this.app.vault.rename(file, specialRename.tempPath);
-      return;
-    }
-    if (this.app.vault.adapter.insensitive && oldPath.toLowerCase() === file.path.toLowerCase() && (0, import_Path.dirname)(oldPath) === (0, import_Path.dirname)(file.path)) {
-      this.specialRenames.push({
-        oldPath,
-        newPath: file.path,
-        tempPath: (0, import_Path.join)(file.parent?.path ?? "", "__temp__" + file.name)
-      });
-      await this.app.vault.rename(file, oldPath);
-      return;
-    }
-    const updateAllLinks = this.app.fileManager.updateAllLinks;
-    try {
-      this.app.fileManager.updateAllLinks = async () => {
-      };
-      const renameMap = /* @__PURE__ */ new Map();
-      await this.fillRenameMap(file, oldPath, renameMap);
-      renameMap.set(oldPath, file.path);
-      for (const oldPath2 of renameMap.keys()) {
-        this.renamingPaths.add(oldPath2);
-      }
-      for (const [oldPath2, newPath2] of renameMap.entries()) {
-        await this.processRename(oldPath2, newPath2, renameMap);
-      }
-    } finally {
-      this.renamingPaths.delete(oldPath);
-      this.app.fileManager.updateAllLinks = updateAllLinks;
-      const specialRename2 = this.specialRenames.find((x) => x.tempPath === file.path);
-      if (specialRename2) {
-        await this.app.vault.rename(file, specialRename2.newPath);
-        this.specialRenames.remove(specialRename2);
-      }
-    }
+  const specialRename = specialRenames.find((x) => x.oldPath === file.path);
+  if (specialRename) {
+    await app.vault.rename(file, specialRename.tempPath);
+    return;
   }
-  async handleDelete(file) {
-    console.debug(`Handle Delete ${file.path}`);
-    if (!(0, import_TAbstractFile.isNote)(file)) {
-      return;
-    }
-    if (this.renamingPaths.has(file.path)) {
-      return;
-    }
-    const attachmentFolderPath = await (0, import_AttachmentPath.getAttachmentFolderPath)(this.app, file.path);
-    const attachmentFolder = this.app.vault.getFolderByPath(attachmentFolderPath);
-    if (!attachmentFolder) {
-      return;
-    }
-    const settings = this.getSettings();
-    if (settings.shouldDeleteOrphanAttachments) {
-      await (0, import_Vault.deleteSafe)(this.app, attachmentFolder, file.path, false, settings.shouldDeleteEmptyFolders);
-    }
+  if (app.vault.adapter.insensitive && oldPath.toLowerCase() === file.path.toLowerCase() && (0, import_Path.dirname)(oldPath) === (0, import_Path.dirname)(file.path)) {
+    specialRenames.push({
+      oldPath,
+      newPath: file.path,
+      tempPath: (0, import_Path.join)(file.parent?.path ?? "", "__temp__" + file.name)
+    });
+    await app.vault.rename(file, oldPath);
+    return;
   }
-  async fillRenameMap(file, oldPath, renameMap) {
-    if (!(0, import_TAbstractFile.isNote)(file)) {
-      return;
+  const updateAllLinks = app.fileManager.updateAllLinks;
+  try {
+    app.fileManager.updateAllLinks = async () => {
+    };
+    const renameMap = /* @__PURE__ */ new Map();
+    await fillRenameMap(app, file, oldPath, renameMap);
+    renameMap.set(oldPath, file.path);
+    for (const [oldPath2, newPath2] of renameMap.entries()) {
+      await processRename(app, oldPath2, newPath2, renameMap);
     }
-    const settings = this.getSettings();
-    const oldAttachmentFolderPath = await (0, import_AttachmentPath.getAttachmentFolderPath)(this.app, oldPath);
-    const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder ? await (0, import_AttachmentPath.getAttachmentFolderPath)(this.app, file.path) : oldAttachmentFolderPath;
-    const dummyOldAttachmentFolderPath = await (0, import_AttachmentPath.getAttachmentFolderPath)(this.app, (0, import_Path.join)((0, import_Path.dirname)(oldPath), "DUMMY_FILE.md"));
-    const oldAttachmentFolder = this.app.vault.getFolderByPath(oldAttachmentFolderPath);
-    if (!oldAttachmentFolder) {
-      return;
+  } finally {
+    app.fileManager.updateAllLinks = updateAllLinks;
+    const specialRename2 = specialRenames.find((x) => x.tempPath === file.path);
+    if (specialRename2) {
+      await app.vault.rename(file, specialRename2.newPath);
+      specialRenames.remove(specialRename2);
     }
-    if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {
+  }
+}
+async function handleDelete(app, file) {
+  console.debug(`Handle Delete ${file.path}`);
+  if (!(0, import_TAbstractFile.isNote)(file)) {
+    return;
+  }
+  const attachmentFolderPath = await (0, import_AttachmentPath.getAttachmentFolderPath)(app, file.path);
+  const attachmentFolder = app.vault.getFolderByPath(attachmentFolderPath);
+  if (!attachmentFolder) {
+    return;
+  }
+  const settings = getSettings(app);
+  if (settings.shouldDeleteOrphanAttachments) {
+    await (0, import_Vault.deleteSafe)(app, attachmentFolder, file.path, false, settings.shouldDeleteEmptyFolders);
+  }
+}
+async function fillRenameMap(app, file, oldPath, renameMap) {
+  if (!(0, import_TAbstractFile.isNote)(file)) {
+    return;
+  }
+  const settings = getSettings(app);
+  const oldAttachmentFolderPath = await (0, import_AttachmentPath.getAttachmentFolderPath)(app, oldPath);
+  const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder ? await (0, import_AttachmentPath.getAttachmentFolderPath)(app, file.path) : oldAttachmentFolderPath;
+  const dummyOldAttachmentFolderPath = await (0, import_AttachmentPath.getAttachmentFolderPath)(app, (0, import_Path.join)((0, import_Path.dirname)(oldPath), "DUMMY_FILE.md"));
+  const oldAttachmentFolder = app.vault.getFolderByPath(oldAttachmentFolderPath);
+  if (!oldAttachmentFolder) {
+    return;
+  }
+  if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {
+    return;
+  }
+  const children = [];
+  if (oldAttachmentFolderPath === dummyOldAttachmentFolderPath) {
+    const cache = await (0, import_MetadataCache.getCacheSafe)(app, file);
+    if (!cache) {
       return;
     }
-    const children = [];
-    if (oldAttachmentFolderPath === dummyOldAttachmentFolderPath) {
-      const cache = await (0, import_MetadataCache.getCacheSafe)(this.app, file);
-      if (!cache) {
-        return;
+    for (const link of (0, import_MetadataCache.getAllLinks)(cache)) {
+      const attachmentFile = (0, import_Link.extractLinkFile)(app, link, oldPath);
+      if (!attachmentFile) {
+        continue;
       }
-      for (const link of (0, import_MetadataCache.getAllLinks)(cache)) {
-        const attachmentFile = (0, import_Link.extractLinkFile)(this.app, link, oldPath);
-        if (!attachmentFile) {
-          continue;
-        }
-        if (attachmentFile.path.startsWith(oldAttachmentFolderPath)) {
-          const backlinks = await (0, import_MetadataCache.getBacklinksForFileSafe)(this.app, attachmentFile);
-          if (backlinks.keys().length === 1) {
-            children.push(attachmentFile);
-          }
+      if (attachmentFile.path.startsWith(oldAttachmentFolderPath)) {
+        const backlinks = await (0, import_MetadataCache.getBacklinksForFileSafe)(app, attachmentFile);
+        if (backlinks.keys().length === 1) {
+          children.push(attachmentFile);
         }
       }
-    } else {
-      import_obsidian.Vault.recurseChildren(oldAttachmentFolder, (child) => {
-        if (child instanceof import_obsidian.TFile) {
-          children.push(child);
-        }
-      });
     }
-    const oldNoteBaseName = (0, import_Path.basename)(oldPath, (0, import_Path.extname)(oldPath));
-    for (const child of children) {
-      if ((0, import_TAbstractFile.isNote)(child)) {
-        continue;
+  } else {
+    import_obsidian.Vault.recurseChildren(oldAttachmentFolder, (child) => {
+      if (child instanceof import_obsidian.TFile) {
+        children.push(child);
       }
-      const relativePath = (0, import_Path.relative)(oldAttachmentFolderPath, child.path);
-      const newDir = (0, import_Path.join)(newAttachmentFolderPath, (0, import_Path.dirname)(relativePath));
-      const newChildBasename = settings.shouldRenameAttachmentFiles ? child.basename.replaceAll(oldNoteBaseName, file.basename) : child.basename;
-      let newChildPath = (0, import_Path.join)(newDir, (0, import_Path.makeFileName)(newChildBasename, child.extension));
-      if (child.path !== newChildPath) {
-        if (settings.shouldDeleteConflictingAttachments) {
-          const newChildFile = this.app.vault.getFileByPath(newChildPath);
-          if (newChildFile) {
-            await this.app.fileManager.trashFile(newChildFile);
-          }
-        } else {
-          newChildPath = this.app.vault.getAvailablePath((0, import_Path.join)(newDir, newChildBasename), child.extension);
+    });
+  }
+  const oldNoteBaseName = (0, import_Path.basename)(oldPath, (0, import_Path.extname)(oldPath));
+  for (const child of children) {
+    if ((0, import_TAbstractFile.isNote)(child)) {
+      continue;
+    }
+    const relativePath = (0, import_Path.relative)(oldAttachmentFolderPath, child.path);
+    const newDir = (0, import_Path.join)(newAttachmentFolderPath, (0, import_Path.dirname)(relativePath));
+    const newChildBasename = settings.shouldRenameAttachmentFiles ? child.basename.replaceAll(oldNoteBaseName, file.basename) : child.basename;
+    let newChildPath = (0, import_Path.join)(newDir, (0, import_Path.makeFileName)(newChildBasename, child.extension));
+    if (child.path !== newChildPath) {
+      if (settings.shouldDeleteConflictingAttachments) {
+        const newChildFile = app.vault.getFileByPath(newChildPath);
+        if (newChildFile) {
+          await app.fileManager.trashFile(newChildFile);
         }
-        renameMap.set(child.path, newChildPath);
+      } else {
+        newChildPath = app.vault.getAvailablePath((0, import_Path.join)(newDir, newChildBasename), child.extension);
       }
+      renameMap.set(child.path, newChildPath);
     }
   }
-  async processRename(oldPath, newPath, renameMap) {
+}
+async function processRename(app, oldPath, newPath, renameMap) {
+  const settings = getSettings(app);
+  let oldFile = app.vault.getFileByPath(oldPath);
+  let newFile = app.vault.getFileByPath(newPath);
+  if (oldFile) {
+    await (0, import_Vault.createFolderSafe)(app, (0, import_Path.dirname)(newPath));
+    const oldFolder = oldFile.parent;
     try {
-      const settings = this.getSettings();
-      let oldFile = this.app.vault.getFileByPath(oldPath);
-      let newFile = this.app.vault.getFileByPath(newPath);
-      if (oldFile) {
-        await (0, import_Vault.createFolderSafe)(this.app, (0, import_Path.dirname)(newPath));
-        const oldFolder = oldFile.parent;
+      if (newFile) {
         try {
-          if (newFile) {
-            try {
-              await this.app.fileManager.trashFile(newFile);
-            } catch (e) {
-              if (this.app.vault.getAbstractFileByPath(newPath)) {
-                throw e;
-              }
-            }
-          }
-          await this.app.vault.rename(oldFile, newPath);
+          await app.fileManager.trashFile(newFile);
         } catch (e) {
-          if (!this.app.vault.getAbstractFileByPath(newPath) || this.app.vault.getAbstractFileByPath(oldPath)) {
+          if (app.vault.getAbstractFileByPath(newPath)) {
             throw e;
           }
         }
-        if (settings.shouldDeleteEmptyFolders) {
-          await (0, import_Vault.deleteEmptyFolderHierarchy)(this.app, oldFolder);
-        }
       }
-      oldFile = (0, import_implementations.createTFileInstance)(this.app.vault, oldPath);
-      newFile = this.app.vault.getFileByPath(newPath);
-      if (!oldFile.deleted || !newFile) {
-        throw new Error(`Could not rename ${oldPath} to ${newPath}`);
-      }
-      if (!settings.shouldUpdateLinks) {
-        return;
+      await app.vault.rename(oldFile, newPath);
+    } catch (e) {
+      if (!app.vault.getAbstractFileByPath(newPath) || app.vault.getAbstractFileByPath(oldPath)) {
+        throw e;
       }
-      const backlinks = await this.getBacklinks(oldFile, newFile);
-      for (const parentNotePath of backlinks.keys()) {
-        let parentNote = this.app.vault.getFileByPath(parentNotePath);
-        if (!parentNote) {
-          const newParentNotePath = renameMap.get(parentNotePath);
-          if (newParentNotePath) {
-            parentNote = this.app.vault.getFileByPath(newParentNotePath);
-          }
-        }
-        if (!parentNote) {
-          console.warn(`Parent note not found: ${parentNotePath}`);
-          continue;
-        }
-        await (0, import_Vault.applyFileChanges)(this.app, parentNote, async () => {
-          const links = (await this.getBacklinks(oldFile, newFile)).get(parentNotePath) ?? [];
-          const changes = [];
-          for (const link of links) {
-            changes.push({
-              startIndex: link.position.start.offset,
-              endIndex: link.position.end.offset,
-              oldContent: link.original,
-              newContent: (0, import_Link.updateLink)({
-                app: this.app,
-                link,
-                pathOrFile: newFile,
-                oldPathOrFile: oldPath,
-                sourcePathOrFile: parentNote,
-                renameMap,
-                shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases
-              })
-            });
-          }
-          return changes;
-        });
-      }
-      if ((0, import_TAbstractFile.isCanvasFile)(newFile)) {
-        await (0, import_Vault.processWithRetry)(this.app, newFile, (content) => {
-          const canvasData = JSON.parse(content);
-          for (const node of canvasData.nodes) {
-            if (node.type !== "file") {
-              continue;
-            }
-            const newPath2 = renameMap.get(node.file);
-            if (!newPath2) {
-              continue;
-            }
-            node.file = newPath2;
-          }
-          return (0, import_Object.toJson)(canvasData);
-        });
-      } else if ((0, import_TAbstractFile.isMarkdownFile)(newFile)) {
-        await (0, import_Link.updateLinksInFile)({
-          app: this.app,
-          pathOrFile: newFile,
-          oldPathOrFile: oldPath,
-          renameMap,
-          shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases
-        });
-      }
-    } finally {
-      this.renamingPaths.delete(oldPath);
     }
-  }
-  async getBacklinks(oldFile, newFile) {
-    const backlinks = /* @__PURE__ */ new Map();
-    const oldLinks = await (0, import_MetadataCache.getBacklinksForFileSafe)(this.app, oldFile);
-    for (const path of oldLinks.keys()) {
-      backlinks.set(path, oldLinks.get(path) ?? []);
+    if (settings.shouldDeleteEmptyFolders) {
+      await (0, import_Vault.deleteEmptyFolderHierarchy)(app, oldFolder);
     }
-    if (!newFile) {
-      return backlinks;
+  }
+  oldFile = (0, import_implementations.createTFileInstance)(app.vault, oldPath);
+  newFile = app.vault.getFileByPath(newPath);
+  if (!oldFile.deleted || !newFile) {
+    throw new Error(`Could not rename ${oldPath} to ${newPath}`);
+  }
+  if (!settings.shouldUpdateLinks) {
+    return;
+  }
+  const backlinks = await (0, import_MetadataCache.getBacklinksMap)(app, [oldFile, newFile]);
+  for (const parentNotePath of backlinks.keys()) {
+    let parentNote = app.vault.getFileByPath(parentNotePath);
+    if (!parentNote) {
+      const newParentNotePath = renameMap.get(parentNotePath);
+      if (newParentNotePath) {
+        parentNote = app.vault.getFileByPath(newParentNotePath);
+      }
     }
-    const newLinks = await (0, import_MetadataCache.getBacklinksForFileSafe)(this.app, newFile);
-    for (const path of newLinks.keys()) {
-      const links = backlinks.get(path) ?? [];
-      links.push(...newLinks.get(path) ?? []);
-      backlinks.set(path, links);
+    if (!parentNote) {
+      console.warn(`Parent note not found: ${parentNotePath}`);
+      continue;
     }
-    return backlinks;
+    await (0, import_Vault.applyFileChanges)(app, parentNote, async () => {
+      const backlinks2 = await (0, import_MetadataCache.getBacklinksMap)(app, [oldFile, newFile]);
+      const links = backlinks2.get(parentNotePath) ?? [];
+      const changes = [];
+      for (const link of links) {
+        changes.push({
+          startIndex: link.position.start.offset,
+          endIndex: link.position.end.offset,
+          oldContent: link.original,
+          newContent: (0, import_Link.updateLink)({
+            app,
+            link,
+            pathOrFile: newFile,
+            oldPathOrFile: oldPath,
+            sourcePathOrFile: parentNote,
+            renameMap,
+            shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases
+          })
+        });
+      }
+      return changes;
+    });
   }
-  getSettings() {
-    const renameDeleteHandlersMap = getRenameDeleteHandlersMap(this.app);
-    const settingsBuilders = Array.from(renameDeleteHandlersMap.values()).reverse();
-    const settings = {};
-    for (const settingsBuilder of settingsBuilders) {
-      const newSettings = settingsBuilder();
-      for (const [key, value] of Object.entries(newSettings)) {
-        settings[key] ||= value;
+  if ((0, import_TAbstractFile.isCanvasFile)(newFile)) {
+    await (0, import_Vault.processWithRetry)(app, newFile, (content) => {
+      const canvasData = JSON.parse(content);
+      for (const node of canvasData.nodes) {
+        if (node.type !== "file") {
+          continue;
+        }
+        const newPath2 = renameMap.get(node.file);
+        if (!newPath2) {
+          continue;
+        }
+        node.file = newPath2;
       }
-    }
-    return settings;
+      return (0, import_Object.toJson)(canvasData);
+    });
+  } else if ((0, import_TAbstractFile.isMarkdownFile)(newFile)) {
+    await (0, import_Link.updateLinksInFile)({
+      app,
+      pathOrFile: newFile,
+      oldPathOrFile: oldPath,
+      renameMap,
+      shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases
+    });
   }
 }
-function getRenameDeleteHandlersMap(app) {
-  return (0, import_App.getObsidianDevUtilsState)(app, "renameDeleteHandlersMap", /* @__PURE__ */ new Map()).value;
-}
-function logPluginSettingsOrder(app) {
+function getSettings(app) {
   const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);
-  console.debug(`Rename/delete handlers will use plugin settings in the following order: ${Array.from(renameDeleteHandlersMap.keys()).join(", ")}`);
+  const settingsBuilders = Array.from(renameDeleteHandlersMap.values()).reverse();
+  const settings = {};
+  for (const settingsBuilder of settingsBuilders) {
+    const newSettings = settingsBuilder();
+    for (const [key, value] of Object.entries(newSettings)) {
+      settings[key] ||= value;
+    }
+  }
+  return settings;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   registerRenameDeleteHandlers
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/RenameDeleteHandler.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (()=>{if(typeof __filename!==\"string\"){return new URL(window.location.href)}return require(\"node:url\").pathToFileURL(__filename)})();\nvar __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\nimport type {\n  Plugin,\n  ReferenceCache,\n  TAbstractFile\n} from 'obsidian';\nimport {\n  App,\n  TFile,\n  Vault\n} from 'obsidian';\nimport type { CanvasData } from 'obsidian/canvas.js';\nimport { createTFileInstance } from 'obsidian-typings/implementations';\n\nimport { invokeAsyncSafely } from '../Async.ts';\nimport { toJson } from '../Object.ts';\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  makeFileName,\n  relative\n} from '../Path.ts';\nimport { getObsidianDevUtilsState } from './App.ts';\nimport { getAttachmentFolderPath } from './AttachmentPath.ts';\nimport {\n  extractLinkFile,\n  updateLink,\n  updateLinksInFile\n} from './Link.ts';\nimport {\n  getAllLinks,\n  getBacklinksForFileSafe,\n  getCacheSafe\n} from './MetadataCache.ts';\nimport {\n  isCanvasFile,\n  isMarkdownFile,\n  isNote\n} from './TAbstractFile.ts';\nimport {\n  applyFileChanges,\n  createFolderSafe,\n  deleteEmptyFolderHierarchy,\n  deleteSafe,\n  processWithRetry\n} from './Vault.ts';\n\ninterface SpecialRename {\n  oldPath: string;\n  newPath: string;\n  tempPath: string;\n}\n\n/**\n * Settings for the rename/delete handler.\n */\nexport interface RenameDeleteHandlerSettings {\n  /**\n   * Whether to delete conflicting attachments.\n   */\n  shouldDeleteConflictingAttachments: boolean;\n\n  /**\n   * Whether to delete empty folders.\n   */\n  shouldDeleteEmptyFolders: boolean;\n\n  /**\n   * Whether to delete orphan attachments after a delete.\n   */\n  shouldDeleteOrphanAttachments: boolean;\n\n  /**\n   * Whether to rename attachment files when a note is renamed.\n   */\n  shouldRenameAttachmentFiles: boolean;\n\n  /**\n    * Whether to rename attachment folder when a note is renamed.\n    */\n  shouldRenameAttachmentFolder: boolean;\n\n  /**\n   * Whether to update filename aliases when a note is renamed.\n   */\n  shouldUpdateFilenameAliases: boolean;\n\n  /**\n   * Whether to update links when a note or attachment is renamed.\n   */\n  shouldUpdateLinks: boolean;\n}\n\n/**\n * Registers the rename/delete handlers.\n * @param plugin - The plugin instance.\n * @param settingsBuilder - A function that returns the settings for the rename delete handler.\n * @returns void\n */\nexport function registerRenameDeleteHandlers(plugin: Plugin, settingsBuilder: () => Partial<RenameDeleteHandlerSettings>): void {\n  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(plugin.app);\n  const pluginId = plugin.manifest.id;\n\n  renameDeleteHandlersMap.set(pluginId, settingsBuilder);\n  logPluginSettingsOrder(plugin.app);\n\n  plugin.register(() => {\n    renameDeleteHandlersMap.delete(pluginId);\n    logPluginSettingsOrder(plugin.app);\n  });\n\n  const app = plugin.app;\n  const renameDeleteHandler = new RenameDeleteHandler(app);\n  plugin.registerEvent(\n    app.vault.on('delete', (file) => {\n      if (!shouldInvokeHandler(app, pluginId, 'Delete')) {\n        return;\n      }\n      invokeAsyncSafely(renameDeleteHandler.handleDelete(file));\n    })\n  );\n\n  plugin.registerEvent(\n    app.vault.on('rename', (file, oldPath) => {\n      if (!shouldInvokeHandler(app, pluginId, 'Rename')) {\n        return;\n      }\n      invokeAsyncSafely(renameDeleteHandler.handleRename(file, oldPath));\n    })\n  );\n}\n\nfunction shouldInvokeHandler(app: App, pluginId: string, handlerType: string): boolean {\n  const renameDeleteHandlerPluginIds = getRenameDeleteHandlersMap(app);\n  const mainPluginId = Array.from(renameDeleteHandlerPluginIds.keys())[0];\n  if (mainPluginId !== pluginId) {\n    console.debug(`${handlerType} handler for plugin ${pluginId} is skipped, because it is handled by plugin ${mainPluginId ?? '(none)'}`);\n    return false;\n  }\n  return true;\n}\n\nclass RenameDeleteHandler {\n  public constructor(private app: App) { }\n\n  private renamingPaths = new Set<string>();\n  private specialRenames: SpecialRename[] = [];\n\n  public async handleRename(file: TAbstractFile, oldPath: string): Promise<void> {\n    console.debug(`Handle Rename ${oldPath} -> ${file.path}`);\n\n    if (this.renamingPaths.has(oldPath)) {\n      return;\n    }\n\n    if (!(file instanceof TFile)) {\n      return;\n    }\n\n    const specialRename = this.specialRenames.find((x) => x.oldPath === file.path);\n    if (specialRename) {\n      await this.app.vault.rename(file, specialRename.tempPath);\n      return;\n    }\n\n    if (this.app.vault.adapter.insensitive && oldPath.toLowerCase() === file.path.toLowerCase() && dirname(oldPath) === dirname(file.path)) {\n      this.specialRenames.push({\n        oldPath,\n        newPath: file.path,\n        tempPath: join(file.parent?.path ?? '', '__temp__' + file.name)\n      });\n\n      await this.app.vault.rename(file, oldPath);\n      return;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const updateAllLinks = this.app.fileManager.updateAllLinks;\n    try {\n      this.app.fileManager.updateAllLinks = async (): Promise<void> => {\n        // do nothing\n      };\n\n      const renameMap = new Map<string, string>();\n      await this.fillRenameMap(file, oldPath, renameMap);\n      renameMap.set(oldPath, file.path);\n      for (const oldPath of renameMap.keys()) {\n        this.renamingPaths.add(oldPath);\n      }\n\n      for (const [oldPath2, newPath2] of renameMap.entries()) {\n        await this.processRename(oldPath2, newPath2, renameMap);\n      }\n    } finally {\n      this.renamingPaths.delete(oldPath);\n      this.app.fileManager.updateAllLinks = updateAllLinks;\n\n      const specialRename = this.specialRenames.find((x) => x.tempPath === file.path);\n      if (specialRename) {\n        await this.app.vault.rename(file, specialRename.newPath);\n        this.specialRenames.remove(specialRename);\n      }\n    }\n  }\n\n  public async handleDelete(file: TAbstractFile): Promise<void> {\n    console.debug(`Handle Delete ${file.path}`);\n    if (!isNote(file)) {\n      return;\n    }\n\n    if (this.renamingPaths.has(file.path)) {\n      return;\n    }\n\n    const attachmentFolderPath = await getAttachmentFolderPath(this.app, file.path);\n    const attachmentFolder = this.app.vault.getFolderByPath(attachmentFolderPath);\n\n    if (!attachmentFolder) {\n      return;\n    }\n\n    const settings = this.getSettings();\n    if (settings.shouldDeleteOrphanAttachments) {\n      await deleteSafe(this.app, attachmentFolder, file.path, false, settings.shouldDeleteEmptyFolders);\n    }\n  }\n\n  private async fillRenameMap(file: TFile, oldPath: string, renameMap: Map<string, string>): Promise<void> {\n    if (!isNote(file)) {\n      return;\n    }\n\n    const settings = this.getSettings();\n\n    const oldAttachmentFolderPath = await getAttachmentFolderPath(this.app, oldPath);\n    const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder\n      ? await getAttachmentFolderPath(this.app, file.path)\n      : oldAttachmentFolderPath;\n    const dummyOldAttachmentFolderPath = await getAttachmentFolderPath(this.app, join(dirname(oldPath), 'DUMMY_FILE.md'));\n\n    const oldAttachmentFolder = this.app.vault.getFolderByPath(oldAttachmentFolderPath);\n\n    if (!oldAttachmentFolder) {\n      return;\n    }\n\n    if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {\n      return;\n    }\n\n    const children: TFile[] = [];\n\n    if (oldAttachmentFolderPath === dummyOldAttachmentFolderPath) {\n      const cache = await getCacheSafe(this.app, file);\n      if (!cache) {\n        return;\n      }\n      for (const link of getAllLinks(cache)) {\n        const attachmentFile = extractLinkFile(this.app, link, oldPath);\n        if (!attachmentFile) {\n          continue;\n        }\n\n        if (attachmentFile.path.startsWith(oldAttachmentFolderPath)) {\n          const backlinks = await getBacklinksForFileSafe(this.app, attachmentFile);\n          if (backlinks.keys().length === 1) {\n            children.push(attachmentFile);\n          }\n        }\n      }\n    } else {\n      Vault.recurseChildren(oldAttachmentFolder, (child) => {\n        if (child instanceof TFile) {\n          children.push(child);\n        }\n      });\n    }\n\n    const oldNoteBaseName = basename(oldPath, extname(oldPath));\n\n    for (const child of children) {\n      if (isNote(child)) {\n        continue;\n      }\n      const relativePath = relative(oldAttachmentFolderPath, child.path);\n      const newDir = join(newAttachmentFolderPath, dirname(relativePath));\n      const newChildBasename = settings.shouldRenameAttachmentFiles\n        ? child.basename.replaceAll(oldNoteBaseName, file.basename)\n        : child.basename;\n      let newChildPath = join(newDir, makeFileName(newChildBasename, child.extension));\n      if (child.path !== newChildPath) {\n        if (settings.shouldDeleteConflictingAttachments) {\n          const newChildFile = this.app.vault.getFileByPath(newChildPath);\n          if (newChildFile) {\n            await this.app.fileManager.trashFile(newChildFile);\n          }\n        } else {\n          newChildPath = this.app.vault.getAvailablePath(join(newDir, newChildBasename), child.extension);\n        }\n        renameMap.set(child.path, newChildPath);\n      }\n    }\n  }\n\n  private async processRename(oldPath: string, newPath: string, renameMap: Map<string, string>): Promise<void> {\n    try {\n      const settings = this.getSettings();\n      let oldFile = this.app.vault.getFileByPath(oldPath);\n      let newFile = this.app.vault.getFileByPath(newPath);\n\n      if (oldFile) {\n        await createFolderSafe(this.app, dirname(newPath));\n        const oldFolder = oldFile.parent;\n        try {\n          if (newFile) {\n            try {\n              await this.app.fileManager.trashFile(newFile);\n            } catch (e) {\n              if (this.app.vault.getAbstractFileByPath(newPath)) {\n                throw e;\n              }\n            }\n          }\n          await this.app.vault.rename(oldFile, newPath);\n        } catch (e) {\n          if (!this.app.vault.getAbstractFileByPath(newPath) || this.app.vault.getAbstractFileByPath(oldPath)) {\n            throw e;\n          }\n        }\n        if (settings.shouldDeleteEmptyFolders) {\n          await deleteEmptyFolderHierarchy(this.app, oldFolder);\n        }\n      }\n\n      oldFile = createTFileInstance(this.app.vault, oldPath);\n      newFile = this.app.vault.getFileByPath(newPath);\n\n      if (!oldFile.deleted || !newFile) {\n        throw new Error(`Could not rename ${oldPath} to ${newPath}`);\n      }\n\n      if (!settings.shouldUpdateLinks) {\n        return;\n      }\n\n      const backlinks = await this.getBacklinks(oldFile, newFile);\n\n      for (const parentNotePath of backlinks.keys()) {\n        let parentNote = this.app.vault.getFileByPath(parentNotePath);\n        if (!parentNote) {\n          const newParentNotePath = renameMap.get(parentNotePath);\n          if (newParentNotePath) {\n            parentNote = this.app.vault.getFileByPath(newParentNotePath);\n          }\n        }\n\n        if (!parentNote) {\n          console.warn(`Parent note not found: ${parentNotePath}`);\n          continue;\n        }\n\n        await applyFileChanges(this.app, parentNote, async () => {\n          const links\n            = (await this.getBacklinks(oldFile, newFile)).get(parentNotePath) ?? [];\n          const changes = [];\n\n          for (const link of links) {\n            changes.push({\n              startIndex: link.position.start.offset,\n              endIndex: link.position.end.offset,\n              oldContent: link.original,\n              newContent: updateLink({\n                app: this.app,\n                link,\n                pathOrFile: newFile,\n                oldPathOrFile: oldPath,\n                sourcePathOrFile: parentNote,\n                renameMap,\n                shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases\n              })\n            });\n          }\n\n          return changes;\n        });\n      }\n\n      if (isCanvasFile(newFile)) {\n        await processWithRetry(this.app, newFile, (content) => {\n          const canvasData = JSON.parse(content) as CanvasData;\n          for (const node of canvasData.nodes) {\n            if (node.type !== 'file') {\n              continue;\n            }\n            const newPath = renameMap.get(node.file);\n            if (!newPath) {\n              continue;\n            }\n            node.file = newPath;\n          }\n          return toJson(canvasData);\n        });\n      } else if (isMarkdownFile(newFile)) {\n        await updateLinksInFile({\n          app: this.app,\n          pathOrFile: newFile,\n          oldPathOrFile: oldPath,\n          renameMap,\n          shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases\n        });\n      }\n    } finally {\n      this.renamingPaths.delete(oldPath);\n    }\n  }\n\n  private async getBacklinks(oldFile: TFile, newFile: TFile | null): Promise<Map<string, ReferenceCache[]>> {\n    const backlinks = new Map<string, ReferenceCache[]>();\n    const oldLinks = await getBacklinksForFileSafe(this.app, oldFile);\n    for (const path of oldLinks.keys()) {\n      backlinks.set(path, oldLinks.get(path) ?? []);\n    }\n\n    if (!newFile) {\n      return backlinks;\n    }\n\n    const newLinks = await getBacklinksForFileSafe(this.app, newFile);\n\n    for (const path of newLinks.keys()) {\n      const links = backlinks.get(path) ?? [];\n      links.push(...newLinks.get(path) ?? []);\n      backlinks.set(path, links);\n    }\n\n    return backlinks;\n  }\n\n  private getSettings(): Partial<RenameDeleteHandlerSettings> {\n    const renameDeleteHandlersMap = getRenameDeleteHandlersMap(this.app);\n    const settingsBuilders = Array.from(renameDeleteHandlersMap.values()).reverse();\n\n    const settings: Partial<RenameDeleteHandlerSettings> = {};\n    for (const settingsBuilder of settingsBuilders) {\n      const newSettings = settingsBuilder();\n      for (const [key, value] of Object.entries(newSettings) as [keyof RenameDeleteHandlerSettings, boolean][]) {\n        settings[key] ||= value;\n      }\n    }\n\n    return settings;\n  }\n}\n\nfunction getRenameDeleteHandlersMap(app: App): Map<string, () => Partial<RenameDeleteHandlerSettings>> {\n  return getObsidianDevUtilsState(app, 'renameDeleteHandlersMap', new Map<string, () => Partial<RenameDeleteHandlerSettings>>()).value;\n}\n\nfunction logPluginSettingsOrder(app: App): void {\n  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);\n  console.debug(`Rename/delete handlers will use plugin settings in the following order: ${Array.from(renameDeleteHandlersMap.keys()).join(', ')}`);\n}\n"],
  "mappings": "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",
  "names": ["oldPath", "specialRename", "newPath"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/RenameDeleteHandler.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (()=>{if(typeof __filename!==\"string\"){return new URL(window.location.href)}return require(\"node:url\").pathToFileURL(__filename)})();\nvar __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\nimport type {\n  Plugin,\n  TAbstractFile\n} from 'obsidian';\nimport {\n  App,\n  TFile,\n  Vault\n} from 'obsidian';\nimport type { CanvasData } from 'obsidian/canvas.js';\nimport { createTFileInstance } from 'obsidian-typings/implementations';\n\nimport { toJson } from '../Object.ts';\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  makeFileName,\n  relative\n} from '../Path.ts';\nimport { getObsidianDevUtilsState } from './App.ts';\nimport { getAttachmentFolderPath } from './AttachmentPath.ts';\nimport { chainAsyncFn } from './ChainedPromise.ts';\nimport {\n  extractLinkFile,\n  updateLink,\n  updateLinksInFile\n} from './Link.ts';\nimport {\n  getAllLinks,\n  getBacklinksForFileSafe,\n  getBacklinksMap,\n  getCacheSafe\n} from './MetadataCache.ts';\nimport {\n  isCanvasFile,\n  isMarkdownFile,\n  isNote\n} from './TAbstractFile.ts';\nimport {\n  applyFileChanges,\n  createFolderSafe,\n  deleteEmptyFolderHierarchy,\n  deleteSafe,\n  processWithRetry\n} from './Vault.ts';\n\ninterface SpecialRename {\n  oldPath: string;\n  newPath: string;\n  tempPath: string;\n}\n\n/**\n * Settings for the rename/delete handler.\n */\nexport interface RenameDeleteHandlerSettings {\n  /**\n   * Whether to delete conflicting attachments.\n   */\n  shouldDeleteConflictingAttachments: boolean;\n\n  /**\n   * Whether to delete empty folders.\n   */\n  shouldDeleteEmptyFolders: boolean;\n\n  /**\n   * Whether to delete orphan attachments after a delete.\n   */\n  shouldDeleteOrphanAttachments: boolean;\n\n  /**\n   * Whether to rename attachment files when a note is renamed.\n   */\n  shouldRenameAttachmentFiles: boolean;\n\n  /**\n    * Whether to rename attachment folder when a note is renamed.\n    */\n  shouldRenameAttachmentFolder: boolean;\n\n  /**\n   * Whether to update filename aliases when a note is renamed.\n   */\n  shouldUpdateFilenameAliases: boolean;\n\n  /**\n   * Whether to update links when a note or attachment is renamed.\n   */\n  shouldUpdateLinks: boolean;\n}\n\n/**\n * Registers the rename/delete handlers.\n * @param plugin - The plugin instance.\n * @param settingsBuilder - A function that returns the settings for the rename delete handler.\n * @returns void\n */\nexport function registerRenameDeleteHandlers(plugin: Plugin, settingsBuilder: () => Partial<RenameDeleteHandlerSettings>): void {\n  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(plugin.app);\n  const pluginId = plugin.manifest.id;\n\n  renameDeleteHandlersMap.set(pluginId, settingsBuilder);\n  logPluginSettingsOrder(plugin.app);\n\n  plugin.register(() => {\n    renameDeleteHandlersMap.delete(pluginId);\n    logPluginSettingsOrder(plugin.app);\n  });\n\n  const app = plugin.app;\n  plugin.registerEvent(\n    app.vault.on('delete', (file) => {\n      if (!shouldInvokeHandler(app, pluginId, 'Delete')) {\n        return;\n      }\n      chainAsyncFn(app, () => handleDelete(app, file));\n    })\n  );\n\n  plugin.registerEvent(\n    app.vault.on('rename', (file, oldPath) => {\n      if (!shouldInvokeHandler(app, pluginId, 'Rename')) {\n        return;\n      }\n      chainAsyncFn(app, () => handleRename(app, file, oldPath));\n    })\n  );\n}\n\nfunction shouldInvokeHandler(app: App, pluginId: string, handlerType: string): boolean {\n  const renameDeleteHandlerPluginIds = getRenameDeleteHandlersMap(app);\n  const mainPluginId = Array.from(renameDeleteHandlerPluginIds.keys())[0];\n  if (mainPluginId !== pluginId) {\n    console.debug(`${handlerType} handler for plugin ${pluginId} is skipped, because it is handled by plugin ${mainPluginId ?? '(none)'}`);\n    return false;\n  }\n  return true;\n}\n\nfunction getRenameDeleteHandlersMap(app: App): Map<string, () => Partial<RenameDeleteHandlerSettings>> {\n  return getObsidianDevUtilsState(app, 'renameDeleteHandlersMap', new Map<string, () => Partial<RenameDeleteHandlerSettings>>()).value;\n}\n\nfunction logPluginSettingsOrder(app: App): void {\n  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);\n  console.debug(`Rename/delete handlers will use plugin settings in the following order: ${Array.from(renameDeleteHandlersMap.keys()).join(', ')}`);\n}\n\nconst specialRenames: SpecialRename[] = [];\n\nasync function handleRename(app: App, file: TAbstractFile, oldPath: string): Promise<void> {\n  console.debug(`Handle Rename ${oldPath} -> ${file.path}`);\n\n  if (!(file instanceof TFile)) {\n    return;\n  }\n\n  const specialRename = specialRenames.find((x) => x.oldPath === file.path);\n  if (specialRename) {\n    await app.vault.rename(file, specialRename.tempPath);\n    return;\n  }\n\n  if (app.vault.adapter.insensitive && oldPath.toLowerCase() === file.path.toLowerCase() && dirname(oldPath) === dirname(file.path)) {\n    specialRenames.push({\n      oldPath,\n      newPath: file.path,\n      tempPath: join(file.parent?.path ?? '', '__temp__' + file.name)\n    });\n\n    await app.vault.rename(file, oldPath);\n    return;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  const updateAllLinks = app.fileManager.updateAllLinks;\n  try {\n    app.fileManager.updateAllLinks = async (): Promise<void> => {\n      // do nothing\n    };\n\n    const renameMap = new Map<string, string>();\n    await fillRenameMap(app, file, oldPath, renameMap);\n    renameMap.set(oldPath, file.path);\n\n    for (const [oldPath2, newPath2] of renameMap.entries()) {\n      await processRename(app, oldPath2, newPath2, renameMap);\n    }\n  } finally {\n    app.fileManager.updateAllLinks = updateAllLinks;\n\n    const specialRename = specialRenames.find((x) => x.tempPath === file.path);\n    if (specialRename) {\n      await app.vault.rename(file, specialRename.newPath);\n      specialRenames.remove(specialRename);\n    }\n  }\n}\n\nasync function handleDelete(app: App, file: TAbstractFile): Promise<void> {\n  console.debug(`Handle Delete ${file.path}`);\n  if (!isNote(file)) {\n    return;\n  }\n\n  const attachmentFolderPath = await getAttachmentFolderPath(app, file.path);\n  const attachmentFolder = app.vault.getFolderByPath(attachmentFolderPath);\n\n  if (!attachmentFolder) {\n    return;\n  }\n\n  const settings = getSettings(app);\n  if (settings.shouldDeleteOrphanAttachments) {\n    await deleteSafe(app, attachmentFolder, file.path, false, settings.shouldDeleteEmptyFolders);\n  }\n}\n\nasync function fillRenameMap(app: App, file: TFile, oldPath: string, renameMap: Map<string, string>): Promise<void> {\n  if (!isNote(file)) {\n    return;\n  }\n\n  const settings = getSettings(app);\n\n  const oldAttachmentFolderPath = await getAttachmentFolderPath(app, oldPath);\n  const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder\n    ? await getAttachmentFolderPath(app, file.path)\n    : oldAttachmentFolderPath;\n  const dummyOldAttachmentFolderPath = await getAttachmentFolderPath(app, join(dirname(oldPath), 'DUMMY_FILE.md'));\n\n  const oldAttachmentFolder = app.vault.getFolderByPath(oldAttachmentFolderPath);\n\n  if (!oldAttachmentFolder) {\n    return;\n  }\n\n  if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {\n    return;\n  }\n\n  const children: TFile[] = [];\n\n  if (oldAttachmentFolderPath === dummyOldAttachmentFolderPath) {\n    const cache = await getCacheSafe(app, file);\n    if (!cache) {\n      return;\n    }\n    for (const link of getAllLinks(cache)) {\n      const attachmentFile = extractLinkFile(app, link, oldPath);\n      if (!attachmentFile) {\n        continue;\n      }\n\n      if (attachmentFile.path.startsWith(oldAttachmentFolderPath)) {\n        const backlinks = await getBacklinksForFileSafe(app, attachmentFile);\n        if (backlinks.keys().length === 1) {\n          children.push(attachmentFile);\n        }\n      }\n    }\n  } else {\n    Vault.recurseChildren(oldAttachmentFolder, (child) => {\n      if (child instanceof TFile) {\n        children.push(child);\n      }\n    });\n  }\n\n  const oldNoteBaseName = basename(oldPath, extname(oldPath));\n\n  for (const child of children) {\n    if (isNote(child)) {\n      continue;\n    }\n    const relativePath = relative(oldAttachmentFolderPath, child.path);\n    const newDir = join(newAttachmentFolderPath, dirname(relativePath));\n    const newChildBasename = settings.shouldRenameAttachmentFiles\n      ? child.basename.replaceAll(oldNoteBaseName, file.basename)\n      : child.basename;\n    let newChildPath = join(newDir, makeFileName(newChildBasename, child.extension));\n    if (child.path !== newChildPath) {\n      if (settings.shouldDeleteConflictingAttachments) {\n        const newChildFile = app.vault.getFileByPath(newChildPath);\n        if (newChildFile) {\n          await app.fileManager.trashFile(newChildFile);\n        }\n      } else {\n        newChildPath = app.vault.getAvailablePath(join(newDir, newChildBasename), child.extension);\n      }\n      renameMap.set(child.path, newChildPath);\n    }\n  }\n}\n\nasync function processRename(app: App, oldPath: string, newPath: string, renameMap: Map<string, string>): Promise<void> {\n  const settings = getSettings(app);\n  let oldFile = app.vault.getFileByPath(oldPath);\n  let newFile = app.vault.getFileByPath(newPath);\n\n  if (oldFile) {\n    await createFolderSafe(app, dirname(newPath));\n    const oldFolder = oldFile.parent;\n    try {\n      if (newFile) {\n        try {\n          await app.fileManager.trashFile(newFile);\n        } catch (e) {\n          if (app.vault.getAbstractFileByPath(newPath)) {\n            throw e;\n          }\n        }\n      }\n      await app.vault.rename(oldFile, newPath);\n    } catch (e) {\n      if (!app.vault.getAbstractFileByPath(newPath) || app.vault.getAbstractFileByPath(oldPath)) {\n        throw e;\n      }\n    }\n    if (settings.shouldDeleteEmptyFolders) {\n      await deleteEmptyFolderHierarchy(app, oldFolder);\n    }\n  }\n\n  oldFile = createTFileInstance(app.vault, oldPath);\n  newFile = app.vault.getFileByPath(newPath);\n\n  if (!oldFile.deleted || !newFile) {\n    throw new Error(`Could not rename ${oldPath} to ${newPath}`);\n  }\n\n  if (!settings.shouldUpdateLinks) {\n    return;\n  }\n\n  const backlinks = await getBacklinksMap(app, [oldFile, newFile]);\n\n  for (const parentNotePath of backlinks.keys()) {\n    let parentNote = app.vault.getFileByPath(parentNotePath);\n    if (!parentNote) {\n      const newParentNotePath = renameMap.get(parentNotePath);\n      if (newParentNotePath) {\n        parentNote = app.vault.getFileByPath(newParentNotePath);\n      }\n    }\n\n    if (!parentNote) {\n      console.warn(`Parent note not found: ${parentNotePath}`);\n      continue;\n    }\n\n    await applyFileChanges(app, parentNote, async () => {\n      const backlinks = await getBacklinksMap(app, [oldFile, newFile]);\n      const links = backlinks.get(parentNotePath) ?? [];\n      const changes = [];\n\n      for (const link of links) {\n        changes.push({\n          startIndex: link.position.start.offset,\n          endIndex: link.position.end.offset,\n          oldContent: link.original,\n          newContent: updateLink({\n            app: app,\n            link,\n            pathOrFile: newFile,\n            oldPathOrFile: oldPath,\n            sourcePathOrFile: parentNote,\n            renameMap,\n            shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases\n          })\n        });\n      }\n\n      return changes;\n    });\n  }\n\n  if (isCanvasFile(newFile)) {\n    await processWithRetry(app, newFile, (content) => {\n      const canvasData = JSON.parse(content) as CanvasData;\n      for (const node of canvasData.nodes) {\n        if (node.type !== 'file') {\n          continue;\n        }\n        const newPath = renameMap.get(node.file);\n        if (!newPath) {\n          continue;\n        }\n        node.file = newPath;\n      }\n      return toJson(canvasData);\n    });\n  } else if (isMarkdownFile(newFile)) {\n    await updateLinksInFile({\n      app: app,\n      pathOrFile: newFile,\n      oldPathOrFile: oldPath,\n      renameMap,\n      shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases\n    });\n  }\n}\n\nfunction getSettings(app: App): Partial<RenameDeleteHandlerSettings> {\n  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);\n  const settingsBuilders = Array.from(renameDeleteHandlersMap.values()).reverse();\n\n  const settings: Partial<RenameDeleteHandlerSettings> = {};\n  for (const settingsBuilder of settingsBuilders) {\n    const newSettings = settingsBuilder();\n    for (const [key, value] of Object.entries(newSettings) as [keyof RenameDeleteHandlerSettings, boolean][]) {\n      settings[key] ||= value;\n    }\n  }\n\n  return settings;\n}\n"],
  "mappings": "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",
  "names": ["specialRename", "backlinks", "newPath"]
}
