obsidian-dev-utils 17.10.0 → 17.10.2-beta.1

package/dist/lib/obsidian/RenameDeleteHandler.mjs

@@ -0,0 +1,436 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+import { around } from "monkey-around";
+import {
+  App,
+  TFile,
+  Vault
+} from "obsidian";
+import { getLibDebugger } from "../Debug.mjs";
+import { noopAsync } from "../Function.mjs";
+import {
+  normalizeOptionalProperties,
+  toJson
+} from "../Object.mjs";
+import {
+  basename,
+  dirname,
+  extname,
+  join,
+  makeFileName,
+  relative
+} from "../Path.mjs";
+import { replaceAll } from "../String.mjs";
+import { getObsidianDevUtilsState } from "./App.mjs";
+import {
+  getAttachmentFolderPath,
+  hasOwnAttachmentFolder
+} from "./AttachmentPath.mjs";
+import {
+  getFile,
+  getFileOrNull,
+  getFolderOrNull,
+  isFile,
+  isMarkdownFile,
+  isNote
+} from "./FileSystem.mjs";
+import {
+  editLinks,
+  extractLinkFile,
+  updateLink,
+  updateLinksInFile
+} from "./Link.mjs";
+import {
+  getAllLinks,
+  getBacklinksForFileOrPath,
+  getBacklinksForFileSafe
+} from "./MetadataCache.mjs";
+import { addToQueue } from "./Queue.mjs";
+import {
+  getSafeRenamePath,
+  renameSafe
+} from "./Vault.mjs";
+import {
+  deleteEmptyFolderHierarchy,
+  deleteSafe
+} from "./VaultEx.mjs";
+const deletedMetadataCacheMap = /* @__PURE__ */ new Map();
+const handledRenames = /* @__PURE__ */ new Set();
+const interruptedRenamesMap = /* @__PURE__ */ new Map();
+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;
+  plugin.registerEvent(
+    app.vault.on("delete", (file) => {
+      handleDeleteIfEnabled(plugin, file);
+    })
+  );
+  plugin.registerEvent(
+    app.vault.on("rename", (file, oldPath) => {
+      handleRenameIfEnabled(plugin, file, oldPath);
+    })
+  );
+  plugin.registerEvent(
+    app.metadataCache.on("deleted", (file, prevCache) => {
+      handleMetadataDeletedIfEnabled(plugin, file, prevCache);
+    })
+  );
+}
+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);
+    }
+  }
+}
+async function fillRenameMap(app, oldPath, newPath, renameMap, oldPathLinks) {
+  renameMap.set(oldPath, newPath);
+  if (!isNote(app, oldPath)) {
+    return;
+  }
+  const settings = getSettings(app);
+  const oldAttachmentFolderPath = await getAttachmentFolderPath(app, oldPath);
+  const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder ? await getAttachmentFolderPath(app, newPath) : oldAttachmentFolderPath;
+  const oldAttachmentFolder = getFolderOrNull(app, oldAttachmentFolderPath);
+  if (!oldAttachmentFolder) {
+    return;
+  }
+  if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {
+    return;
+  }
+  const oldAttachmentFiles = [];
+  if (await hasOwnAttachmentFolder(app, oldPath)) {
+    Vault.recurseChildren(oldAttachmentFolder, (oldAttachmentFile) => {
+      if (isFile(oldAttachmentFile)) {
+        oldAttachmentFiles.push(oldAttachmentFile);
+      }
+    });
+  } else {
+    for (const oldPathLink of oldPathLinks) {
+      const oldAttachmentFile = extractLinkFile(app, oldPathLink, oldPath);
+      if (!oldAttachmentFile) {
+        continue;
+      }
+      if (oldAttachmentFile.path.startsWith(oldAttachmentFolderPath)) {
+        const oldAttachmentBacklinks = await getBacklinksForFileSafe(app, oldAttachmentFile);
+        if (oldAttachmentBacklinks.keys().length === 1) {
+          oldAttachmentFiles.push(oldAttachmentFile);
+        }
+      }
+    }
+  }
+  const oldBasename = basename(oldPath, extname(oldPath));
+  const newBasename = basename(newPath, extname(newPath));
+  for (const oldAttachmentFile of oldAttachmentFiles) {
+    if (isNote(app, oldAttachmentFile)) {
+      continue;
+    }
+    const relativePath = relative(oldAttachmentFolderPath, oldAttachmentFile.path);
+    const newDir = join(newAttachmentFolderPath, dirname(relativePath));
+    const newChildBasename = settings.shouldRenameAttachmentFiles ? replaceAll(oldAttachmentFile.basename, oldBasename, newBasename) : oldAttachmentFile.basename;
+    let newChildPath = join(newDir, makeFileName(newChildBasename, oldAttachmentFile.extension));
+    if (oldAttachmentFile.path === newChildPath) {
+      continue;
+    }
+    if (settings.shouldDeleteConflictingAttachments) {
+      const newChildFile = getFileOrNull(app, newChildPath);
+      if (newChildFile) {
+        await app.fileManager.trashFile(newChildFile);
+      }
+    } else {
+      newChildPath = app.vault.getAvailablePath(join(newDir, newChildBasename), oldAttachmentFile.extension);
+    }
+    renameMap.set(oldAttachmentFile.path, newChildPath);
+  }
+}
+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 = {};
+  for (const settingsBuilder of settingsBuilders) {
+    const newSettings = settingsBuilder();
+    settings.shouldDeleteConflictingAttachments ||= newSettings.shouldDeleteConflictingAttachments ?? false;
+    settings.shouldDeleteEmptyFolders ||= newSettings.shouldDeleteEmptyFolders ?? false;
+    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;
+  }
+  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) {
+  getLibDebugger("RenameDeleteHandler:handleDelete")(`Handle Delete ${path}`);
+  if (!isNote(app, path)) {
+    return;
+  }
+  const settings = getSettings(app);
+  if (!settings.shouldHandleDeletions) {
+    return;
+  }
+  if (settings.isPathIgnored?.(path)) {
+    return;
+  }
+  const cache = deletedMetadataCacheMap.get(path);
+  deletedMetadataCacheMap.delete(path);
+  if (cache) {
+    const links = getAllLinks(cache);
+    for (const link of links) {
+      const attachmentFile = extractLinkFile(app, link, path);
+      if (!attachmentFile) {
+        continue;
+      }
+      if (isNote(app, attachmentFile)) {
+        continue;
+      }
+      await deleteSafe(app, attachmentFile, path, settings.shouldDeleteEmptyFolders);
+    }
+  }
+  const attachmentFolderPath = await getAttachmentFolderPath(app, path);
+  const attachmentFolder = getFolderOrNull(app, attachmentFolderPath);
+  if (!attachmentFolder) {
+    return;
+  }
+  if (!await hasOwnAttachmentFolder(app, path)) {
+    return;
+  }
+  await deleteSafe(app, attachmentFolder, path, false, settings.shouldDeleteEmptyFolders);
+}
+function handleDeleteIfEnabled(plugin, file) {
+  const app = plugin.app;
+  if (!shouldInvokeHandler(plugin)) {
+    return;
+  }
+  const path = file.path;
+  addToQueue(app, () => handleDelete(app, path));
+}
+function handleMetadataDeleted(app, file, prevCache) {
+  const settings = getSettings(app);
+  if (settings.isPathIgnored?.(file.path)) {
+    return;
+  }
+  if (!settings.shouldHandleDeletions) {
+    return;
+  }
+  if (isMarkdownFile(app, file) && prevCache) {
+    deletedMetadataCacheMap.set(file.path, prevCache);
+  }
+}
+function handleMetadataDeletedIfEnabled(plugin, file, prevCache) {
+  if (!shouldInvokeHandler(plugin)) {
+    return;
+  }
+  handleMetadataDeleted(plugin.app, file, prevCache);
+}
+function handleRename(app, oldPath, newPath) {
+  const key = makeKey(oldPath, newPath);
+  getLibDebugger("RenameDeleteHandler:handleRename")(`Handle Rename ${key}`);
+  if (handledRenames.has(key)) {
+    handledRenames.delete(key);
+    return;
+  }
+  const settings = getSettings(app);
+  if (!settings.shouldHandleRenames || settings.isPathIgnored?.(oldPath) || settings.isPathIgnored?.(newPath)) {
+    return;
+  }
+  const cache = app.metadataCache.getCache(oldPath) ?? app.metadataCache.getCache(newPath);
+  const oldPathLinks = cache ? getAllLinks(cache) : [];
+  const oldPathBacklinksMap = getBacklinksForFileOrPath(app, oldPath).data;
+  addToQueue(app, () => handleRenameAsync(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks));
+}
+async function handleRenameAsync(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks, interruptedCombinedBacklinksMap) {
+  await continueInterruptedRenames(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks);
+  refreshLinks(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks);
+  if (await handleCaseCollision(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks)) {
+    return;
+  }
+  const restoreUpdateAllLinks = around(app.fileManager, {
+    updateAllLinks: () => noopAsync
+  });
+  try {
+    const renameMap = /* @__PURE__ */ new Map();
+    await fillRenameMap(app, oldPath, newPath, renameMap, oldPathLinks);
+    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);
+    }
+    const parentFolders = /* @__PURE__ */ new Set();
+    for (const [oldAttachmentPath, newAttachmentPath] of renameMap.entries()) {
+      if (oldAttachmentPath === oldPath) {
+        continue;
+      }
+      const fixedNewAttachmentPath = await renameHandled(app, oldAttachmentPath, newAttachmentPath);
+      renameMap.set(oldAttachmentPath, fixedNewAttachmentPath);
+      parentFolders.add(dirname(oldAttachmentPath));
+    }
+    const settings = getSettings(app);
+    if (settings.shouldDeleteEmptyFolders) {
+      for (const parentFolder of parentFolders) {
+        await deleteEmptyFolderHierarchy(app, parentFolder);
+      }
+    }
+    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;
+        }
+        const newAttachmentPath = renameMap.get(oldAttachmentPath);
+        if (!newAttachmentPath) {
+          return;
+        }
+        return updateLink(normalizeOptionalProperties({
+          app,
+          link,
+          newSourcePathOrFile: newBacklinkPath,
+          newTargetPathOrFile: newAttachmentPath,
+          oldTargetPathOrFile: oldAttachmentPath,
+          shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases
+        }));
+      }, {
+        shouldFailOnMissingFile: false
+      });
+    }
+    if (isNote(app, newPath)) {
+      await updateLinksInFile(normalizeOptionalProperties({
+        app,
+        newSourcePathOrFile: newPath,
+        oldSourcePathOrFile: oldPath,
+        shouldFailOnMissingFile: false,
+        shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases
+      }));
+    }
+    if (!getFileOrNull(app, newPath)) {
+      let interruptedRenames = interruptedRenamesMap.get(newPath);
+      if (!interruptedRenames) {
+        interruptedRenames = [];
+        interruptedRenamesMap.set(newPath, interruptedRenames);
+      }
+      interruptedRenames.push({
+        combinedBacklinksMap,
+        oldPath
+      });
+    }
+  } finally {
+    restoreUpdateAllLinks();
+    const orphanKeys = Array.from(handledRenames);
+    addToQueue(app, () => {
+      for (const key of orphanKeys) {
+        handledRenames.delete(key);
+      }
+    });
+  }
+}
+function handleRenameIfEnabled(plugin, file, oldPath) {
+  if (!shouldInvokeHandler(plugin)) {
+    return;
+  }
+  if (!isFile(file)) {
+    return;
+  }
+  const newPath = file.path;
+  handleRename(plugin.app, oldPath, newPath);
+}
+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);
+    }
+  }
+}
+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}`;
+}
+function refreshLinks(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks) {
+  const cache = app.metadataCache.getCache(oldPath) ?? app.metadataCache.getCache(newPath);
+  const oldPathLinksRefreshed = cache ? getAllLinks(cache) : [];
+  const oldPathBacklinksMapRefreshed = getBacklinksForFileOrPath(app, oldPath).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;
+      }
+      oldLinks.push(link);
+    }
+  }
+}
+async function renameHandled(app, oldPath, newPath) {
+  newPath = getSafeRenamePath(app, oldPath, newPath);
+  if (oldPath === newPath) {
+    return newPath;
+  }
+  const key = makeKey(oldPath, newPath);
+  handledRenames.add(key);
+  newPath = await renameSafe(app, oldPath, newPath);
+  return newPath;
+}
+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 {
+  registerRenameDeleteHandlers
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/RenameDeleteHandler.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation RenameDeleteHandler\n * Contains utility functions for handling rename and delete events in Obsidian.\n */\n\nimport type {\n  CachedMetadata,\n  Plugin,\n  Reference,\n  TAbstractFile\n} from 'obsidian';\n\nimport { around } from 'monkey-around';\nimport {\n  App,\n  TFile,\n  Vault\n} from 'obsidian';\n\nimport type {\n  UpdateLinkOptions,\n  UpdateLinksInFileOptions\n} from './Link.ts';\n\nimport { getLibDebugger } from '../Debug.ts';\nimport { noopAsync } from '../Function.ts';\nimport {\n  normalizeOptionalProperties,\n  toJson\n} from '../Object.ts';\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  makeFileName,\n  relative\n} from '../Path.ts';\nimport { replaceAll } from '../String.ts';\nimport { getObsidianDevUtilsState } from './App.ts';\nimport {\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} from './MetadataCache.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 * Settings for the rename/delete handler.\n */\nexport interface RenameDeleteHandlerSettings {\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 delete empty folders.\n   */\n  shouldDeleteEmptyFolders: 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 filename aliases when a note is renamed.\n   */\n  shouldUpdateFilenameAliases: boolean;\n}\n\ninterface InterruptedRename {\n  combinedBacklinksMap: Map<string, Map<string, string>>;\n  oldPath: string;\n}\n\n/**\n * Registers the rename/delete handlers.\n * @param plugin - The plugin instance.\n * @param settingsBuilder - A function that returns the settings for the rename delete handler.\n * @returns void\n */\nexport function registerRenameDeleteHandlers(plugin: Plugin, settingsBuilder: () => Partial<RenameDeleteHandlerSettings>): void {\n  const renameDeleteHandlersMap = getRenameDeleteHandlersMap(plugin.app);\n  const pluginId = plugin.manifest.id;\n\n  renameDeleteHandlersMap.set(pluginId, settingsBuilder);\n  logRegisteredHandlers(plugin.app);\n\n  plugin.register(() => {\n    renameDeleteHandlersMap.delete(pluginId);\n    logRegisteredHandlers(plugin.app);\n  });\n\n  const app = plugin.app;\n  plugin.registerEvent(\n    app.vault.on('delete', (file) => {\n      handleDeleteIfEnabled(plugin, file);\n    })\n  );\n\n  plugin.registerEvent(\n    app.vault.on('rename', (file, oldPath) => {\n      handleRenameIfEnabled(plugin, file, oldPath);\n    })\n  );\n\n  plugin.registerEvent(\n    app.metadataCache.on('deleted', (file, prevCache) => {\n      handleMetadataDeletedIfEnabled(plugin, file, prevCache);\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(app: App, oldPath: string, newPath: string, renameMap: Map<string, string>, oldPathLinks: Reference[]): Promise<void> {\n  renameMap.set(oldPath, newPath);\n\n  if (!isNote(app, oldPath)) {\n    return;\n  }\n\n  const settings = getSettings(app);\n\n  const oldAttachmentFolderPath = await getAttachmentFolderPath(app, oldPath);\n  const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder\n    ? await getAttachmentFolderPath(app, newPath)\n    : 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)) {\n    Vault.recurseChildren(oldAttachmentFolder, (oldAttachmentFile) => {\n      if (isFile(oldAttachmentFile)) {\n        oldAttachmentFiles.push(oldAttachmentFile);\n      }\n    });\n  } else {\n    for (const oldPathLink of oldPathLinks) {\n      const oldAttachmentFile = extractLinkFile(app, oldPathLink, oldPath);\n      if (!oldAttachmentFile) {\n        continue;\n      }\n\n      if (oldAttachmentFile.path.startsWith(oldAttachmentFolderPath)) {\n        const oldAttachmentBacklinks = await getBacklinksForFileSafe(app, oldAttachmentFile);\n        if (oldAttachmentBacklinks.keys().length === 1) {\n          oldAttachmentFiles.push(oldAttachmentFile);\n        }\n      }\n    }\n  }\n\n  const oldBasename = basename(oldPath, extname(oldPath));\n  const newBasename = basename(newPath, extname(newPath));\n\n  for (const oldAttachmentFile of oldAttachmentFiles) {\n    if (isNote(app, oldAttachmentFile)) {\n      continue;\n    }\n    const relativePath = relative(oldAttachmentFolderPath, oldAttachmentFile.path);\n    const newDir = join(newAttachmentFolderPath, dirname(relativePath));\n    const newChildBasename = settings.shouldRenameAttachmentFiles\n      ? replaceAll(oldAttachmentFile.basename, oldBasename, newBasename)\n      : oldAttachmentFile.basename;\n    let newChildPath = join(newDir, makeFileName(newChildBasename, oldAttachmentFile.extension));\n\n    if (oldAttachmentFile.path === newChildPath) {\n      continue;\n    }\n\n    if (settings.shouldDeleteConflictingAttachments) {\n      const newChildFile = getFileOrNull(app, newChildPath);\n      if (newChildFile) {\n        await app.fileManager.trashFile(newChildFile);\n      }\n    } else {\n      newChildPath = app.vault.getAvailablePath(join(newDir, newChildBasename), oldAttachmentFile.extension);\n    }\n    renameMap.set(oldAttachmentFile.path, newChildPath);\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  for (const settingsBuilder of settingsBuilders) {\n    const newSettings = settingsBuilder();\n    settings.shouldDeleteConflictingAttachments ||= newSettings.shouldDeleteConflictingAttachments ?? false;\n    settings.shouldDeleteEmptyFolders ||= newSettings.shouldDeleteEmptyFolders ?? false;\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  }\n\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): Promise<void> {\n  getLibDebugger('RenameDeleteHandler:handleDelete')(`Handle Delete ${path}`);\n  if (!isNote(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    return;\n  }\n\n  const cache = deletedMetadataCacheMap.get(path);\n  deletedMetadataCacheMap.delete(path);\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 (isNote(app, attachmentFile)) {\n        continue;\n      }\n\n      await deleteSafe(app, attachmentFile, path, settings.shouldDeleteEmptyFolders);\n    }\n  }\n\n  const attachmentFolderPath = await getAttachmentFolderPath(app, path);\n  const attachmentFolder = getFolderOrNull(app, attachmentFolderPath);\n\n  if (!attachmentFolder) {\n    return;\n  }\n\n  if (!(await hasOwnAttachmentFolder(app, path))) {\n    return;\n  }\n\n  await deleteSafe(app, attachmentFolder, path, false, settings.shouldDeleteEmptyFolders);\n}\n\nfunction handleDeleteIfEnabled(plugin: Plugin, file: TAbstractFile): void {\n  const app = plugin.app;\n  if (!shouldInvokeHandler(plugin)) {\n    return;\n  }\n  const path = file.path;\n  addToQueue(app, () => handleDelete(app, path));\n}\n\nfunction handleMetadataDeleted(app: App, file: TAbstractFile, prevCache: CachedMetadata | null): void {\n  const settings = getSettings(app);\n  if (settings.isPathIgnored?.(file.path)) {\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): 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 || settings.isPathIgnored?.(oldPath) || settings.isPathIgnored?.(newPath)) {\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, () => handleRenameAsync(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks));\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): Promise<void> {\n  await continueInterruptedRenames(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks);\n  refreshLinks(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks);\n  if (await handleCaseCollision(app, oldPath, newPath, oldPathBacklinksMap, oldPathLinks)) {\n    return;\n  }\n\n  const restoreUpdateAllLinks = around(app.fileManager, {\n    updateAllLinks: () => noopAsync\n  });\n  try {\n    const renameMap = new Map<string, string>();\n    await fillRenameMap(app, oldPath, newPath, renameMap, oldPathLinks);\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 parentFolders = 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      parentFolders.add(dirname(oldAttachmentPath));\n    }\n\n    const settings = getSettings(app);\n    if (settings.shouldDeleteEmptyFolders) {\n      for (const parentFolder of parentFolders) {\n        await deleteEmptyFolderHierarchy(app, parentFolder);\n      }\n    }\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    }\n\n    if (isNote(app, newPath)) {\n      await updateLinksInFile(normalizeOptionalProperties<UpdateLinksInFileOptions>({\n        app,\n        newSourcePathOrFile: newPath,\n        oldSourcePathOrFile: oldPath,\n        shouldFailOnMissingFile: false,\n        shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases\n      }));\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    restoreUpdateAllLinks();\n    const orphanKeys = Array.from(handledRenames);\n    addToQueue(app, () => {\n      for (const key of orphanKeys) {\n        handledRenames.delete(key);\n      }\n    });\n  }\n}\n\nfunction handleRenameIfEnabled(plugin: Plugin, file: TAbstractFile, oldPath: string): 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);\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 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\nfunction refreshLinks(app: App, oldPath: string, newPath: string, oldPathBacklinksMap: Map<string, Reference[]>, oldPathLinks: Reference[]): void {\n  const cache = app.metadataCache.getCache(oldPath) ?? app.metadataCache.getCache(newPath);\n  const oldPathLinksRefreshed = cache ? getAllLinks(cache) : [];\n  const oldPathBacklinksMapRefreshed = getBacklinksForFileOrPath(app, oldPath).data;\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\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": []
}


package/dist/lib/obsidian/ResourceUrl.mjs

@@ -0,0 +1,19 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+import { Platform } from "obsidian";
+import { toPosixPath } from "../Path.mjs";
+function relativePathToResourceUrl(app, relativePath, notePath) {
+  const noteFullPath = toPosixPath(app.vault.adapter.getFullRealPath(notePath));
+  const noteUrl = `${Platform.resourcePathPrefix}${noteFullPath}`;
+  const relativeUrl = new URL(relativePath, noteUrl);
+  return relativeUrl.toString();
+}
+export {
+  relativePathToResourceUrl
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL29ic2lkaWFuL1Jlc291cmNlVXJsLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvbiBSZXNvdXJjZVVybFxuICogVGhpcyBtb2R1bGUgcHJvdmlkZXMgdXRpbGl0eSBmdW5jdGlvbnMgZm9yIHdvcmtpbmcgd2l0aCByZXNvdXJjZSBVUkxzIGluIE9ic2lkaWFuLlxuICovXG5cbmltcG9ydCB0eXBlIHsgQXBwIH0gZnJvbSAnb2JzaWRpYW4nO1xuXG5pbXBvcnQgeyBQbGF0Zm9ybSB9IGZyb20gJ29ic2lkaWFuJztcblxuaW1wb3J0IHsgdG9Qb3NpeFBhdGggfSBmcm9tICcuLi9QYXRoLnRzJztcblxuLyoqXG4gKiBDb252ZXJ0cyBhIHJlbGF0aXZlIHBhdGggdG8gYSByZXNvdXJjZSBVUkwuXG4gKlxuICogQHBhcmFtIGFwcCAtIFRoZSBPYnNpZGlhbiBhcHBsaWNhdGlvbiBpbnN0YW5jZS5cbiAqIEBwYXJhbSByZWxhdGl2ZVBhdGggLSBUaGUgcmVsYXRpdmUgcGF0aCB0byB0aGUgcmVzb3VyY2UuXG4gKiBAcGFyYW0gbm90ZVBhdGggLSBUaGUgcGF0aCBvZiB0aGUgbm90ZS5cbiAqIEByZXR1cm5zIFRoZSByZXNvdXJjZSBVUkwuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZWxhdGl2ZVBhdGhUb1Jlc291cmNlVXJsKGFwcDogQXBwLCByZWxhdGl2ZVBhdGg6IHN0cmluZywgbm90ZVBhdGg6IHN0cmluZyk6IHN0cmluZyB7XG4gIGNvbnN0IG5vdGVGdWxsUGF0aCA9IHRvUG9zaXhQYXRoKGFwcC52YXVsdC5hZGFwdGVyLmdldEZ1bGxSZWFsUGF0aChub3RlUGF0aCkpO1xuICBjb25zdCBub3RlVXJsID0gYCR7UGxhdGZvcm0ucmVzb3VyY2VQYXRoUHJlZml4fSR7bm90ZUZ1bGxQYXRofWA7XG4gIGNvbnN0IHJlbGF0aXZlVXJsID0gbmV3IFVSTChyZWxhdGl2ZVBhdGgsIG5vdGVVcmwpO1xuICByZXR1cm4gcmVsYXRpdmVVcmwudG9TdHJpbmcoKTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7QUFPQSxTQUFTLGdCQUFnQjtBQUV6QixTQUFTLG1CQUFtQjtBQVVyQixTQUFTLDBCQUEwQixLQUFVLGNBQXNCLFVBQTBCO0FBQ2xHLFFBQU0sZUFBZSxZQUFZLElBQUksTUFBTSxRQUFRLGdCQUFnQixRQUFRLENBQUM7QUFDNUUsUUFBTSxVQUFVLEdBQUcsU0FBUyxrQkFBa0IsR0FBRyxZQUFZO0FBQzdELFFBQU0sY0FBYyxJQUFJLElBQUksY0FBYyxPQUFPO0FBQ2pELFNBQU8sWUFBWSxTQUFTO0FBQzlCOyIsCiAgIm5hbWVzIjogW10KfQo=