obsidian-dev-utils 40.9.1 → 40.10.0

package/dist/lib/esm/obsidian/RenameDeleteHandler.mjs

@@ -29,6 +29,7 @@ import {
   hasOwnAttachmentFolder
 } from "./AttachmentPath.mjs";
 import {
+  CANVAS_FILE_EXTENSION,
   getFile,
   getFileOrNull,
   getFolderOrNull,
@@ -46,7 +47,10 @@ import {
   getAllLinks,
   getBacklinksForFileOrPath,
   getBacklinksForFileSafe,
-  tempRegisterFilesAndRun
+  registerFileCacheForNonExistingFile,
+  tempRegisterFilesAndRun,
+  tempRegisterFilesAndRunAsync,
+  unregisterFileCacheForNonExistingFile
 } from "./MetadataCache.mjs";
 import { registerPatch } from "./MonkeyAround.mjs";
 import { addToQueue } from "./Queue.mjs";
@@ -58,511 +62,655 @@ import {
   deleteEmptyFolderHierarchy,
   deleteSafe
 } from "./VaultEx.mjs";
-const deletedMetadataCacheMap = /* @__PURE__ */ new Map();
-const handledRenames = /* @__PURE__ */ new Set();
-const interruptedRenamesMap = /* @__PURE__ */ new Map();
 var EmptyAttachmentFolderBehavior = /* @__PURE__ */ ((EmptyAttachmentFolderBehavior2) => {
   EmptyAttachmentFolderBehavior2["Delete"] = "Delete";
   EmptyAttachmentFolderBehavior2["DeleteWithEmptyParents"] = "DeleteWithEmptyParents";
   EmptyAttachmentFolderBehavior2["Keep"] = "Keep";
   return EmptyAttachmentFolderBehavior2;
 })(EmptyAttachmentFolderBehavior || {});
-function registerRenameDeleteHandlers(plugin, settingsBuilder) {
-  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(plugin.app);
-  const pluginId = plugin.manifest.id;
-  renameDeleteHandlersMap.set(pluginId, settingsBuilder);
-  logRegisteredHandlers(plugin.app);
-  plugin.register(() => {
-    renameDeleteHandlersMap.delete(pluginId);
-    logRegisteredHandlers(plugin.app);
-  });
-  const app = plugin.app;
-  const abortSignal = plugin.abortSignal ?? abortSignalNever();
-  plugin.registerEvent(
-    app.vault.on("delete", (file) => {
-      handleDeleteIfEnabled(plugin, file, abortSignal);
-    })
-  );
-  plugin.registerEvent(
-    app.vault.on("rename", (file, oldPath) => {
-      handleRenameIfEnabled(plugin, file, oldPath, abortSignal);
-    })
-  );
-  plugin.registerEvent(
-    app.metadataCache.on("deleted", (file, prevCache) => {
-      handleMetadataDeletedIfEnabled(plugin, file, prevCache);
-    })
-  );
-  registerPatch(plugin, app.fileManager, {
-    runAsyncLinkUpdate: (next) => {
-      return (linkUpdatesHandler) => runAsyncLinkUpdate(app, next, linkUpdatesHandler);
-    }
-  });
-}
-async function cleanupParentFolders(app, parentFolderPaths, notePath) {
-  const settings = getSettings(app);
-  if (settings.emptyAttachmentFolderBehavior === "Keep" /* Keep */) {
-    return;
-  }
-  for (const parentFolderPath of parentFolderPaths) {
-    switch (settings.emptyAttachmentFolderBehavior) {
-      case "Delete" /* Delete */:
-        await deleteSafe(app, parentFolderPath, notePath, void 0, true);
-        break;
-      case "DeleteWithEmptyParents" /* DeleteWithEmptyParents */:
-        await deleteEmptyFolderHierarchy(app, parentFolderPath);
-        break;
-      default:
-        break;
+class DeleteHandler {
+  constructor(app, file, abortSignal, settingsManager, deletedMetadataCacheMap) {
+    this.app = app;
+    this.file = file;
+    this.abortSignal = abortSignal;
+    this.settingsManager = settingsManager;
+    this.deletedMetadataCacheMap = deletedMetadataCacheMap;
+  }
+  async handle() {
+    this.abortSignal.throwIfAborted();
+    getLibDebugger("RenameDeleteHandler:handleDelete")(`Handle Delete ${this.file.path}`);
+    if (!this.settingsManager.isNoteEx(this.file.path)) {
+      return;
     }
-  }
-}
-async function continueInterruptedRenames(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks) {
-  const interruptedRenames = interruptedRenamesMap.get(oldPath);
-  if (interruptedRenames) {
-    interruptedRenamesMap.delete(oldPath);
-    for (const interruptedRename of interruptedRenames) {
-      await handleRenameAsync(app, interruptedRename.oldPath, newPath, oldPathBacklinksMap, oldPathLinks, interruptedRename.combinedBacklinksMap);
+    const settings = this.settingsManager.getSettings();
+    if (!settings.shouldHandleDeletions) {
+      return;
     }
-  }
-}
-async function fillRenameMap(app, oldPath, newPath, renameMap, oldPathLinks, abortSignal) {
-  abortSignal.throwIfAborted();
-  renameMap.set(oldPath, newPath);
-  if (!isNoteEx(app, oldPath)) {
-    return;
-  }
-  const settings = getSettings(app);
-  const oldAttachmentFolderPath = await getAttachmentFolderPath(app, oldPath, AttachmentPathContext.RenameNote);
-  const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder ? await getAttachmentFolderPath(app, newPath, AttachmentPathContext.RenameNote) : oldAttachmentFolderPath;
-  const isOldAttachmentFolderAtRoot = oldAttachmentFolderPath === "/";
-  const oldAttachmentFolder = getFolderOrNull(app, oldAttachmentFolderPath);
-  if (!oldAttachmentFolder) {
-    return;
-  }
-  if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {
-    return;
-  }
-  const oldAttachmentFiles = [];
-  if (await hasOwnAttachmentFolder(app, oldPath, AttachmentPathContext.RenameNote)) {
-    Vault.recurseChildren(oldAttachmentFolder, (oldAttachmentFile) => {
-      abortSignal.throwIfAborted();
-      if (isFile(oldAttachmentFile)) {
-        oldAttachmentFiles.push(oldAttachmentFile);
-      }
-    });
-  } else {
-    for (const oldPathLink of oldPathLinks) {
-      abortSignal.throwIfAborted();
-      const oldAttachmentFile = extractLinkFile(app, oldPathLink, oldPath);
-      if (!oldAttachmentFile) {
-        continue;
-      }
-      if (isOldAttachmentFolderAtRoot || oldAttachmentFile.path.startsWith(oldAttachmentFolderPath)) {
-        const oldAttachmentBacklinks = await getBacklinksForFileSafe(app, oldAttachmentFile);
-        abortSignal.throwIfAborted();
-        if (oldAttachmentBacklinks.keys().length === 1) {
-          oldAttachmentFiles.push(oldAttachmentFile);
+    if (settings.isPathIgnored?.(this.file.path)) {
+      getLibDebugger("RenameDeleteHandler:handleDelete")(`Skipping delete handler of ${this.file.path} as the path is ignored.`);
+      return;
+    }
+    const cache = this.deletedMetadataCacheMap.get(this.file.path);
+    this.deletedMetadataCacheMap.delete(this.file.path);
+    const parentFolderPaths = /* @__PURE__ */ new Set();
+    if (cache) {
+      const links = getAllLinks(cache);
+      for (const link of links) {
+        const attachmentFile = extractLinkFile(this.app, link, this.file.path);
+        if (!attachmentFile) {
+          continue;
+        }
+        if (this.settingsManager.isNoteEx(attachmentFile.path)) {
+          continue;
         }
+        parentFolderPaths.add(attachmentFile.parent?.path ?? "");
+        await deleteSafe(this.app, attachmentFile, this.file.path, false, settings.emptyAttachmentFolderBehavior !== "Keep" /* Keep */);
       }
     }
-  }
-  for (const oldAttachmentFile of oldAttachmentFiles) {
-    abortSignal.throwIfAborted();
-    if (isNoteEx(app, oldAttachmentFile.path)) {
-      continue;
-    }
-    let newAttachmentFilePath;
-    if (settings.shouldRenameAttachmentFiles) {
-      newAttachmentFilePath = await getAttachmentFilePath({
-        app,
-        attachmentPathOrFile: oldAttachmentFile,
-        context: AttachmentPathContext.RenameNote,
-        notePathOrFile: newPath,
-        oldNotePathOrFile: oldPath,
-        shouldSkipDuplicateCheck: true
-      });
-      abortSignal.throwIfAborted();
-    } else {
-      const relativePath = isOldAttachmentFolderAtRoot ? oldAttachmentFile.path : relative(oldAttachmentFolderPath, oldAttachmentFile.path);
-      const newFolder = join(newAttachmentFolderPath, dirname(relativePath));
-      newAttachmentFilePath = join(newFolder, oldAttachmentFile.name);
-    }
-    if (oldAttachmentFile.path === newAttachmentFilePath) {
-      continue;
-    }
-    if (settings.shouldDeleteConflictingAttachments) {
-      const newAttachmentFile = getFileOrNull(app, newAttachmentFilePath);
-      if (newAttachmentFile) {
-        getLibDebugger("RenameDeleteHandler:fillRenameMap")(`Removing conflicting attachment ${newAttachmentFile.path}.`);
-        await app.fileManager.trashFile(newAttachmentFile);
-        abortSignal.throwIfAborted();
-      }
-    } else {
-      const dir = dirname(newAttachmentFilePath);
-      const ext = extname(newAttachmentFilePath);
-      const baseName = basename(newAttachmentFilePath, ext);
-      newAttachmentFilePath = app.vault.getAvailablePath(join(dir, baseName), ext.slice(1));
+    await cleanupParentFolders(this.app, this.settingsManager.getSettings(), Array.from(parentFolderPaths), this.file.path);
+    this.abortSignal.throwIfAborted();
+    const attachmentFolderPath = await getAttachmentFolderPath(this.app, this.file.path, AttachmentPathContext.DeleteNote);
+    const attachmentFolder = getFolderOrNull(this.app, attachmentFolderPath);
+    if (!attachmentFolder) {
+      return;
+    }
+    if (!await hasOwnAttachmentFolder(this.app, this.file.path, AttachmentPathContext.DeleteNote)) {
+      return;
     }
-    renameMap.set(oldAttachmentFile.path, newAttachmentFilePath);
+    this.abortSignal.throwIfAborted();
+    await deleteSafe(this.app, attachmentFolder, this.file.path, false, settings.emptyAttachmentFolderBehavior !== "Keep" /* Keep */);
+    this.abortSignal.throwIfAborted();
   }
 }
-function getRenameDeleteHandlersMap(app) {
-  return getObsidianDevUtilsState(app, "renameDeleteHandlersMap", /* @__PURE__ */ new Map()).value;
-}
-function getSettings(app) {
-  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);
-  const settingsBuilders = Array.from(renameDeleteHandlersMap.values()).reverse();
-  const settings = {};
-  settings.isNote = (path) => isNote(app, path);
-  settings.isPathIgnored = () => false;
-  for (const settingsBuilder of settingsBuilders) {
-    const newSettings = settingsBuilder();
-    settings.shouldDeleteConflictingAttachments ||= newSettings.shouldDeleteConflictingAttachments ?? false;
-    if (newSettings.emptyAttachmentFolderBehavior) {
-      settings.emptyAttachmentFolderBehavior ??= newSettings.emptyAttachmentFolderBehavior;
-    }
-    settings.shouldHandleDeletions ||= newSettings.shouldHandleDeletions ?? false;
-    settings.shouldHandleRenames ||= newSettings.shouldHandleRenames ?? false;
-    settings.shouldRenameAttachmentFiles ||= newSettings.shouldRenameAttachmentFiles ?? false;
-    settings.shouldRenameAttachmentFolder ||= newSettings.shouldRenameAttachmentFolder ?? false;
-    settings.shouldUpdateFileNameAliases ||= newSettings.shouldUpdateFileNameAliases ?? false;
-    const isPathIgnored = settings.isPathIgnored;
-    settings.isPathIgnored = (path) => isPathIgnored(path) || (newSettings.isPathIgnored?.(path) ?? false);
-    const currentIsNote = settings.isNote;
-    settings.isNote = (path) => currentIsNote(path) && (newSettings.isNote?.(path) ?? true);
-  }
-  settings.emptyAttachmentFolderBehavior ??= "Keep" /* Keep */;
-  return settings;
-}
-async function handleCaseCollision(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks) {
-  if (!app.vault.adapter.insensitive || oldPath.toLowerCase() !== newPath.toLowerCase()) {
-    return false;
-  }
-  const tempPath = join(dirname(newPath), `__temp__${basename(newPath)}`);
-  await renameHandled(app, newPath, tempPath);
-  await handleRenameAsync(app, oldPath, tempPath, oldPathBacklinksMap, oldPathLinks);
-  await app.vault.rename(getFile(app, tempPath), newPath);
-  return true;
-}
-async function handleDelete(app, path, abortSignal) {
-  abortSignal.throwIfAborted();
-  getLibDebugger("RenameDeleteHandler:handleDelete")(`Handle Delete ${path}`);
-  if (!isNoteEx(app, path)) {
-    return;
+class HandledRenames {
+  map = /* @__PURE__ */ new Map();
+  add(oldPath, newPath) {
+    this.map.set(this.keyToString(oldPath, newPath), { newPath, oldPath });
   }
-  const settings = getSettings(app);
-  if (!settings.shouldHandleDeletions) {
-    return;
-  }
-  if (settings.isPathIgnored?.(path)) {
-    getLibDebugger("RenameDeleteHandler:handleDelete")(`Skipping delete handler of ${path} as the path is ignored.`);
-    return;
+  delete(oldPath, newPath) {
+    this.map.delete(this.keyToString(oldPath, newPath));
   }
-  const cache = deletedMetadataCacheMap.get(path);
-  deletedMetadataCacheMap.delete(path);
-  const parentFolderPaths = /* @__PURE__ */ new Set();
-  if (cache) {
-    const links = getAllLinks(cache);
-    for (const link of links) {
-      const attachmentFile = extractLinkFile(app, link, path);
-      if (!attachmentFile) {
-        continue;
-      }
-      if (isNoteEx(app, attachmentFile.path)) {
-        continue;
-      }
-      parentFolderPaths.add(attachmentFile.parent?.path ?? "");
-      await deleteSafe(app, attachmentFile, path, false, settings.emptyAttachmentFolderBehavior !== "Keep" /* Keep */);
-      abortSignal.throwIfAborted();
-    }
+  has(oldPath, newPath) {
+    return this.map.has(this.keyToString(oldPath, newPath));
   }
-  await cleanupParentFolders(app, Array.from(parentFolderPaths), path);
-  abortSignal.throwIfAborted();
-  const attachmentFolderPath = await getAttachmentFolderPath(app, path, AttachmentPathContext.DeleteNote);
-  const attachmentFolder = getFolderOrNull(app, attachmentFolderPath);
-  if (!attachmentFolder) {
-    return;
+  keys() {
+    return this.map.values();
   }
-  if (!await hasOwnAttachmentFolder(app, path, AttachmentPathContext.DeleteNote)) {
-    return;
+  keyToString(oldPath, newPath) {
+    return `${oldPath} -> ${newPath}`;
   }
-  abortSignal.throwIfAborted();
-  await deleteSafe(app, attachmentFolder, path, false, settings.emptyAttachmentFolderBehavior !== "Keep" /* Keep */);
-  abortSignal.throwIfAborted();
 }
-function handleDeleteIfEnabled(plugin, file, abortSignal) {
-  const app = plugin.app;
-  if (!shouldInvokeHandler(plugin)) {
-    return;
+class MetadataDeletedHandler {
+  constructor(app, file, prevCache, settingsManager, deletedMetadataCacheMap) {
+    this.app = app;
+    this.file = file;
+    this.prevCache = prevCache;
+    this.settingsManager = settingsManager;
+    this.deletedMetadataCacheMap = deletedMetadataCacheMap;
+  }
+  handle() {
+    const settings = this.settingsManager.getSettings();
+    if (!settings.shouldHandleDeletions) {
+      return;
+    }
+    if (settings.isPathIgnored?.(this.file.path)) {
+      getLibDebugger("RenameDeleteHandler:handleMetadataDeleted")(`Skipping metadata delete handler of ${this.file.path} as the path is ignored.`);
+      return;
+    }
+    if (isMarkdownFile(this.app, this.file) && this.prevCache) {
+      this.deletedMetadataCacheMap.set(this.file.path, this.prevCache);
+    }
   }
-  const path = file.path;
-  addToQueue(app, (abortSignal2) => handleDelete(app, path, abortSignal2), abortSignal);
 }
-function handleMetadataDeleted(app, file, prevCache) {
-  const settings = getSettings(app);
-  if (settings.isPathIgnored?.(file.path)) {
-    getLibDebugger("RenameDeleteHandler:handleMetadataDeleted")(`Skipping metadata delete handler of ${file.path} as the path is ignored.`);
-    return;
+class Registry {
+  constructor(plugin, settingsBuilder, settingsManager) {
+    this.plugin = plugin;
+    this.settingsBuilder = settingsBuilder;
+    this.settingsManager = settingsManager;
+    this.app = plugin.app;
+    this.pluginId = plugin.manifest.id;
+    this.abortSignal = plugin.abortSignal ?? abortSignalNever();
+  }
+  abortSignal;
+  app;
+  deletedMetadataCacheMap = /* @__PURE__ */ new Map();
+  handledRenames = new HandledRenames();
+  interruptedRenamesMap = /* @__PURE__ */ new Map();
+  pluginId;
+  register() {
+    const renameDeleteHandlersMap = this.settingsManager.renameDeleteHandlersMap;
+    renameDeleteHandlersMap.set(this.pluginId, this.settingsBuilder);
+    this.logRegisteredHandlers();
+    this.plugin.register(() => {
+      renameDeleteHandlersMap.delete(this.pluginId);
+      this.logRegisteredHandlers();
+    });
+    this.plugin.registerEvent(this.app.vault.on("delete", this.handleDelete.bind(this)));
+    this.plugin.registerEvent(this.app.vault.on("rename", this.handleRename.bind(this)));
+    this.plugin.registerEvent(this.app.metadataCache.on("deleted", this.handleMetadataDeleted.bind(this)));
+    registerPatch(this.plugin, this.app.fileManager, {
+      runAsyncLinkUpdate: (next) => {
+        return Object.assign((linkUpdatesHandler) => this.runAsyncLinkUpdate(next, linkUpdatesHandler), { renameDeleteHandlerPatched: true });
+      }
+    });
   }
-  if (!settings.shouldHandleDeletions) {
-    return;
+  handleDelete(file) {
+    if (!this.shouldInvokeHandler()) {
+      return;
+    }
+    addToQueue(
+      this.app,
+      (abortSignal) => new DeleteHandler(this.app, file, abortSignal, this.settingsManager, this.deletedMetadataCacheMap).handle(),
+      this.abortSignal
+    );
+  }
+  handleMetadataDeleted(file, prevCache) {
+    if (!this.shouldInvokeHandler()) {
+      return;
+    }
+    addToQueue(this.app, () => {
+      new MetadataDeletedHandler(this.app, file, prevCache, this.settingsManager, this.deletedMetadataCacheMap).handle();
+    }, this.abortSignal);
   }
-  if (isMarkdownFile(app, file) && prevCache) {
-    deletedMetadataCacheMap.set(file.path, prevCache);
+  handleRename(file, oldPath) {
+    if (!this.shouldInvokeHandler()) {
+      return;
+    }
+    if (!isFile(file)) {
+      return;
+    }
+    const newPath = file.path;
+    getLibDebugger("RenameDeleteHandler:handleRename")(`Handle Rename ${oldPath} -> ${newPath}`);
+    if (this.handledRenames.has(oldPath, newPath)) {
+      this.handledRenames.delete(oldPath, newPath);
+      return;
+    }
+    const settings = this.settingsManager.getSettings();
+    if (!settings.shouldHandleRenames) {
+      return;
+    }
+    if (settings.isPathIgnored?.(oldPath)) {
+      getLibDebugger("RenameDeleteHandler:handleRename")(`Skipping rename handler of old path ${oldPath} as the path is ignored.`);
+      return;
+    }
+    if (settings.isPathIgnored?.(newPath)) {
+      getLibDebugger("RenameDeleteHandler:handleRename")(`Skipping rename handler of new path ${newPath} as the path is ignored.`);
+      return;
+    }
+    const oldCache = this.app.metadataCache.getCache(oldPath) ?? this.app.metadataCache.getCache(newPath);
+    const oldPathBacklinksMap = getBacklinksForFileOrPath(this.app, oldPath).data;
+    addToQueue(this.app, (abortSignal) => new RenameHandler({
+      abortSignal,
+      app: this.app,
+      handledRenames: this.handledRenames,
+      interruptedRenamesMap: this.interruptedRenamesMap,
+      newPath,
+      oldCache,
+      oldPath,
+      oldPathBacklinksMap,
+      settingsManager: this.settingsManager
+    }).handle(), this.abortSignal);
+  }
+  logRegisteredHandlers() {
+    const renameDeleteHandlersMap = this.settingsManager.renameDeleteHandlersMap;
+    getLibDebugger("RenameDeleteHandler:logRegisteredHandlers")(
+      `Plugins with registered rename/delete handlers: ${JSON.stringify(Array.from(renameDeleteHandlersMap.keys()))}`
+    );
+  }
+  async runAsyncLinkUpdate(next, linkUpdatesHandler) {
+    if (next.renameDeleteHandlerPatched) {
+      await next.call(this.app.fileManager, linkUpdatesHandler);
+      return;
+    }
+    await next.call(this.app.fileManager, (linkUpdates) => this.wrapLinkUpdatesHandler(linkUpdates, linkUpdatesHandler));
   }
-}
-function handleMetadataDeletedIfEnabled(plugin, file, prevCache) {
-  if (!shouldInvokeHandler(plugin)) {
-    return;
+  shouldInvokeHandler() {
+    const pluginId = this.plugin.manifest.id;
+    const renameDeleteHandlersMap = this.settingsManager.renameDeleteHandlersMap;
+    const mainPluginId = Array.from(renameDeleteHandlersMap.keys())[0];
+    return mainPluginId === pluginId;
+  }
+  async wrapLinkUpdatesHandler(linkUpdates, linkUpdatesHandler) {
+    let isRenameCalled = false;
+    const eventRef = this.app.vault.on("rename", () => {
+      isRenameCalled = true;
+    });
+    try {
+      await linkUpdatesHandler(linkUpdates);
+    } finally {
+      this.app.vault.offref(eventRef);
+    }
+    const settings = this.settingsManager.getSettings();
+    if (!isRenameCalled || !settings.shouldHandleRenames) {
+      return;
+    }
+    filterInPlace(
+      linkUpdates,
+      (linkUpdate) => {
+        if (settings.isPathIgnored?.(linkUpdate.sourceFile.path)) {
+          getLibDebugger("RenameDeleteHandler:runAsyncLinkUpdate")(
+            `Roll back to default link update of source file ${linkUpdate.sourceFile.path} as the path is ignored.`
+          );
+          return true;
+        }
+        if (settings.isPathIgnored?.(linkUpdate.resolvedFile.path)) {
+          getLibDebugger("RenameDeleteHandler:runAsyncLinkUpdate")(
+            `Roll back to default link update of resolved file ${linkUpdate.resolvedFile.path} as the path is ignored.`
+          );
+          return true;
+        }
+        if (!this.app.internalPlugins.getEnabledPluginById(InternalPluginName.Canvas)) {
+          return false;
+        }
+        if (this.app.plugins.getPlugin("backlink-cache")) {
+          return false;
+        }
+        if (linkUpdate.sourceFile.extension === CANVAS_FILE_EXTENSION) {
+          return true;
+        }
+        if (linkUpdate.resolvedFile.extension === CANVAS_FILE_EXTENSION) {
+          return true;
+        }
+        return false;
+      }
+    );
   }
-  handleMetadataDeleted(plugin.app, file, prevCache);
 }
-function handleRename(app, oldPath, newPath, abortSignal) {
-  const key = makeKey(oldPath, newPath);
-  getLibDebugger("RenameDeleteHandler:handleRename")(`Handle Rename ${key}`);
-  if (handledRenames.has(key)) {
-    handledRenames.delete(key);
-    return;
+class RenameHandler {
+  abortSignal;
+  app;
+  handledRenames;
+  interruptedCombinedBacklinksMap;
+  interruptedRenamesMap;
+  newPath;
+  oldCache;
+  oldPath;
+  oldPathBacklinksMap;
+  oldPathLinks;
+  settingsManager;
+  constructor(options) {
+    this.app = options.app;
+    this.oldPath = options.oldPath;
+    this.newPath = options.newPath;
+    this.oldPathBacklinksMap = options.oldPathBacklinksMap;
+    this.oldCache = options.oldCache;
+    this.abortSignal = options.abortSignal;
+    this.settingsManager = options.settingsManager;
+    this.interruptedRenamesMap = options.interruptedRenamesMap;
+    this.oldPathLinks = this.oldCache ? getAllLinks(this.oldCache) : [];
+    this.handledRenames = options.handledRenames;
+    this.interruptedCombinedBacklinksMap = options.interruptedCombinedBacklinksMap ?? /* @__PURE__ */ new Map();
+  }
+  async handle() {
+    this.abortSignal.throwIfAborted();
+    await this.continueInterruptedRenames();
+    this.abortSignal.throwIfAborted();
+    await this.refreshLinks();
+    this.abortSignal.throwIfAborted();
+    if (await this.handleCaseCollision()) {
+      return;
+    }
+    this.abortSignal.throwIfAborted();
+    try {
+      const renameMap = new RenameMap({
+        abortSignal: this.abortSignal,
+        app: this.app,
+        newPath: this.newPath,
+        oldCache: this.oldCache,
+        oldPath: this.oldPath,
+        settingsManager: this.settingsManager
+      });
+      await renameMap.fill();
+      this.abortSignal.throwIfAborted();
+      const combinedBacklinksMap = /* @__PURE__ */ new Map();
+      renameMap.initBacklinksMap(this.oldPathBacklinksMap, combinedBacklinksMap, this.oldPath);
+      for (const attachmentOldPath of renameMap.keys()) {
+        if (attachmentOldPath === this.oldPath) {
+          continue;
+        }
+        const attachmentOldPathBacklinksMap = (await getBacklinksForFileSafe(this.app, attachmentOldPath)).data;
+        this.abortSignal.throwIfAborted();
+        renameMap.initBacklinksMap(attachmentOldPathBacklinksMap, combinedBacklinksMap, attachmentOldPath);
+      }
+      const parentFolderPaths = /* @__PURE__ */ new Set();
+      for (const [oldAttachmentPath, newAttachmentPath] of renameMap.entries()) {
+        if (oldAttachmentPath === this.oldPath) {
+          continue;
+        }
+        const fixedNewAttachmentPath = await this.renameHandled(oldAttachmentPath, newAttachmentPath);
+        this.abortSignal.throwIfAborted();
+        renameMap.set(oldAttachmentPath, fixedNewAttachmentPath);
+        parentFolderPaths.add(dirname(oldAttachmentPath));
+      }
+      await cleanupParentFolders(this.app, this.settingsManager.getSettings(), Array.from(parentFolderPaths), this.oldPath);
+      this.abortSignal.throwIfAborted();
+      const settings = this.settingsManager.getSettings();
+      for (const [newBacklinkPath, linkJsonToPathMap] of Array.from(combinedBacklinksMap.entries()).concat(
+        Array.from(this.interruptedCombinedBacklinksMap.entries())
+      )) {
+        await editLinks(this.app, newBacklinkPath, (link) => {
+          const oldAttachmentPath = linkJsonToPathMap.get(toJson(link));
+          if (!oldAttachmentPath) {
+            return;
+          }
+          const newAttachmentPath = renameMap.get(oldAttachmentPath);
+          if (!newAttachmentPath) {
+            return;
+          }
+          return updateLink(normalizeOptionalProperties({
+            app: this.app,
+            link,
+            newSourcePathOrFile: newBacklinkPath,
+            newTargetPathOrFile: newAttachmentPath,
+            oldTargetPathOrFile: oldAttachmentPath,
+            shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases
+          }));
+        }, {
+          shouldFailOnMissingFile: false
+        });
+        this.abortSignal.throwIfAborted();
+      }
+      if (this.settingsManager.isNoteEx(this.newPath)) {
+        await updateLinksInFile(normalizeOptionalProperties({
+          app: this.app,
+          newSourcePathOrFile: this.newPath,
+          oldSourcePathOrFile: this.oldPath,
+          shouldFailOnMissingFile: false,
+          shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases
+        }));
+        this.abortSignal.throwIfAborted();
+      }
+      if (!getFileOrNull(this.app, this.newPath)) {
+        let interruptedRenames = this.interruptedRenamesMap.get(this.newPath);
+        if (!interruptedRenames) {
+          interruptedRenames = [];
+          this.interruptedRenamesMap.set(this.newPath, interruptedRenames);
+        }
+        interruptedRenames.push({
+          combinedBacklinksMap,
+          oldPath: this.oldPath
+        });
+      }
+    } finally {
+      const orphanKeys = Array.from(this.handledRenames.keys());
+      addToQueue(this.app, () => {
+        for (const orphanKey of orphanKeys) {
+          this.handledRenames.delete(orphanKey.oldPath, orphanKey.newPath);
+        }
+      }, this.abortSignal);
+    }
   }
-  const settings = getSettings(app);
-  if (!settings.shouldHandleRenames) {
-    return;
+  async continueInterruptedRenames() {
+    const interruptedRenames = this.interruptedRenamesMap.get(this.oldPath);
+    if (interruptedRenames) {
+      this.interruptedRenamesMap.delete(this.oldPath);
+      for (const interruptedRename of interruptedRenames) {
+        await new RenameHandler({
+          abortSignal: this.abortSignal,
+          app: this.app,
+          handledRenames: this.handledRenames,
+          interruptedCombinedBacklinksMap: interruptedRename.combinedBacklinksMap,
+          interruptedRenamesMap: this.interruptedRenamesMap,
+          newPath: this.newPath,
+          oldCache: this.oldCache,
+          oldPath: interruptedRename.oldPath,
+          oldPathBacklinksMap: this.oldPathBacklinksMap,
+          settingsManager: this.settingsManager
+        }).handle();
+      }
+    }
   }
-  if (settings.isPathIgnored?.(oldPath)) {
-    getLibDebugger("RenameDeleteHandler:handleRename")(`Skipping rename handler of old path ${oldPath} as the path is ignored.`);
-    return;
+  async handleCaseCollision() {
+    if (!this.app.vault.adapter.insensitive || this.oldPath.toLowerCase() !== this.newPath.toLowerCase()) {
+      return false;
+    }
+    const tempPath = join(dirname(this.newPath), `__temp__${basename(this.newPath)}`);
+    await this.renameHandled(this.newPath, tempPath);
+    await new RenameHandler({
+      abortSignal: this.abortSignal,
+      app: this.app,
+      handledRenames: this.handledRenames,
+      interruptedRenamesMap: this.interruptedRenamesMap,
+      newPath: tempPath,
+      oldCache: this.oldCache,
+      oldPath: this.oldPath,
+      oldPathBacklinksMap: this.oldPathBacklinksMap,
+      settingsManager: this.settingsManager
+    }).handle();
+    await this.app.vault.rename(getFile(this.app, tempPath), this.newPath);
+    return true;
+  }
+  async refreshLinks() {
+    const cache = this.app.metadataCache.getCache(this.oldPath) ?? this.app.metadataCache.getCache(this.newPath);
+    const oldPathLinksRefreshed = cache ? getAllLinks(cache) : [];
+    const fakeOldFile = getFile(this.app, this.oldPath, true);
+    let oldPathBacklinksMapRefreshed = /* @__PURE__ */ new Map();
+    await tempRegisterFilesAndRun(this.app, [fakeOldFile], async () => {
+      oldPathBacklinksMapRefreshed = (await getBacklinksForFileSafe(this.app, fakeOldFile)).data;
+    });
+    for (const link of oldPathLinksRefreshed) {
+      if (this.oldPathLinks.includes(link)) {
+        continue;
+      }
+      this.oldPathLinks.push(link);
+    }
+    for (const [backlinkPath, refreshedLinks] of oldPathBacklinksMapRefreshed.entries()) {
+      let oldLinks = this.oldPathBacklinksMap.get(backlinkPath);
+      if (!oldLinks) {
+        oldLinks = [];
+        this.oldPathBacklinksMap.set(backlinkPath, oldLinks);
+      }
+      for (const link of refreshedLinks) {
+        if (oldLinks.includes(link)) {
+          continue;
+        }
+        oldLinks.push(link);
+      }
+    }
   }
-  if (settings.isPathIgnored?.(newPath)) {
-    getLibDebugger("RenameDeleteHandler:handleRename")(`Skipping rename handler of new path ${newPath} as the path is ignored.`);
-    return;
+  async renameHandled(oldPath, newPath) {
+    newPath = getSafeRenamePath(this.app, oldPath, newPath);
+    if (oldPath === newPath) {
+      return newPath;
+    }
+    this.handledRenames.add(oldPath, newPath);
+    newPath = await renameSafe(this.app, oldPath, newPath);
+    return newPath;
   }
-  const cache = app.metadataCache.getCache(oldPath) ?? app.metadataCache.getCache(newPath);
-  const oldPathLinks = cache ? getAllLinks(cache) : [];
-  const oldPathBacklinksMap = getBacklinksForFileOrPath(app, oldPath).data;
-  addToQueue(app, (abortSignal2) => handleRenameAsync(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks, void 0, abortSignal2), abortSignal);
 }
-async function handleRenameAsync(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks, interruptedCombinedBacklinksMap, abortSignal) {
-  abortSignal ??= abortSignalNever();
-  abortSignal.throwIfAborted();
-  await continueInterruptedRenames(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks);
-  abortSignal.throwIfAborted();
-  await refreshLinks(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks);
-  abortSignal.throwIfAborted();
-  if (await handleCaseCollision(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks)) {
-    return;
-  }
-  abortSignal.throwIfAborted();
-  try {
-    const renameMap = /* @__PURE__ */ new Map();
-    await fillRenameMap(app, oldPath, newPath, renameMap, oldPathLinks, abortSignal);
-    abortSignal.throwIfAborted();
-    const combinedBacklinksMap = /* @__PURE__ */ new Map();
-    initBacklinksMap(oldPathBacklinksMap, renameMap, combinedBacklinksMap, oldPath);
-    for (const attachmentOldPath of renameMap.keys()) {
-      if (attachmentOldPath === oldPath) {
-        continue;
-      }
-      const attachmentOldPathBacklinksMap = (await getBacklinksForFileSafe(app, attachmentOldPath)).data;
-      initBacklinksMap(attachmentOldPathBacklinksMap, renameMap, combinedBacklinksMap, attachmentOldPath);
+class RenameMap {
+  abortSignal;
+  app;
+  map = /* @__PURE__ */ new Map();
+  newPath;
+  oldCache;
+  oldPath;
+  oldPathLinks;
+  settingsManager;
+  constructor(options) {
+    this.abortSignal = options.abortSignal;
+    this.app = options.app;
+    this.settingsManager = options.settingsManager;
+    this.oldCache = options.oldCache;
+    this.oldPath = options.oldPath;
+    this.newPath = options.newPath;
+    this.oldPathLinks = this.oldCache ? getAllLinks(this.oldCache) : [];
+  }
+  entries() {
+    return this.map.entries();
+  }
+  async fill() {
+    this.abortSignal.throwIfAborted();
+    this.map.set(this.oldPath, this.newPath);
+    if (!this.settingsManager.isNoteEx(this.oldPath)) {
+      return;
     }
-    const parentFolderPaths = /* @__PURE__ */ new Set();
-    for (const [oldAttachmentPath, newAttachmentPath] of renameMap.entries()) {
-      if (oldAttachmentPath === oldPath) {
-        continue;
+    const settings = this.settingsManager.getSettings();
+    const oldFile = getFile(this.app, this.oldPath, true);
+    let oldAttachmentFolderPath = "";
+    await tempRegisterFilesAndRunAsync(this.app, [oldFile], async () => {
+      const shouldFakeOldPathCache = this.oldCache && oldFile.deleted;
+      if (shouldFakeOldPathCache) {
+        registerFileCacheForNonExistingFile(this.app, oldFile, this.oldCache);
       }
-      const fixedNewAttachmentPath = await renameHandled(app, oldAttachmentPath, newAttachmentPath);
-      renameMap.set(oldAttachmentPath, fixedNewAttachmentPath);
-      parentFolderPaths.add(dirname(oldAttachmentPath));
-    }
-    await cleanupParentFolders(app, Array.from(parentFolderPaths), oldPath);
-    abortSignal.throwIfAborted();
-    const settings = getSettings(app);
-    for (const [newBacklinkPath, linkJsonToPathMap] of Array.from(combinedBacklinksMap.entries()).concat(
-      Array.from(interruptedCombinedBacklinksMap?.entries() ?? [])
-    )) {
-      await editLinks(app, newBacklinkPath, (link) => {
-        const oldAttachmentPath = linkJsonToPathMap.get(toJson(link));
-        if (!oldAttachmentPath) {
-          return;
+      try {
+        oldAttachmentFolderPath = await getAttachmentFolderPath(this.app, this.oldPath, AttachmentPathContext.RenameNote);
+      } finally {
+        if (shouldFakeOldPathCache) {
+          unregisterFileCacheForNonExistingFile(this.app, oldFile);
         }
-        const newAttachmentPath = renameMap.get(oldAttachmentPath);
-        if (!newAttachmentPath) {
-          return;
+      }
+    });
+    const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder ? await getAttachmentFolderPath(this.app, this.newPath, AttachmentPathContext.RenameNote) : oldAttachmentFolderPath;
+    const isOldAttachmentFolderAtRoot = oldAttachmentFolderPath === "/";
+    const oldAttachmentFolder = getFolderOrNull(this.app, oldAttachmentFolderPath);
+    if (!oldAttachmentFolder) {
+      return;
+    }
+    if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {
+      return;
+    }
+    const oldAttachmentFiles = [];
+    if (await hasOwnAttachmentFolder(this.app, this.oldPath, AttachmentPathContext.RenameNote)) {
+      Vault.recurseChildren(oldAttachmentFolder, (oldAttachmentFile) => {
+        this.abortSignal.throwIfAborted();
+        if (isFile(oldAttachmentFile)) {
+          oldAttachmentFiles.push(oldAttachmentFile);
         }
-        return updateLink(normalizeOptionalProperties({
-          app,
-          link,
-          newSourcePathOrFile: newBacklinkPath,
-          newTargetPathOrFile: newAttachmentPath,
-          oldTargetPathOrFile: oldAttachmentPath,
-          shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases
-        }));
-      }, {
-        shouldFailOnMissingFile: false
       });
-      abortSignal.throwIfAborted();
-    }
-    if (isNoteEx(app, newPath)) {
-      await updateLinksInFile(normalizeOptionalProperties({
-        app,
-        newSourcePathOrFile: newPath,
-        oldSourcePathOrFile: oldPath,
-        shouldFailOnMissingFile: false,
-        shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases
-      }));
-      abortSignal.throwIfAborted();
-    }
-    if (!getFileOrNull(app, newPath)) {
-      let interruptedRenames = interruptedRenamesMap.get(newPath);
-      if (!interruptedRenames) {
-        interruptedRenames = [];
-        interruptedRenamesMap.set(newPath, interruptedRenames);
+    } else {
+      for (const oldPathLink of this.oldPathLinks) {
+        this.abortSignal.throwIfAborted();
+        const oldAttachmentFile = extractLinkFile(this.app, oldPathLink, this.oldPath);
+        if (!oldAttachmentFile) {
+          continue;
+        }
+        if (isOldAttachmentFolderAtRoot || oldAttachmentFile.path.startsWith(oldAttachmentFolderPath)) {
+          const oldAttachmentBacklinks = await getBacklinksForFileSafe(this.app, oldAttachmentFile);
+          this.abortSignal.throwIfAborted();
+          if (oldAttachmentBacklinks.keys().length === 1) {
+            oldAttachmentFiles.push(oldAttachmentFile);
+          }
+        }
       }
-      interruptedRenames.push({
-        combinedBacklinksMap,
-        oldPath
-      });
     }
-  } finally {
-    const orphanKeys = Array.from(handledRenames);
-    addToQueue(app, () => {
-      for (const key of orphanKeys) {
-        handledRenames.delete(key);
+    for (const oldAttachmentFile of oldAttachmentFiles) {
+      this.abortSignal.throwIfAborted();
+      if (this.settingsManager.isNoteEx(oldAttachmentFile.path)) {
+        continue;
       }
-    }, abortSignal);
-  }
-}
-function handleRenameIfEnabled(plugin, file, oldPath, abortSignal) {
-  if (!shouldInvokeHandler(plugin)) {
-    return;
+      let newAttachmentFilePath;
+      if (settings.shouldRenameAttachmentFiles) {
+        newAttachmentFilePath = await getAttachmentFilePath({
+          app: this.app,
+          attachmentPathOrFile: oldAttachmentFile,
+          context: AttachmentPathContext.RenameNote,
+          notePathOrFile: this.newPath,
+          oldNotePathOrFile: this.oldPath,
+          shouldSkipDuplicateCheck: true
+        });
+        this.abortSignal.throwIfAborted();
+      } else {
+        const relativePath = isOldAttachmentFolderAtRoot ? oldAttachmentFile.path : relative(oldAttachmentFolderPath, oldAttachmentFile.path);
+        const newFolder = join(newAttachmentFolderPath, dirname(relativePath));
+        newAttachmentFilePath = join(newFolder, oldAttachmentFile.name);
+      }
+      if (oldAttachmentFile.path === newAttachmentFilePath) {
+        continue;
+      }
+      if (settings.shouldDeleteConflictingAttachments) {
+        const newAttachmentFile = getFileOrNull(this.app, newAttachmentFilePath);
+        if (newAttachmentFile) {
+          getLibDebugger("RenameDeleteHandler:fillRenameMap")(`Removing conflicting attachment ${newAttachmentFile.path}.`);
+          await this.app.fileManager.trashFile(newAttachmentFile);
+          this.abortSignal.throwIfAborted();
+        }
+      } else {
+        const dir = dirname(newAttachmentFilePath);
+        const ext = extname(newAttachmentFilePath);
+        const baseName = basename(newAttachmentFilePath, ext);
+        newAttachmentFilePath = this.app.vault.getAvailablePath(join(dir, baseName), ext.slice(1));
+      }
+      this.map.set(oldAttachmentFile.path, newAttachmentFilePath);
+    }
   }
-  if (!isFile(file)) {
-    return;
+  get(oldPath) {
+    return this.map.get(oldPath);
   }
-  const newPath = file.path;
-  handleRename(plugin.app, oldPath, newPath, abortSignal);
-}
-function initBacklinksMap(singleBacklinksMap, renameMap, combinedBacklinksMap, path) {
-  for (const [backlinkPath, links] of singleBacklinksMap.entries()) {
-    const newBacklinkPath = renameMap.get(backlinkPath) ?? backlinkPath;
-    const linkJsonToPathMap = combinedBacklinksMap.get(newBacklinkPath) ?? /* @__PURE__ */ new Map();
-    combinedBacklinksMap.set(newBacklinkPath, linkJsonToPathMap);
-    for (const link of links) {
-      linkJsonToPathMap.set(toJson(link), path);
+  initBacklinksMap(singleBacklinksMap, combinedBacklinksMap, path) {
+    for (const [backlinkPath, links] of singleBacklinksMap.entries()) {
+      const newBacklinkPath = this.map.get(backlinkPath) ?? backlinkPath;
+      const linkJsonToPathMap = combinedBacklinksMap.get(newBacklinkPath) ?? /* @__PURE__ */ new Map();
+      combinedBacklinksMap.set(newBacklinkPath, linkJsonToPathMap);
+      for (const link of links) {
+        linkJsonToPathMap.set(toJson(link), path);
+      }
     }
   }
+  keys() {
+    return this.map.keys();
+  }
+  set(oldPath, newPath) {
+    this.map.set(oldPath, newPath);
+  }
 }
-function isNoteEx(app, path) {
-  const settings = getSettings(app);
-  return settings.isNote?.(path) ?? false;
-}
-function logRegisteredHandlers(app) {
-  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);
-  getLibDebugger("RenameDeleteHandler:logRegisteredHandlers")(
-    `Plugins with registered rename/delete handlers: ${JSON.stringify(Array.from(renameDeleteHandlersMap.keys()))}`
-  );
-}
-function makeKey(oldPath, newPath) {
-  return `${oldPath} -> ${newPath}`;
-}
-async function refreshLinks(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks) {
-  const cache = app.metadataCache.getCache(oldPath) ?? app.metadataCache.getCache(newPath);
-  const oldPathLinksRefreshed = cache ? getAllLinks(cache) : [];
-  const fakeOldFile = getFile(app, oldPath, true);
-  let oldPathBacklinksMapRefreshed = /* @__PURE__ */ new Map();
-  await tempRegisterFilesAndRun(app, [fakeOldFile], async () => {
-    oldPathBacklinksMapRefreshed = (await getBacklinksForFileSafe(app, fakeOldFile)).data;
-  });
-  for (const link of oldPathLinksRefreshed) {
-    if (oldPathLinks.includes(link)) {
-      continue;
-    }
-    oldPathLinks.push(link);
-  }
-  for (const [backlinkPath, refreshedLinks] of oldPathBacklinksMapRefreshed.entries()) {
-    let oldLinks = oldPathBacklinksMap.get(backlinkPath);
-    if (!oldLinks) {
-      oldLinks = [];
-      oldPathBacklinksMap.set(backlinkPath, oldLinks);
-    }
-    for (const link of refreshedLinks) {
-      if (oldLinks.includes(link)) {
-        continue;
+class SettingsManager {
+  constructor(app) {
+    this.app = app;
+    this.renameDeleteHandlersMap = getObsidianDevUtilsState(app, "renameDeleteHandlersMap", /* @__PURE__ */ new Map()).value;
+  }
+  renameDeleteHandlersMap;
+  getSettings() {
+    const settingsBuilders = Array.from(this.renameDeleteHandlersMap.values()).reverse();
+    const settings = {};
+    settings.isNote = (path) => isNote(this.app, path);
+    settings.isPathIgnored = () => false;
+    for (const settingsBuilder of settingsBuilders) {
+      const newSettings = settingsBuilder();
+      settings.shouldDeleteConflictingAttachments ||= newSettings.shouldDeleteConflictingAttachments ?? false;
+      if (newSettings.emptyAttachmentFolderBehavior) {
+        settings.emptyAttachmentFolderBehavior ??= newSettings.emptyAttachmentFolderBehavior;
       }
-      oldLinks.push(link);
+      settings.shouldHandleDeletions ||= newSettings.shouldHandleDeletions ?? false;
+      settings.shouldHandleRenames ||= newSettings.shouldHandleRenames ?? false;
+      settings.shouldRenameAttachmentFiles ||= newSettings.shouldRenameAttachmentFiles ?? false;
+      settings.shouldRenameAttachmentFolder ||= newSettings.shouldRenameAttachmentFolder ?? false;
+      settings.shouldUpdateFileNameAliases ||= newSettings.shouldUpdateFileNameAliases ?? false;
+      const isPathIgnored = settings.isPathIgnored;
+      settings.isPathIgnored = (path) => isPathIgnored(path) || (newSettings.isPathIgnored?.(path) ?? false);
+      const currentIsNote = settings.isNote;
+      settings.isNote = (path) => currentIsNote(path) && (newSettings.isNote?.(path) ?? true);
     }
+    settings.emptyAttachmentFolderBehavior ??= "Keep" /* Keep */;
+    return settings;
   }
-}
-async function renameHandled(app, oldPath, newPath) {
-  newPath = getSafeRenamePath(app, oldPath, newPath);
-  if (oldPath === newPath) {
-    return newPath;
+  isNoteEx(path) {
+    const settings = this.getSettings();
+    return settings.isNote?.(path) ?? false;
   }
-  const key = makeKey(oldPath, newPath);
-  handledRenames.add(key);
-  newPath = await renameSafe(app, oldPath, newPath);
-  return newPath;
 }
-async function runAsyncLinkUpdate(app, next, linkUpdatesHandler) {
-  await next.call(app.fileManager, wrappedHandler);
-  async function wrappedHandler(linkUpdates) {
-    let isRenameCalled = false;
-    const eventRef = app.vault.on("rename", () => {
-      isRenameCalled = true;
-    });
-    try {
-      await linkUpdatesHandler(linkUpdates);
-    } finally {
-      app.vault.offref(eventRef);
-    }
-    const settings = getSettings(app);
-    if (isRenameCalled && settings.shouldHandleRenames) {
-      filterInPlace(
-        linkUpdates,
-        (linkUpdate) => {
-          if (settings.isPathIgnored?.(linkUpdate.sourceFile.path)) {
-            getLibDebugger("RenameDeleteHandler:runAsyncLinkUpdate")(
-              `Roll back to default link update of source file ${linkUpdate.sourceFile.path} as the path is ignored.`
-            );
-            return true;
-          }
-          if (settings.isPathIgnored?.(linkUpdate.resolvedFile.path)) {
-            getLibDebugger("RenameDeleteHandler:runAsyncLinkUpdate")(
-              `Roll back to default link update of resolved file ${linkUpdate.resolvedFile.path} as the path is ignored.`
-            );
-            return true;
-          }
-          if (!app.internalPlugins.getEnabledPluginById(InternalPluginName.Canvas)) {
-            return false;
-          }
-          if (app.plugins.getPlugin("backlink-cache")) {
-            return false;
-          }
-          if (linkUpdate.sourceFile.extension === "canvas") {
-            return true;
-          }
-          if (linkUpdate.resolvedFile.extension === "canvas") {
-            return true;
-          }
-          return false;
-        }
-      );
+function registerRenameDeleteHandlers(plugin, settingsBuilder) {
+  new Registry(plugin, settingsBuilder, new SettingsManager(plugin.app)).register();
+}
+async function cleanupParentFolders(app, settings, parentFolderPaths, notePath) {
+  if (settings.emptyAttachmentFolderBehavior === "Keep" /* Keep */) {
+    return;
+  }
+  for (const parentFolderPath of parentFolderPaths) {
+    switch (settings.emptyAttachmentFolderBehavior) {
+      case "Delete" /* Delete */:
+        await deleteSafe(app, parentFolderPath, notePath, void 0, true);
+        break;
+      case "DeleteWithEmptyParents" /* DeleteWithEmptyParents */:
+        await deleteEmptyFolderHierarchy(app, parentFolderPath);
+        break;
+      default:
+        break;
     }
   }
 }
-function shouldInvokeHandler(plugin) {
-  const app = plugin.app;
-  const pluginId = plugin.manifest.id;
-  const renameDeleteHandlerPluginIds = getRenameDeleteHandlersMap(app);
-  const mainPluginId = Array.from(renameDeleteHandlerPluginIds.keys())[0];
-  if (mainPluginId !== pluginId) {
-    return false;
-  }
-  return true;
-}
 export {
   EmptyAttachmentFolderBehavior,
   registerRenameDeleteHandlers
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/RenameDeleteHandler.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for handling rename and delete events in Obsidian.\n */\n\nimport type {\n  App,\n  CachedMetadata,\n  FileManager,\n  Plugin,\n  Reference,\n  TAbstractFile,\n  TFile\n} from 'obsidian';\nimport type {\n  LinkUpdate,\n  LinkUpdatesHandler\n} from 'obsidian-typings';\n\nimport { Vault } from 'obsidian';\nimport { InternalPluginName } from 'obsidian-typings/implementations';\n\nimport type {\n  UpdateLinkOptions,\n  UpdateLinksInFileOptions\n} from './Link.ts';\n\nimport { abortSignalNever } from '../AbortController.ts';\nimport { filterInPlace } from '../Array.ts';\nimport { getLibDebugger } from '../Debug.ts';\nimport {\n  normalizeOptionalProperties,\n  toJson\n} from '../ObjectUtils.ts';\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  relative\n} from '../Path.ts';\nimport { getObsidianDevUtilsState } from './App.ts';\nimport {\n  AttachmentPathContext,\n  getAttachmentFilePath,\n  getAttachmentFolderPath,\n  hasOwnAttachmentFolder\n} from './AttachmentPath.ts';\nimport {\n  getFile,\n  getFileOrNull,\n  getFolderOrNull,\n  isFile,\n  isMarkdownFile,\n  isNote\n} from './FileSystem.ts';\nimport {\n  editLinks,\n  extractLinkFile,\n  updateLink,\n  updateLinksInFile\n} from './Link.ts';\nimport {\n  getAllLinks,\n  getBacklinksForFileOrPath,\n  getBacklinksForFileSafe,\n  tempRegisterFilesAndRun\n} from './MetadataCache.ts';\nimport { registerPatch } from './MonkeyAround.ts';\nimport { addToQueue } from './Queue.ts';\nimport {\n  getSafeRenamePath,\n  renameSafe\n} from './Vault.ts';\nimport {\n  deleteEmptyFolderHierarchy,\n  deleteSafe\n} from './VaultEx.ts';\n\nconst deletedMetadataCacheMap = new Map<string, CachedMetadata>();\nconst handledRenames = new Set<string>();\nconst interruptedRenamesMap = new Map<string, InterruptedRename[]>();\n\n/**\n * A behavior of the rename/delete handler when deleting empty attachment folders.\n */\nexport enum EmptyAttachmentFolderBehavior {\n  /**\n   * Delete the empty attachment folder.\n   */\n  Delete = 'Delete',\n\n  /**\n   * Delete the empty attachment folder and all its empty parents.\n   */\n  DeleteWithEmptyParents = 'DeleteWithEmptyParents',\n\n  /**\n   * Keep the empty attachment folder.\n   */\n  Keep = 'Keep'\n}\n\n/**\n * Settings for the rename/delete handler.\n */\nexport interface RenameDeleteHandlerSettings {\n  /**\n   * A behavior of the rename/delete handler when deleting empty attachment folders.\n   */\n  emptyAttachmentFolderBehavior: EmptyAttachmentFolderBehavior;\n\n  /**\n   * Whether the path is a note.\n   */\n  isNote(path: string): boolean;\n\n  /**\n   * Whether to ignore the path.\n   */\n  isPathIgnored(path: string): boolean;\n\n  /**\n   * Whether to delete conflicting attachments.\n   */\n  shouldDeleteConflictingAttachments: boolean;\n\n  /**\n   * Whether to handle deletions.\n   */\n  shouldHandleDeletions: boolean;\n\n  /**\n   * Whether to handle renames.\n   */\n  shouldHandleRenames: 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 file name aliases when a note is renamed.\n   */\n  shouldUpdateFileNameAliases: boolean;\n}\n\ninterface AbortablePlugin extends Plugin {\n  abortSignal?: AbortSignal;\n}\n\ninterface InterruptedRename {\n  combinedBacklinksMap: Map<string, Map<string, string>>;\n  oldPath: string;\n}\n\ntype RunAsyncLinkUpdateFn = FileManager['runAsyncLinkUpdate'];\n\n/**\n * Registers the rename/delete handlers.\n *\n * @param plugin - The plugin instance.\n * @param settingsBuilder - A function that returns the settings for the rename delete handler.\n */\nexport function registerRenameDeleteHandlers(plugin: AbortablePlugin, settingsBuilder: () => Partial<RenameDeleteHandlerSettings>): void {\n  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(plugin.app);\n  const pluginId = plugin.manifest.id;\n\n  renameDeleteHandlersMap.set(pluginId, settingsBuilder);\n  logRegisteredHandlers(plugin.app);\n\n  plugin.register(() => {\n    renameDeleteHandlersMap.delete(pluginId);\n    logRegisteredHandlers(plugin.app);\n  });\n\n  const app = plugin.app;\n  const abortSignal = plugin.abortSignal ?? abortSignalNever();\n\n  plugin.registerEvent(\n    app.vault.on('delete', (file) => {\n      handleDeleteIfEnabled(plugin, file, abortSignal);\n    })\n  );\n\n  plugin.registerEvent(\n    app.vault.on('rename', (file, oldPath) => {\n      handleRenameIfEnabled(plugin, file, oldPath, abortSignal);\n    })\n  );\n\n  plugin.registerEvent(\n    app.metadataCache.on('deleted', (file, prevCache) => {\n      handleMetadataDeletedIfEnabled(plugin, file, prevCache);\n    })\n  );\n\n  registerPatch(plugin, app.fileManager, {\n    runAsyncLinkUpdate: (next: RunAsyncLinkUpdateFn): RunAsyncLinkUpdateFn => {\n      return (linkUpdatesHandler) => runAsyncLinkUpdate(app, next, linkUpdatesHandler);\n    }\n  });\n}\n\nasync function cleanupParentFolders(app: App, parentFolderPaths: string[], notePath: string): Promise<void> {\n  const settings = getSettings(app);\n  if (settings.emptyAttachmentFolderBehavior === EmptyAttachmentFolderBehavior.Keep) {\n    return;\n  }\n  for (const parentFolderPath of parentFolderPaths) {\n    switch (settings.emptyAttachmentFolderBehavior) {\n      case EmptyAttachmentFolderBehavior.Delete:\n        await deleteSafe(app, parentFolderPath, notePath, undefined, true);\n        break;\n      case EmptyAttachmentFolderBehavior.DeleteWithEmptyParents:\n        await deleteEmptyFolderHierarchy(app, parentFolderPath);\n        break;\n      default:\n        break;\n    }\n  }\n}\n\nasync function continueInterruptedRenames(\n  app: App,\n  oldPath: string,\n  newPath: string,\n  oldPathBacklinksMap: Map<string, Reference[]>,\n  oldPathLinks: Reference[]\n): Promise<void> {\n  const interruptedRenames = interruptedRenamesMap.get(oldPath);\n  if (interruptedRenames) {\n    interruptedRenamesMap.delete(oldPath);\n    for (const interruptedRename of interruptedRenames) {\n      await handleRenameAsync(app, interruptedRename.oldPath, newPath, oldPathBacklinksMap, oldPathLinks, interruptedRename.combinedBacklinksMap);\n    }\n  }\n}\n\nasync function fillRenameMap(\n  app: App,\n  oldPath: string,\n  newPath: string,\n  renameMap: Map<string, string>,\n  oldPathLinks: Reference[],\n  abortSignal: AbortSignal\n): Promise<void> {\n  abortSignal.throwIfAborted();\n  renameMap.set(oldPath, newPath);\n\n  if (!isNoteEx(app, oldPath)) {\n    return;\n  }\n\n  const settings = getSettings(app);\n\n  const oldAttachmentFolderPath = await getAttachmentFolderPath(app, oldPath, AttachmentPathContext.RenameNote);\n  const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder\n    ? await getAttachmentFolderPath(app, newPath, AttachmentPathContext.RenameNote)\n    : oldAttachmentFolderPath;\n\n  const isOldAttachmentFolderAtRoot = oldAttachmentFolderPath === '/';\n\n  const oldAttachmentFolder = getFolderOrNull(app, oldAttachmentFolderPath);\n\n  if (!oldAttachmentFolder) {\n    return;\n  }\n\n  if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {\n    return;\n  }\n\n  const oldAttachmentFiles: TFile[] = [];\n\n  if (await hasOwnAttachmentFolder(app, oldPath, AttachmentPathContext.RenameNote)) {\n    Vault.recurseChildren(oldAttachmentFolder, (oldAttachmentFile) => {\n      abortSignal.throwIfAborted();\n      if (isFile(oldAttachmentFile)) {\n        oldAttachmentFiles.push(oldAttachmentFile);\n      }\n    });\n  } else {\n    for (const oldPathLink of oldPathLinks) {\n      abortSignal.throwIfAborted();\n      const oldAttachmentFile = extractLinkFile(app, oldPathLink, oldPath);\n      if (!oldAttachmentFile) {\n        continue;\n      }\n\n      if (isOldAttachmentFolderAtRoot || oldAttachmentFile.path.startsWith(oldAttachmentFolderPath)) {\n        const oldAttachmentBacklinks = await getBacklinksForFileSafe(app, oldAttachmentFile);\n        abortSignal.throwIfAborted();\n        if (oldAttachmentBacklinks.keys().length === 1) {\n          oldAttachmentFiles.push(oldAttachmentFile);\n        }\n      }\n    }\n  }\n\n  for (const oldAttachmentFile of oldAttachmentFiles) {\n    abortSignal.throwIfAborted();\n    if (isNoteEx(app, oldAttachmentFile.path)) {\n      continue;\n    }\n\n    let newAttachmentFilePath: string;\n    if (settings.shouldRenameAttachmentFiles) {\n      newAttachmentFilePath = await getAttachmentFilePath({\n        app,\n        attachmentPathOrFile: oldAttachmentFile,\n        context: AttachmentPathContext.RenameNote,\n        notePathOrFile: newPath,\n        oldNotePathOrFile: oldPath,\n        shouldSkipDuplicateCheck: true\n      });\n      abortSignal.throwIfAborted();\n    } else {\n      const relativePath = isOldAttachmentFolderAtRoot ? oldAttachmentFile.path : relative(oldAttachmentFolderPath, oldAttachmentFile.path);\n      const newFolder = join(newAttachmentFolderPath, dirname(relativePath));\n      newAttachmentFilePath = join(newFolder, oldAttachmentFile.name);\n    }\n\n    if (oldAttachmentFile.path === newAttachmentFilePath) {\n      continue;\n    }\n    if (settings.shouldDeleteConflictingAttachments) {\n      const newAttachmentFile = getFileOrNull(app, newAttachmentFilePath);\n      if (newAttachmentFile) {\n        getLibDebugger('RenameDeleteHandler:fillRenameMap')(`Removing conflicting attachment ${newAttachmentFile.path}.`);\n        await app.fileManager.trashFile(newAttachmentFile);\n        abortSignal.throwIfAborted();\n      }\n    } else {\n      const dir = dirname(newAttachmentFilePath);\n      const ext = extname(newAttachmentFilePath);\n      const baseName = basename(newAttachmentFilePath, ext);\n      newAttachmentFilePath = app.vault.getAvailablePath(join(dir, baseName), ext.slice(1));\n    }\n    renameMap.set(oldAttachmentFile.path, newAttachmentFilePath);\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 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  settings.isNote = (path: string): boolean => isNote(app, path);\n  settings.isPathIgnored = (): boolean => false;\n\n  for (const settingsBuilder of settingsBuilders) {\n    const newSettings = settingsBuilder();\n    settings.shouldDeleteConflictingAttachments ||= newSettings.shouldDeleteConflictingAttachments ?? false;\n    if (newSettings.emptyAttachmentFolderBehavior) {\n      settings.emptyAttachmentFolderBehavior ??= newSettings.emptyAttachmentFolderBehavior;\n    }\n    settings.shouldHandleDeletions ||= newSettings.shouldHandleDeletions ?? false;\n    settings.shouldHandleRenames ||= newSettings.shouldHandleRenames ?? false;\n    settings.shouldRenameAttachmentFiles ||= newSettings.shouldRenameAttachmentFiles ?? false;\n    settings.shouldRenameAttachmentFolder ||= newSettings.shouldRenameAttachmentFolder ?? false;\n    settings.shouldUpdateFileNameAliases ||= newSettings.shouldUpdateFileNameAliases ?? false;\n    const isPathIgnored = settings.isPathIgnored;\n    settings.isPathIgnored = (path: string): boolean => isPathIgnored(path) || (newSettings.isPathIgnored?.(path) ?? false);\n    const currentIsNote = settings.isNote;\n    settings.isNote = (path: string): boolean => currentIsNote(path) && (newSettings.isNote?.(path) ?? true);\n  }\n\n  settings.emptyAttachmentFolderBehavior ??= EmptyAttachmentFolderBehavior.Keep;\n  return settings;\n}\n\nasync function handleCaseCollision(\n  app: App,\n  oldPath: string,\n  newPath: string,\n  oldPathBacklinksMap: Map<string, Reference[]>,\n  oldPathLinks: Reference[]\n): Promise<boolean> {\n  if (!app.vault.adapter.insensitive || oldPath.toLowerCase() !== newPath.toLowerCase()) {\n    return false;\n  }\n\n  const tempPath = join(dirname(newPath), `__temp__${basename(newPath)}`);\n  await renameHandled(app, newPath, tempPath);\n  await handleRenameAsync(app, oldPath, tempPath, oldPathBacklinksMap, oldPathLinks);\n  await app.vault.rename(getFile(app, tempPath), newPath);\n  return true;\n}\n\nasync function handleDelete(app: App, path: string, abortSignal: AbortSignal): Promise<void> {\n  abortSignal.throwIfAborted();\n  getLibDebugger('RenameDeleteHandler:handleDelete')(`Handle Delete ${path}`);\n  if (!isNoteEx(app, path)) {\n    return;\n  }\n\n  const settings = getSettings(app);\n  if (!settings.shouldHandleDeletions) {\n    return;\n  }\n\n  if (settings.isPathIgnored?.(path)) {\n    getLibDebugger('RenameDeleteHandler:handleDelete')(`Skipping delete handler of ${path} as the path is ignored.`);\n    return;\n  }\n\n  const cache = deletedMetadataCacheMap.get(path);\n  deletedMetadataCacheMap.delete(path);\n  const parentFolderPaths = new Set<string>();\n  if (cache) {\n    const links = getAllLinks(cache);\n\n    for (const link of links) {\n      const attachmentFile = extractLinkFile(app, link, path);\n      if (!attachmentFile) {\n        continue;\n      }\n\n      if (isNoteEx(app, attachmentFile.path)) {\n        continue;\n      }\n\n      parentFolderPaths.add(attachmentFile.parent?.path ?? '');\n      await deleteSafe(app, attachmentFile, path, false, settings.emptyAttachmentFolderBehavior !== EmptyAttachmentFolderBehavior.Keep);\n      abortSignal.throwIfAborted();\n    }\n  }\n\n  await cleanupParentFolders(app, Array.from(parentFolderPaths), path);\n  abortSignal.throwIfAborted();\n\n  const attachmentFolderPath = await getAttachmentFolderPath(app, path, AttachmentPathContext.DeleteNote);\n  const attachmentFolder = getFolderOrNull(app, attachmentFolderPath);\n\n  if (!attachmentFolder) {\n    return;\n  }\n\n  if (!(await hasOwnAttachmentFolder(app, path, AttachmentPathContext.DeleteNote))) {\n    return;\n  }\n\n  abortSignal.throwIfAborted();\n\n  await deleteSafe(app, attachmentFolder, path, false, settings.emptyAttachmentFolderBehavior !== EmptyAttachmentFolderBehavior.Keep);\n  abortSignal.throwIfAborted();\n}\n\nfunction handleDeleteIfEnabled(plugin: AbortablePlugin, file: TAbstractFile, abortSignal: AbortSignal): void {\n  const app = plugin.app;\n  if (!shouldInvokeHandler(plugin)) {\n    return;\n  }\n  const path = file.path;\n  addToQueue(app, (abortSignal2) => handleDelete(app, path, abortSignal2), abortSignal);\n}\n\nfunction handleMetadataDeleted(app: App, file: TAbstractFile, prevCache: CachedMetadata | null): void {\n  const settings = getSettings(app);\n  if (settings.isPathIgnored?.(file.path)) {\n    getLibDebugger('RenameDeleteHandler:handleMetadataDeleted')(`Skipping metadata delete handler of ${file.path} as the path is ignored.`);\n    return;\n  }\n\n  if (!settings.shouldHandleDeletions) {\n    return;\n  }\n  if (isMarkdownFile(app, file) && prevCache) {\n    deletedMetadataCacheMap.set(file.path, prevCache);\n  }\n}\n\nfunction handleMetadataDeletedIfEnabled(plugin: Plugin, file: TAbstractFile, prevCache: CachedMetadata | null): void {\n  if (!shouldInvokeHandler(plugin)) {\n    return;\n  }\n  handleMetadataDeleted(plugin.app, file, prevCache);\n}\n\nfunction handleRename(app: App, oldPath: string, newPath: string, abortSignal: AbortSignal): void {\n  const key = makeKey(oldPath, newPath);\n  getLibDebugger('RenameDeleteHandler:handleRename')(`Handle Rename ${key}`);\n  if (handledRenames.has(key)) {\n    handledRenames.delete(key);\n    return;\n  }\n\n  const settings = getSettings(app);\n  if (!settings.shouldHandleRenames) {\n    return;\n  }\n\n  if (settings.isPathIgnored?.(oldPath)) {\n    getLibDebugger('RenameDeleteHandler:handleRename')(`Skipping rename handler of old path ${oldPath} as the path is ignored.`);\n    return;\n  }\n\n  if (settings.isPathIgnored?.(newPath)) {\n    getLibDebugger('RenameDeleteHandler:handleRename')(`Skipping rename handler of new path ${newPath} as the path is ignored.`);\n    return;\n  }\n\n  const cache = app.metadataCache.getCache(oldPath) ?? app.metadataCache.getCache(newPath);\n  const oldPathLinks = cache ? getAllLinks(cache) : [];\n  const oldPathBacklinksMap = getBacklinksForFileOrPath(app, oldPath).data;\n  addToQueue(app, (abortSignal2) => handleRenameAsync(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks, undefined, abortSignal2), abortSignal);\n}\n\nasync function handleRenameAsync(\n  app: App,\n  oldPath: string,\n  newPath: string,\n  oldPathBacklinksMap: Map<string, Reference[]>,\n  oldPathLinks: Reference[],\n  interruptedCombinedBacklinksMap?: Map<string, Map<string, string>>,\n  abortSignal?: AbortSignal\n): Promise<void> {\n  abortSignal ??= abortSignalNever();\n  abortSignal.throwIfAborted();\n  await continueInterruptedRenames(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks);\n  abortSignal.throwIfAborted();\n  await refreshLinks(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks);\n  abortSignal.throwIfAborted();\n  if (await handleCaseCollision(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks)) {\n    return;\n  }\n\n  abortSignal.throwIfAborted();\n\n  try {\n    const renameMap = new Map<string, string>();\n    await fillRenameMap(app, oldPath, newPath, renameMap, oldPathLinks, abortSignal);\n    abortSignal.throwIfAborted();\n\n    const combinedBacklinksMap = new Map<string, Map<string, string>>();\n    initBacklinksMap(oldPathBacklinksMap, renameMap, combinedBacklinksMap, oldPath);\n\n    for (const attachmentOldPath of renameMap.keys()) {\n      if (attachmentOldPath === oldPath) {\n        continue;\n      }\n      const attachmentOldPathBacklinksMap = (await getBacklinksForFileSafe(app, attachmentOldPath)).data;\n      initBacklinksMap(attachmentOldPathBacklinksMap, renameMap, combinedBacklinksMap, attachmentOldPath);\n    }\n\n    const parentFolderPaths = new Set<string>();\n\n    for (const [oldAttachmentPath, newAttachmentPath] of renameMap.entries()) {\n      if (oldAttachmentPath === oldPath) {\n        continue;\n      }\n      const fixedNewAttachmentPath = await renameHandled(app, oldAttachmentPath, newAttachmentPath);\n      renameMap.set(oldAttachmentPath, fixedNewAttachmentPath);\n      parentFolderPaths.add(dirname(oldAttachmentPath));\n    }\n\n    await cleanupParentFolders(app, Array.from(parentFolderPaths), oldPath);\n    abortSignal.throwIfAborted();\n    const settings = getSettings(app);\n\n    for (\n      const [newBacklinkPath, linkJsonToPathMap] of Array.from(combinedBacklinksMap.entries()).concat(\n        Array.from(interruptedCombinedBacklinksMap?.entries() ?? [])\n      )\n    ) {\n      await editLinks(app, newBacklinkPath, (link) => {\n        const oldAttachmentPath = linkJsonToPathMap.get(toJson(link));\n        if (!oldAttachmentPath) {\n          return;\n        }\n\n        const newAttachmentPath = renameMap.get(oldAttachmentPath);\n        if (!newAttachmentPath) {\n          return;\n        }\n\n        return updateLink(normalizeOptionalProperties<UpdateLinkOptions>({\n          app,\n          link,\n          newSourcePathOrFile: newBacklinkPath,\n          newTargetPathOrFile: newAttachmentPath,\n          oldTargetPathOrFile: oldAttachmentPath,\n          shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases\n        }));\n      }, {\n        shouldFailOnMissingFile: false\n      });\n      abortSignal.throwIfAborted();\n    }\n\n    if (isNoteEx(app, newPath)) {\n      await updateLinksInFile(normalizeOptionalProperties<UpdateLinksInFileOptions>({\n        app,\n        newSourcePathOrFile: newPath,\n        oldSourcePathOrFile: oldPath,\n        shouldFailOnMissingFile: false,\n        shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases\n      }));\n      abortSignal.throwIfAborted();\n    }\n\n    if (!getFileOrNull(app, newPath)) {\n      let interruptedRenames = interruptedRenamesMap.get(newPath);\n      if (!interruptedRenames) {\n        interruptedRenames = [];\n        interruptedRenamesMap.set(newPath, interruptedRenames);\n      }\n      interruptedRenames.push({\n        combinedBacklinksMap,\n        oldPath\n      });\n    }\n  } finally {\n    const orphanKeys = Array.from(handledRenames);\n    addToQueue(app, () => {\n      for (const key of orphanKeys) {\n        handledRenames.delete(key);\n      }\n    }, abortSignal);\n  }\n}\n\nfunction handleRenameIfEnabled(plugin: Plugin, file: TAbstractFile, oldPath: string, abortSignal: AbortSignal): void {\n  if (!shouldInvokeHandler(plugin)) {\n    return;\n  }\n  if (!isFile(file)) {\n    return;\n  }\n  const newPath = file.path;\n  handleRename(plugin.app, oldPath, newPath, abortSignal);\n}\n\nfunction initBacklinksMap(\n  singleBacklinksMap: Map<string, Reference[]>,\n  renameMap: Map<string, string>,\n  combinedBacklinksMap: Map<string, Map<string, string>>,\n  path: string\n): void {\n  for (const [backlinkPath, links] of singleBacklinksMap.entries()) {\n    const newBacklinkPath = renameMap.get(backlinkPath) ?? backlinkPath;\n    const linkJsonToPathMap = combinedBacklinksMap.get(newBacklinkPath) ?? new Map<string, string>();\n    combinedBacklinksMap.set(newBacklinkPath, linkJsonToPathMap);\n    for (const link of links) {\n      linkJsonToPathMap.set(toJson(link), path);\n    }\n  }\n}\n\nfunction isNoteEx(app: App, path: string): boolean {\n  const settings = getSettings(app);\n  return settings.isNote?.(path) ?? false;\n}\n\nfunction logRegisteredHandlers(app: App): void {\n  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);\n  getLibDebugger('RenameDeleteHandler:logRegisteredHandlers')(\n    `Plugins with registered rename/delete handlers: ${JSON.stringify(Array.from(renameDeleteHandlersMap.keys()))}`\n  );\n}\n\nfunction makeKey(oldPath: string, newPath: string): string {\n  return `${oldPath} -> ${newPath}`;\n}\n\nasync function refreshLinks(\n  app: App,\n  oldPath: string,\n  newPath: string,\n  oldPathBacklinksMap: Map<string, Reference[]>,\n  oldPathLinks: Reference[]\n): Promise<void> {\n  const cache = app.metadataCache.getCache(oldPath) ?? app.metadataCache.getCache(newPath);\n  const oldPathLinksRefreshed = cache ? getAllLinks(cache) : [];\n  const fakeOldFile = getFile(app, oldPath, true);\n  let oldPathBacklinksMapRefreshed = new Map<string, Reference[]>();\n  await tempRegisterFilesAndRun(app, [fakeOldFile], async () => {\n    oldPathBacklinksMapRefreshed = (await getBacklinksForFileSafe(app, fakeOldFile)).data;\n  });\n\n  for (const link of oldPathLinksRefreshed) {\n    if (oldPathLinks.includes(link)) {\n      continue;\n    }\n    oldPathLinks.push(link);\n  }\n\n  for (const [backlinkPath, refreshedLinks] of oldPathBacklinksMapRefreshed.entries()) {\n    let oldLinks = oldPathBacklinksMap.get(backlinkPath);\n    if (!oldLinks) {\n      oldLinks = [];\n      oldPathBacklinksMap.set(backlinkPath, oldLinks);\n    }\n\n    for (const link of refreshedLinks) {\n      if (oldLinks.includes(link)) {\n        continue;\n      }\n      oldLinks.push(link);\n    }\n  }\n}\n\nasync function renameHandled(app: App, oldPath: string, newPath: string): Promise<string> {\n  newPath = getSafeRenamePath(app, oldPath, newPath);\n  if (oldPath === newPath) {\n    return newPath;\n  }\n  const key = makeKey(oldPath, newPath);\n  handledRenames.add(key);\n  newPath = await renameSafe(app, oldPath, newPath);\n  return newPath;\n}\n\nasync function runAsyncLinkUpdate(app: App, next: RunAsyncLinkUpdateFn, linkUpdatesHandler: LinkUpdatesHandler): Promise<void> {\n  await next.call(app.fileManager, wrappedHandler);\n\n  async function wrappedHandler(linkUpdates: LinkUpdate[]): Promise<void> {\n    let isRenameCalled = false;\n    const eventRef = app.vault.on('rename', () => {\n      isRenameCalled = true;\n    });\n    try {\n      await linkUpdatesHandler(linkUpdates);\n    } finally {\n      app.vault.offref(eventRef);\n    }\n    const settings = getSettings(app);\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    if (isRenameCalled && settings.shouldHandleRenames) {\n      filterInPlace(\n        linkUpdates,\n        (linkUpdate) => {\n          if (settings.isPathIgnored?.(linkUpdate.sourceFile.path)) {\n            getLibDebugger('RenameDeleteHandler:runAsyncLinkUpdate')(\n              `Roll back to default link update of source file ${linkUpdate.sourceFile.path} as the path is ignored.`\n            );\n            return true;\n          }\n\n          if (settings.isPathIgnored?.(linkUpdate.resolvedFile.path)) {\n            getLibDebugger('RenameDeleteHandler:runAsyncLinkUpdate')(\n              `Roll back to default link update of resolved file ${linkUpdate.resolvedFile.path} as the path is ignored.`\n            );\n            return true;\n          }\n\n          if (!app.internalPlugins.getEnabledPluginById(InternalPluginName.Canvas)) {\n            return false;\n          }\n\n          if (app.plugins.getPlugin('backlink-cache')) {\n            return false;\n          }\n\n          if (linkUpdate.sourceFile.extension === 'canvas') {\n            return true;\n          }\n\n          if (linkUpdate.resolvedFile.extension === 'canvas') {\n            return true;\n          }\n\n          return false;\n        }\n      );\n    }\n  }\n}\n\nfunction shouldInvokeHandler(plugin: Plugin): boolean {\n  const app = plugin.app;\n  const pluginId = plugin.manifest.id;\n\n  const renameDeleteHandlerPluginIds = getRenameDeleteHandlersMap(app);\n  const mainPluginId = Array.from(renameDeleteHandlerPluginIds.keys())[0];\n  if (mainPluginId !== pluginId) {\n    return false;\n  }\n  return true;\n}\n"],
  "mappings": "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",
  "names": ["EmptyAttachmentFolderBehavior"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/RenameDeleteHandler.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for handling rename and delete events in Obsidian.\n */\n\nimport type {\n  App,\n  CachedMetadata,\n  FileManager,\n  Plugin,\n  Reference,\n  TAbstractFile,\n  TFile\n} from 'obsidian';\nimport type {\n  LinkUpdate,\n  LinkUpdatesHandler\n} from 'obsidian-typings';\n\nimport { Vault } from 'obsidian';\nimport { InternalPluginName } from 'obsidian-typings/implementations';\n\nimport type {\n  UpdateLinkOptions,\n  UpdateLinksInFileOptions\n} from './Link.ts';\n\nimport { abortSignalNever } from '../AbortController.ts';\nimport { filterInPlace } from '../Array.ts';\nimport { getLibDebugger } from '../Debug.ts';\nimport {\n  normalizeOptionalProperties,\n  toJson\n} from '../ObjectUtils.ts';\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  relative\n} from '../Path.ts';\nimport { getObsidianDevUtilsState } from './App.ts';\nimport {\n  AttachmentPathContext,\n  getAttachmentFilePath,\n  getAttachmentFolderPath,\n  hasOwnAttachmentFolder\n} from './AttachmentPath.ts';\nimport {\n  CANVAS_FILE_EXTENSION,\n  getFile,\n  getFileOrNull,\n  getFolderOrNull,\n  isFile,\n  isMarkdownFile,\n  isNote\n} from './FileSystem.ts';\nimport {\n  editLinks,\n  extractLinkFile,\n  updateLink,\n  updateLinksInFile\n} from './Link.ts';\nimport {\n  getAllLinks,\n  getBacklinksForFileOrPath,\n  getBacklinksForFileSafe,\n  registerFileCacheForNonExistingFile,\n  tempRegisterFilesAndRun,\n  tempRegisterFilesAndRunAsync,\n  unregisterFileCacheForNonExistingFile\n} from './MetadataCache.ts';\nimport { registerPatch } from './MonkeyAround.ts';\nimport { addToQueue } from './Queue.ts';\nimport {\n  getSafeRenamePath,\n  renameSafe\n} from './Vault.ts';\nimport {\n  deleteEmptyFolderHierarchy,\n  deleteSafe\n} from './VaultEx.ts';\n\n/**\n * A behavior of the rename/delete handler when deleting empty attachment folders.\n */\nexport enum EmptyAttachmentFolderBehavior {\n  /**\n   * Delete the empty attachment folder.\n   */\n  Delete = 'Delete',\n\n  /**\n   * Delete the empty attachment folder and all its empty parents.\n   */\n  DeleteWithEmptyParents = 'DeleteWithEmptyParents',\n\n  /**\n   * Keep the empty attachment folder.\n   */\n  Keep = 'Keep'\n}\n\n/**\n * Settings for the rename/delete handler.\n */\nexport interface RenameDeleteHandlerSettings {\n  /**\n   * A behavior of the rename/delete handler when deleting empty attachment folders.\n   */\n  emptyAttachmentFolderBehavior: EmptyAttachmentFolderBehavior;\n\n  /**\n   * Whether the path is a note.\n   */\n  isNote(path: string): boolean;\n\n  /**\n   * Whether to ignore the path.\n   */\n  isPathIgnored(path: string): boolean;\n\n  /**\n   * Whether to delete conflicting attachments.\n   */\n  shouldDeleteConflictingAttachments: boolean;\n\n  /**\n   * Whether to handle deletions.\n   */\n  shouldHandleDeletions: boolean;\n\n  /**\n   * Whether to handle renames.\n   */\n  shouldHandleRenames: 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 file name aliases when a note is renamed.\n   */\n  shouldUpdateFileNameAliases: boolean;\n}\n\ninterface AbortablePlugin extends Plugin {\n  abortSignal?: AbortSignal;\n}\n\ninterface HandledRenameKey {\n  newPath: string;\n  oldPath: string;\n}\n\ninterface InterruptedRename {\n  combinedBacklinksMap: Map<string, Map<string, string>>;\n  oldPath: string;\n}\n\ninterface RenameHandlerOptions {\n  abortSignal: AbortSignal;\n  app: App;\n  handledRenames: HandledRenames;\n  interruptedCombinedBacklinksMap?: Map<string, Map<string, string>>;\n  interruptedRenamesMap: Map<string, InterruptedRename[]>;\n  newPath: string;\n  oldCache: CachedMetadata | null;\n  oldPath: string;\n  oldPathBacklinksMap: Map<string, Reference[]>;\n  settingsManager: SettingsManager;\n}\n\ninterface RenameMapOptions {\n  abortSignal: AbortSignal;\n  app: App;\n  newPath: string;\n  oldCache: CachedMetadata | null;\n  oldPath: string;\n  settingsManager: SettingsManager;\n}\n\ntype RunAsyncLinkUpdateFn = { renameDeleteHandlerPatched?: boolean } & FileManager['runAsyncLinkUpdate'];\n\nclass DeleteHandler {\n  public constructor(\n    private readonly app: App,\n    private readonly file: TAbstractFile,\n    private readonly abortSignal: AbortSignal,\n    private readonly settingsManager: SettingsManager,\n    private readonly deletedMetadataCacheMap: Map<string, CachedMetadata>\n  ) {\n  }\n\n  public async handle(): Promise<void> {\n    this.abortSignal.throwIfAborted();\n    getLibDebugger('RenameDeleteHandler:handleDelete')(`Handle Delete ${this.file.path}`);\n    if (!this.settingsManager.isNoteEx(this.file.path)) {\n      return;\n    }\n\n    const settings = this.settingsManager.getSettings();\n    if (!settings.shouldHandleDeletions) {\n      return;\n    }\n\n    if (settings.isPathIgnored?.(this.file.path)) {\n      getLibDebugger('RenameDeleteHandler:handleDelete')(`Skipping delete handler of ${this.file.path} as the path is ignored.`);\n      return;\n    }\n\n    const cache = this.deletedMetadataCacheMap.get(this.file.path);\n    this.deletedMetadataCacheMap.delete(this.file.path);\n    const parentFolderPaths = new Set<string>();\n    if (cache) {\n      const links = getAllLinks(cache);\n\n      for (const link of links) {\n        const attachmentFile = extractLinkFile(this.app, link, this.file.path);\n        if (!attachmentFile) {\n          continue;\n        }\n\n        if (this.settingsManager.isNoteEx(attachmentFile.path)) {\n          continue;\n        }\n\n        parentFolderPaths.add(attachmentFile.parent?.path ?? '');\n        await deleteSafe(this.app, attachmentFile, this.file.path, false, settings.emptyAttachmentFolderBehavior !== EmptyAttachmentFolderBehavior.Keep);\n      }\n    }\n\n    await cleanupParentFolders(this.app, this.settingsManager.getSettings(), Array.from(parentFolderPaths), this.file.path);\n    this.abortSignal.throwIfAborted();\n\n    const attachmentFolderPath = await getAttachmentFolderPath(this.app, this.file.path, AttachmentPathContext.DeleteNote);\n    const attachmentFolder = getFolderOrNull(this.app, attachmentFolderPath);\n\n    if (!attachmentFolder) {\n      return;\n    }\n\n    if (!(await hasOwnAttachmentFolder(this.app, this.file.path, AttachmentPathContext.DeleteNote))) {\n      return;\n    }\n\n    this.abortSignal.throwIfAborted();\n\n    await deleteSafe(this.app, attachmentFolder, this.file.path, false, settings.emptyAttachmentFolderBehavior !== EmptyAttachmentFolderBehavior.Keep);\n    this.abortSignal.throwIfAborted();\n  }\n}\n\nclass HandledRenames {\n  private readonly map = new Map<string, HandledRenameKey>();\n\n  public add(oldPath: string, newPath: string): void {\n    this.map.set(this.keyToString(oldPath, newPath), { newPath, oldPath });\n  }\n\n  public delete(oldPath: string, newPath: string): void {\n    this.map.delete(this.keyToString(oldPath, newPath));\n  }\n\n  public has(oldPath: string, newPath: string): boolean {\n    return this.map.has(this.keyToString(oldPath, newPath));\n  }\n\n  public keys(): IterableIterator<HandledRenameKey> {\n    return this.map.values();\n  }\n\n  private keyToString(oldPath: string, newPath: string): string {\n    return `${oldPath} -> ${newPath}`;\n  }\n}\n\nclass MetadataDeletedHandler {\n  public constructor(\n    private readonly app: App,\n    private readonly file: TAbstractFile,\n    private readonly prevCache: CachedMetadata | null,\n    private readonly settingsManager: SettingsManager,\n    private readonly deletedMetadataCacheMap: Map<string, CachedMetadata>\n  ) {\n  }\n\n  public handle(): void {\n    const settings = this.settingsManager.getSettings();\n\n    if (!settings.shouldHandleDeletions) {\n      return;\n    }\n\n    if (settings.isPathIgnored?.(this.file.path)) {\n      getLibDebugger('RenameDeleteHandler:handleMetadataDeleted')(`Skipping metadata delete handler of ${this.file.path} as the path is ignored.`);\n      return;\n    }\n\n    if (isMarkdownFile(this.app, this.file) && this.prevCache) {\n      this.deletedMetadataCacheMap.set(this.file.path, this.prevCache);\n    }\n  }\n}\n\nclass Registry {\n  private readonly abortSignal: AbortSignal;\n  private readonly app: App;\n  private readonly deletedMetadataCacheMap = new Map<string, CachedMetadata>();\n  private readonly handledRenames = new HandledRenames();\n  private readonly interruptedRenamesMap = new Map<string, InterruptedRename[]>();\n  private readonly pluginId: string;\n\n  public constructor(\n    private readonly plugin: AbortablePlugin,\n    private readonly settingsBuilder: () => Partial<RenameDeleteHandlerSettings>,\n    private readonly settingsManager: SettingsManager\n  ) {\n    this.app = plugin.app;\n    this.pluginId = plugin.manifest.id;\n    this.abortSignal = plugin.abortSignal ?? abortSignalNever();\n  }\n\n  public register(): void {\n    const renameDeleteHandlersMap = this.settingsManager.renameDeleteHandlersMap;\n\n    renameDeleteHandlersMap.set(this.pluginId, this.settingsBuilder);\n    this.logRegisteredHandlers();\n\n    this.plugin.register(() => {\n      renameDeleteHandlersMap.delete(this.pluginId);\n      this.logRegisteredHandlers();\n    });\n\n    this.plugin.registerEvent(this.app.vault.on('delete', this.handleDelete.bind(this)));\n    this.plugin.registerEvent(this.app.vault.on('rename', this.handleRename.bind(this)));\n    this.plugin.registerEvent(this.app.metadataCache.on('deleted', this.handleMetadataDeleted.bind(this)));\n\n    registerPatch(this.plugin, this.app.fileManager, {\n      runAsyncLinkUpdate: (next: RunAsyncLinkUpdateFn): RunAsyncLinkUpdateFn => {\n        return Object.assign((linkUpdatesHandler) => this.runAsyncLinkUpdate(next, linkUpdatesHandler), { renameDeleteHandlerPatched: true });\n      }\n    });\n  }\n\n  private handleDelete(file: TAbstractFile): void {\n    if (!this.shouldInvokeHandler()) {\n      return;\n    }\n    addToQueue(\n      this.app,\n      (abortSignal) => new DeleteHandler(this.app, file, abortSignal, this.settingsManager, this.deletedMetadataCacheMap).handle(),\n      this.abortSignal\n    );\n  }\n\n  private handleMetadataDeleted(file: TAbstractFile, prevCache: CachedMetadata | null): void {\n    if (!this.shouldInvokeHandler()) {\n      return;\n    }\n    addToQueue(this.app, () => {\n      new MetadataDeletedHandler(this.app, file, prevCache, this.settingsManager, this.deletedMetadataCacheMap).handle();\n    }, this.abortSignal);\n  }\n\n  private handleRename(file: TAbstractFile, oldPath: string): void {\n    if (!this.shouldInvokeHandler()) {\n      return;\n    }\n\n    if (!isFile(file)) {\n      return;\n    }\n\n    const newPath = file.path;\n\n    getLibDebugger('RenameDeleteHandler:handleRename')(`Handle Rename ${oldPath} -> ${newPath}`);\n    if (this.handledRenames.has(oldPath, newPath)) {\n      this.handledRenames.delete(oldPath, newPath);\n      return;\n    }\n\n    const settings = this.settingsManager.getSettings();\n    if (!settings.shouldHandleRenames) {\n      return;\n    }\n\n    if (settings.isPathIgnored?.(oldPath)) {\n      getLibDebugger('RenameDeleteHandler:handleRename')(`Skipping rename handler of old path ${oldPath} as the path is ignored.`);\n      return;\n    }\n\n    if (settings.isPathIgnored?.(newPath)) {\n      getLibDebugger('RenameDeleteHandler:handleRename')(`Skipping rename handler of new path ${newPath} as the path is ignored.`);\n      return;\n    }\n\n    const oldCache = this.app.metadataCache.getCache(oldPath) ?? this.app.metadataCache.getCache(newPath);\n    const oldPathBacklinksMap = getBacklinksForFileOrPath(this.app, oldPath).data;\n    addToQueue(this.app, (abortSignal) =>\n      new RenameHandler({\n        abortSignal,\n        app: this.app,\n        handledRenames: this.handledRenames,\n        interruptedRenamesMap: this.interruptedRenamesMap,\n        newPath,\n        oldCache,\n        oldPath,\n        oldPathBacklinksMap,\n        settingsManager: this.settingsManager\n      }).handle(), this.abortSignal);\n  }\n\n  private logRegisteredHandlers(): void {\n    const renameDeleteHandlersMap = this.settingsManager.renameDeleteHandlersMap;\n    getLibDebugger('RenameDeleteHandler:logRegisteredHandlers')(\n      `Plugins with registered rename/delete handlers: ${JSON.stringify(Array.from(renameDeleteHandlersMap.keys()))}`\n    );\n  }\n\n  private async runAsyncLinkUpdate(next: RunAsyncLinkUpdateFn, linkUpdatesHandler: LinkUpdatesHandler): Promise<void> {\n    if (next.renameDeleteHandlerPatched) {\n      await next.call(this.app.fileManager, linkUpdatesHandler);\n      return;\n    }\n    await next.call(this.app.fileManager, (linkUpdates) => this.wrapLinkUpdatesHandler(linkUpdates, linkUpdatesHandler));\n  }\n\n  private shouldInvokeHandler(): boolean {\n    const pluginId = this.plugin.manifest.id;\n\n    const renameDeleteHandlersMap = this.settingsManager.renameDeleteHandlersMap;\n    const mainPluginId = Array.from(renameDeleteHandlersMap.keys())[0];\n    return mainPluginId === pluginId;\n  }\n\n  private async wrapLinkUpdatesHandler(linkUpdates: LinkUpdate[], linkUpdatesHandler: LinkUpdatesHandler): Promise<void> {\n    let isRenameCalled = false;\n    const eventRef = this.app.vault.on('rename', () => {\n      isRenameCalled = true;\n    });\n    try {\n      await linkUpdatesHandler(linkUpdates);\n    } finally {\n      this.app.vault.offref(eventRef);\n    }\n    const settings = this.settingsManager.getSettings();\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    if (!isRenameCalled || !settings.shouldHandleRenames) {\n      return;\n    }\n\n    filterInPlace(\n      linkUpdates,\n      (linkUpdate) => {\n        if (settings.isPathIgnored?.(linkUpdate.sourceFile.path)) {\n          getLibDebugger('RenameDeleteHandler:runAsyncLinkUpdate')(\n            `Roll back to default link update of source file ${linkUpdate.sourceFile.path} as the path is ignored.`\n          );\n          return true;\n        }\n\n        if (settings.isPathIgnored?.(linkUpdate.resolvedFile.path)) {\n          getLibDebugger('RenameDeleteHandler:runAsyncLinkUpdate')(\n            `Roll back to default link update of resolved file ${linkUpdate.resolvedFile.path} as the path is ignored.`\n          );\n          return true;\n        }\n\n        if (!this.app.internalPlugins.getEnabledPluginById(InternalPluginName.Canvas)) {\n          return false;\n        }\n\n        if (this.app.plugins.getPlugin('backlink-cache')) {\n          return false;\n        }\n\n        if (linkUpdate.sourceFile.extension === CANVAS_FILE_EXTENSION) {\n          return true;\n        }\n\n        if (linkUpdate.resolvedFile.extension === CANVAS_FILE_EXTENSION) {\n          return true;\n        }\n\n        return false;\n      }\n    );\n  }\n}\n\nclass RenameHandler {\n  private readonly abortSignal: AbortSignal;\n  private readonly app: App;\n  private readonly handledRenames: HandledRenames;\n  private readonly interruptedCombinedBacklinksMap: Map<string, Map<string, string>>;\n  private readonly interruptedRenamesMap: Map<string, InterruptedRename[]>;\n  private readonly newPath: string;\n  private readonly oldCache: CachedMetadata | null;\n  private readonly oldPath: string;\n  private readonly oldPathBacklinksMap: Map<string, Reference[]>;\n  private readonly oldPathLinks: Reference[];\n  private readonly settingsManager: SettingsManager;\n\n  public constructor(options: RenameHandlerOptions) {\n    this.app = options.app;\n    this.oldPath = options.oldPath;\n    this.newPath = options.newPath;\n    this.oldPathBacklinksMap = options.oldPathBacklinksMap;\n    this.oldCache = options.oldCache;\n    this.abortSignal = options.abortSignal;\n    this.settingsManager = options.settingsManager;\n    this.interruptedRenamesMap = options.interruptedRenamesMap;\n    this.oldPathLinks = this.oldCache ? getAllLinks(this.oldCache) : [];\n    this.handledRenames = options.handledRenames;\n    this.interruptedCombinedBacklinksMap = options.interruptedCombinedBacklinksMap ?? new Map<string, Map<string, string>>();\n  }\n\n  public async handle(): Promise<void> {\n    this.abortSignal.throwIfAborted();\n    await this.continueInterruptedRenames();\n    this.abortSignal.throwIfAborted();\n    await this.refreshLinks();\n    this.abortSignal.throwIfAborted();\n    if (await this.handleCaseCollision()) {\n      return;\n    }\n\n    this.abortSignal.throwIfAborted();\n\n    try {\n      const renameMap = new RenameMap({\n        abortSignal: this.abortSignal,\n        app: this.app,\n        newPath: this.newPath,\n        oldCache: this.oldCache,\n        oldPath: this.oldPath,\n        settingsManager: this.settingsManager\n      });\n      await renameMap.fill();\n      this.abortSignal.throwIfAborted();\n\n      const combinedBacklinksMap = new Map<string, Map<string, string>>();\n      renameMap.initBacklinksMap(this.oldPathBacklinksMap, combinedBacklinksMap, this.oldPath);\n\n      for (const attachmentOldPath of renameMap.keys()) {\n        if (attachmentOldPath === this.oldPath) {\n          continue;\n        }\n        const attachmentOldPathBacklinksMap = (await getBacklinksForFileSafe(this.app, attachmentOldPath)).data;\n        this.abortSignal.throwIfAborted();\n        renameMap.initBacklinksMap(attachmentOldPathBacklinksMap, combinedBacklinksMap, attachmentOldPath);\n      }\n\n      const parentFolderPaths = new Set<string>();\n\n      for (const [oldAttachmentPath, newAttachmentPath] of renameMap.entries()) {\n        if (oldAttachmentPath === this.oldPath) {\n          continue;\n        }\n        const fixedNewAttachmentPath = await this.renameHandled(oldAttachmentPath, newAttachmentPath);\n        this.abortSignal.throwIfAborted();\n        renameMap.set(oldAttachmentPath, fixedNewAttachmentPath);\n        parentFolderPaths.add(dirname(oldAttachmentPath));\n      }\n\n      await cleanupParentFolders(this.app, this.settingsManager.getSettings(), Array.from(parentFolderPaths), this.oldPath);\n      this.abortSignal.throwIfAborted();\n      const settings = this.settingsManager.getSettings();\n\n      for (\n        const [newBacklinkPath, linkJsonToPathMap] of Array.from(combinedBacklinksMap.entries()).concat(\n          Array.from(this.interruptedCombinedBacklinksMap.entries())\n        )\n      ) {\n        await editLinks(this.app, newBacklinkPath, (link) => {\n          const oldAttachmentPath = linkJsonToPathMap.get(toJson(link));\n          if (!oldAttachmentPath) {\n            return;\n          }\n\n          const newAttachmentPath = renameMap.get(oldAttachmentPath);\n          if (!newAttachmentPath) {\n            return;\n          }\n\n          return updateLink(normalizeOptionalProperties<UpdateLinkOptions>({\n            app: this.app,\n            link,\n            newSourcePathOrFile: newBacklinkPath,\n            newTargetPathOrFile: newAttachmentPath,\n            oldTargetPathOrFile: oldAttachmentPath,\n            shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases\n          }));\n        }, {\n          shouldFailOnMissingFile: false\n        });\n        this.abortSignal.throwIfAborted();\n      }\n\n      if (this.settingsManager.isNoteEx(this.newPath)) {\n        await updateLinksInFile(normalizeOptionalProperties<UpdateLinksInFileOptions>({\n          app: this.app,\n          newSourcePathOrFile: this.newPath,\n          oldSourcePathOrFile: this.oldPath,\n          shouldFailOnMissingFile: false,\n          shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases\n        }));\n        this.abortSignal.throwIfAborted();\n      }\n\n      if (!getFileOrNull(this.app, this.newPath)) {\n        let interruptedRenames = this.interruptedRenamesMap.get(this.newPath);\n        if (!interruptedRenames) {\n          interruptedRenames = [];\n          this.interruptedRenamesMap.set(this.newPath, interruptedRenames);\n        }\n        interruptedRenames.push({\n          combinedBacklinksMap,\n          oldPath: this.oldPath\n        });\n      }\n    } finally {\n      const orphanKeys = Array.from(this.handledRenames.keys());\n      addToQueue(this.app, () => {\n        for (const orphanKey of orphanKeys) {\n          this.handledRenames.delete(orphanKey.oldPath, orphanKey.newPath);\n        }\n      }, this.abortSignal);\n    }\n  }\n\n  private async continueInterruptedRenames(): Promise<void> {\n    const interruptedRenames = this.interruptedRenamesMap.get(this.oldPath);\n    if (interruptedRenames) {\n      this.interruptedRenamesMap.delete(this.oldPath);\n      for (const interruptedRename of interruptedRenames) {\n        await new RenameHandler({\n          abortSignal: this.abortSignal,\n          app: this.app,\n          handledRenames: this.handledRenames,\n          interruptedCombinedBacklinksMap: interruptedRename.combinedBacklinksMap,\n          interruptedRenamesMap: this.interruptedRenamesMap,\n          newPath: this.newPath,\n          oldCache: this.oldCache,\n          oldPath: interruptedRename.oldPath,\n          oldPathBacklinksMap: this.oldPathBacklinksMap,\n          settingsManager: this.settingsManager\n        }).handle();\n      }\n    }\n  }\n\n  private async handleCaseCollision(): Promise<boolean> {\n    if (!this.app.vault.adapter.insensitive || this.oldPath.toLowerCase() !== this.newPath.toLowerCase()) {\n      return false;\n    }\n\n    const tempPath = join(dirname(this.newPath), `__temp__${basename(this.newPath)}`);\n    await this.renameHandled(this.newPath, tempPath);\n\n    await new RenameHandler({\n      abortSignal: this.abortSignal,\n      app: this.app,\n      handledRenames: this.handledRenames,\n      interruptedRenamesMap: this.interruptedRenamesMap,\n      newPath: tempPath,\n      oldCache: this.oldCache,\n      oldPath: this.oldPath,\n      oldPathBacklinksMap: this.oldPathBacklinksMap,\n      settingsManager: this.settingsManager\n    }).handle();\n\n    await this.app.vault.rename(getFile(this.app, tempPath), this.newPath);\n    return true;\n  }\n\n  private async refreshLinks(): Promise<void> {\n    const cache = this.app.metadataCache.getCache(this.oldPath) ?? this.app.metadataCache.getCache(this.newPath);\n    const oldPathLinksRefreshed = cache ? getAllLinks(cache) : [];\n    const fakeOldFile = getFile(this.app, this.oldPath, true);\n    let oldPathBacklinksMapRefreshed = new Map<string, Reference[]>();\n    await tempRegisterFilesAndRun(this.app, [fakeOldFile], async () => {\n      oldPathBacklinksMapRefreshed = (await getBacklinksForFileSafe(this.app, fakeOldFile)).data;\n    });\n\n    for (const link of oldPathLinksRefreshed) {\n      if (this.oldPathLinks.includes(link)) {\n        continue;\n      }\n      this.oldPathLinks.push(link);\n    }\n\n    for (const [backlinkPath, refreshedLinks] of oldPathBacklinksMapRefreshed.entries()) {\n      let oldLinks = this.oldPathBacklinksMap.get(backlinkPath);\n      if (!oldLinks) {\n        oldLinks = [];\n        this.oldPathBacklinksMap.set(backlinkPath, oldLinks);\n      }\n\n      for (const link of refreshedLinks) {\n        if (oldLinks.includes(link)) {\n          continue;\n        }\n        oldLinks.push(link);\n      }\n    }\n  }\n\n  private async renameHandled(oldPath: string, newPath: string): Promise<string> {\n    newPath = getSafeRenamePath(this.app, oldPath, newPath);\n    if (oldPath === newPath) {\n      return newPath;\n    }\n    this.handledRenames.add(oldPath, newPath);\n    newPath = await renameSafe(this.app, oldPath, newPath);\n    return newPath;\n  }\n}\n\nclass RenameMap {\n  private readonly abortSignal: AbortSignal;\n  private readonly app: App;\n  private readonly map = new Map<string, string>();\n  private readonly newPath: string;\n  private readonly oldCache: CachedMetadata | null;\n  private readonly oldPath: string;\n  private readonly oldPathLinks: Reference[];\n  private readonly settingsManager: SettingsManager;\n\n  public constructor(options: RenameMapOptions) {\n    this.abortSignal = options.abortSignal;\n    this.app = options.app;\n    this.settingsManager = options.settingsManager;\n    this.oldCache = options.oldCache;\n    this.oldPath = options.oldPath;\n    this.newPath = options.newPath;\n    this.oldPathLinks = this.oldCache ? getAllLinks(this.oldCache) : [];\n  }\n\n  public entries(): IterableIterator<[string, string]> {\n    return this.map.entries();\n  }\n\n  public async fill(): Promise<void> {\n    this.abortSignal.throwIfAborted();\n    this.map.set(this.oldPath, this.newPath);\n\n    if (!this.settingsManager.isNoteEx(this.oldPath)) {\n      return;\n    }\n\n    const settings = this.settingsManager.getSettings();\n\n    const oldFile = getFile(this.app, this.oldPath, true);\n    let oldAttachmentFolderPath = '';\n    await tempRegisterFilesAndRunAsync(this.app, [oldFile], async () => {\n      const shouldFakeOldPathCache = this.oldCache && oldFile.deleted;\n      if (shouldFakeOldPathCache) {\n        registerFileCacheForNonExistingFile(this.app, oldFile, this.oldCache);\n      }\n\n      try {\n        oldAttachmentFolderPath = await getAttachmentFolderPath(this.app, this.oldPath, AttachmentPathContext.RenameNote);\n      } finally {\n        if (shouldFakeOldPathCache) {\n          unregisterFileCacheForNonExistingFile(this.app, oldFile);\n        }\n      }\n    });\n\n    const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder\n      ? await getAttachmentFolderPath(this.app, this.newPath, AttachmentPathContext.RenameNote)\n      : oldAttachmentFolderPath;\n\n    const isOldAttachmentFolderAtRoot = oldAttachmentFolderPath === '/';\n\n    const oldAttachmentFolder = getFolderOrNull(this.app, oldAttachmentFolderPath);\n\n    if (!oldAttachmentFolder) {\n      return;\n    }\n\n    if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {\n      return;\n    }\n\n    const oldAttachmentFiles: TFile[] = [];\n\n    if (await hasOwnAttachmentFolder(this.app, this.oldPath, AttachmentPathContext.RenameNote)) {\n      Vault.recurseChildren(oldAttachmentFolder, (oldAttachmentFile) => {\n        this.abortSignal.throwIfAborted();\n        if (isFile(oldAttachmentFile)) {\n          oldAttachmentFiles.push(oldAttachmentFile);\n        }\n      });\n    } else {\n      for (const oldPathLink of this.oldPathLinks) {\n        this.abortSignal.throwIfAborted();\n        const oldAttachmentFile = extractLinkFile(this.app, oldPathLink, this.oldPath);\n        if (!oldAttachmentFile) {\n          continue;\n        }\n\n        if (isOldAttachmentFolderAtRoot || oldAttachmentFile.path.startsWith(oldAttachmentFolderPath)) {\n          const oldAttachmentBacklinks = await getBacklinksForFileSafe(this.app, oldAttachmentFile);\n          this.abortSignal.throwIfAborted();\n          if (oldAttachmentBacklinks.keys().length === 1) {\n            oldAttachmentFiles.push(oldAttachmentFile);\n          }\n        }\n      }\n    }\n\n    for (const oldAttachmentFile of oldAttachmentFiles) {\n      this.abortSignal.throwIfAborted();\n      if (this.settingsManager.isNoteEx(oldAttachmentFile.path)) {\n        continue;\n      }\n\n      let newAttachmentFilePath: string;\n      if (settings.shouldRenameAttachmentFiles) {\n        newAttachmentFilePath = await getAttachmentFilePath({\n          app: this.app,\n          attachmentPathOrFile: oldAttachmentFile,\n          context: AttachmentPathContext.RenameNote,\n          notePathOrFile: this.newPath,\n          oldNotePathOrFile: this.oldPath,\n          shouldSkipDuplicateCheck: true\n        });\n        this.abortSignal.throwIfAborted();\n      } else {\n        const relativePath = isOldAttachmentFolderAtRoot ? oldAttachmentFile.path : relative(oldAttachmentFolderPath, oldAttachmentFile.path);\n        const newFolder = join(newAttachmentFolderPath, dirname(relativePath));\n        newAttachmentFilePath = join(newFolder, oldAttachmentFile.name);\n      }\n\n      if (oldAttachmentFile.path === newAttachmentFilePath) {\n        continue;\n      }\n      if (settings.shouldDeleteConflictingAttachments) {\n        const newAttachmentFile = getFileOrNull(this.app, newAttachmentFilePath);\n        if (newAttachmentFile) {\n          getLibDebugger('RenameDeleteHandler:fillRenameMap')(`Removing conflicting attachment ${newAttachmentFile.path}.`);\n          await this.app.fileManager.trashFile(newAttachmentFile);\n          this.abortSignal.throwIfAborted();\n        }\n      } else {\n        const dir = dirname(newAttachmentFilePath);\n        const ext = extname(newAttachmentFilePath);\n        const baseName = basename(newAttachmentFilePath, ext);\n        newAttachmentFilePath = this.app.vault.getAvailablePath(join(dir, baseName), ext.slice(1));\n      }\n      this.map.set(oldAttachmentFile.path, newAttachmentFilePath);\n    }\n  }\n\n  public get(oldPath: string): string | undefined {\n    return this.map.get(oldPath);\n  }\n\n  public initBacklinksMap(\n    singleBacklinksMap: Map<string, Reference[]>,\n    combinedBacklinksMap: Map<string, Map<string, string>>,\n    path: string\n  ): void {\n    for (const [backlinkPath, links] of singleBacklinksMap.entries()) {\n      const newBacklinkPath = this.map.get(backlinkPath) ?? backlinkPath;\n      const linkJsonToPathMap = combinedBacklinksMap.get(newBacklinkPath) ?? new Map<string, string>();\n      combinedBacklinksMap.set(newBacklinkPath, linkJsonToPathMap);\n      for (const link of links) {\n        linkJsonToPathMap.set(toJson(link), path);\n      }\n    }\n  }\n\n  public keys(): IterableIterator<string> {\n    return this.map.keys();\n  }\n\n  public set(oldPath: string, newPath: string): void {\n    this.map.set(oldPath, newPath);\n  }\n}\n\nclass SettingsManager {\n  public readonly renameDeleteHandlersMap: Map<string, () => Partial<RenameDeleteHandlerSettings>>;\n\n  public constructor(private readonly app: App) {\n    this.renameDeleteHandlersMap =\n      getObsidianDevUtilsState(app, 'renameDeleteHandlersMap', new Map<string, () => Partial<RenameDeleteHandlerSettings>>()).value;\n  }\n\n  public getSettings(): Partial<RenameDeleteHandlerSettings> {\n    const settingsBuilders = Array.from(this.renameDeleteHandlersMap.values()).reverse();\n\n    const settings: Partial<RenameDeleteHandlerSettings> = {};\n    settings.isNote = (path: string): boolean => isNote(this.app, path);\n    settings.isPathIgnored = (): boolean => false;\n\n    for (const settingsBuilder of settingsBuilders) {\n      const newSettings = settingsBuilder();\n      settings.shouldDeleteConflictingAttachments ||= newSettings.shouldDeleteConflictingAttachments ?? false;\n      if (newSettings.emptyAttachmentFolderBehavior) {\n        settings.emptyAttachmentFolderBehavior ??= newSettings.emptyAttachmentFolderBehavior;\n      }\n      settings.shouldHandleDeletions ||= newSettings.shouldHandleDeletions ?? false;\n      settings.shouldHandleRenames ||= newSettings.shouldHandleRenames ?? false;\n      settings.shouldRenameAttachmentFiles ||= newSettings.shouldRenameAttachmentFiles ?? false;\n      settings.shouldRenameAttachmentFolder ||= newSettings.shouldRenameAttachmentFolder ?? false;\n      settings.shouldUpdateFileNameAliases ||= newSettings.shouldUpdateFileNameAliases ?? false;\n      const isPathIgnored = settings.isPathIgnored;\n      settings.isPathIgnored = (path: string): boolean => isPathIgnored(path) || (newSettings.isPathIgnored?.(path) ?? false);\n      const currentIsNote = settings.isNote;\n      settings.isNote = (path: string): boolean => currentIsNote(path) && (newSettings.isNote?.(path) ?? true);\n    }\n\n    settings.emptyAttachmentFolderBehavior ??= EmptyAttachmentFolderBehavior.Keep;\n    return settings;\n  }\n\n  public isNoteEx(path: string): boolean {\n    const settings = this.getSettings();\n    return settings.isNote?.(path) ?? false;\n  }\n}\n\n/**\n * Registers the rename/delete handlers.\n *\n * @param plugin - The plugin instance.\n * @param settingsBuilder - A function that returns the settings for the rename delete handler.\n */\nexport function registerRenameDeleteHandlers(plugin: AbortablePlugin, settingsBuilder: () => Partial<RenameDeleteHandlerSettings>): void {\n  new Registry(plugin, settingsBuilder, new SettingsManager(plugin.app)).register();\n}\n\nasync function cleanupParentFolders(app: App, settings: Partial<RenameDeleteHandlerSettings>, parentFolderPaths: string[], notePath: string): Promise<void> {\n  if (settings.emptyAttachmentFolderBehavior === EmptyAttachmentFolderBehavior.Keep) {\n    return;\n  }\n  for (const parentFolderPath of parentFolderPaths) {\n    switch (settings.emptyAttachmentFolderBehavior) {\n      case EmptyAttachmentFolderBehavior.Delete:\n        await deleteSafe(app, parentFolderPath, notePath, undefined, true);\n        break;\n      case EmptyAttachmentFolderBehavior.DeleteWithEmptyParents:\n        await deleteEmptyFolderHierarchy(app, parentFolderPath);\n        break;\n      default:\n        break;\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": ["EmptyAttachmentFolderBehavior"]
}
