obsidian-dev-utils 3.7.1 → 3.9.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 3.9.0
+
+- Extract RenameDeleteHandler
+
+## 3.8.0
+
+- Implement getAvailablePathForAttachments without patching mkdir
+
 ## 3.7.1
 
 - Ensure folders are created

package/dist/lib/String.cjs

@@ -82,7 +82,7 @@ function trimEnd(str, suffix, validate) {
   return str;
 }
 function normalize(str) {
-  return str.replace(/\u00A0/g, " ").normalize("NFC");
+  return str.replace(/\u00A0|\u202F/g, " ").normalize("NFC");
 }
 async function replaceAllAsync(str, searchValue, replacer) {
   const replacementPromises = [];
@@ -125,4 +125,4 @@ function replace(str, replacementsMap) {
   trimStart,
   unescape
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/String.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (()=>{if(typeof __filename!==\"string\"){return new URL(window.location.href)}return require(\"node:url\").pathToFileURL(__filename)})();\nvar __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation String\n * Contains utility functions for string operations.\n */\n\nimport { throwExpression } from './Error.ts';\nimport { escapeRegExp } from './RegExp.ts';\nimport type { ValueProvider } from './ValueProvider.ts';\nimport { resolveValue } from './ValueProvider.ts';\n\n/**\n * An asynchronous function that generates replacement strings.\n */\nexport type AsyncReplacer<Args extends unknown[]> = ValueProvider<string, [string, ...Args]>;\n\n/**\n * Mapping of special characters to their escaped counterparts.\n */\nconst ESCAPE_MAP: Record<string, string> = {\n  '\\\\': '\\\\\\\\',\n  '\"': '\\\\\"',\n  '\\'': '\\\\\\'',\n  '\\n': '\\\\n',\n  '\\r': '\\\\r',\n  '\\t': '\\\\t',\n  '\\b': '\\\\b',\n  '\\f': '\\\\f'\n} as const;\n\n/**\n * Mapping of escaped special characters to their unescaped counterparts.\n */\nconst UNESCAPE_MAP: Record<string, string> = {};\nfor (const [key, value] of Object.entries(ESCAPE_MAP)) {\n  UNESCAPE_MAP[value] = key;\n}\n\n/**\n * Trims the specified prefix from the start of a string.\n *\n * @param str - The string to trim.\n * @param prefix - The prefix to remove from the start of the string.\n * @param validate - If true, throws an error if the string does not start with the prefix.\n * @returns The trimmed string.\n * @throws If `validate` is true and the string does not start with the prefix.\n */\nexport function trimStart(str: string, prefix: string, validate?: boolean): string {\n  if (str.startsWith(prefix)) {\n    return str.slice(prefix.length);\n  }\n\n  if (validate) {\n    throw new Error(`String ${str} does not start with prefix ${prefix}`);\n  }\n\n  return str;\n}\n\n/**\n * Trims the specified suffix from the end of a string.\n *\n * @param str - The string to trim.\n * @param suffix - The suffix to remove from the end of the string.\n * @param validate - If true, throws an error if the string does not end with the suffix.\n * @returns The trimmed string.\n * @throws If `validate` is true and the string does not end with the suffix.\n */\nexport function trimEnd(str: string, suffix: string, validate?: boolean): string {\n  if (str.endsWith(suffix)) {\n    return str.slice(0, -suffix.length);\n  }\n\n  if (validate) {\n    throw new Error(`String ${str} does not end with suffix ${suffix}`);\n  }\n\n  return str;\n}\n\n/**\n * Normalizes a string by converting it to the NFC form and replacing non-breaking spaces with regular spaces.\n *\n * @param str - The string to normalize.\n * @returns The normalized string.\n */\nexport function normalize(str: string): string {\n  return str.replace(/\\u00A0/g, ' ').normalize('NFC');\n}\n\n/**\n * Asynchronously replaces all occurrences of a search string or pattern with the results of an asynchronous replacer function.\n *\n * @typeParam Args - The type of additional arguments passed to the replacer function.\n * @param str - The string in which to perform replacements.\n * @param searchValue - The string or regular expression to search for.\n * @param replacer - An asynchronous function that generates replacement strings.\n * @returns A promise that resolves to the string with all replacements made.\n */\nexport async function replaceAllAsync<Args extends unknown[]>(\n  str: string,\n  searchValue: string | RegExp,\n  replacer: AsyncReplacer<Args>\n): Promise<string> {\n  const replacementPromises: Promise<string>[] = [];\n\n  str.replaceAll(searchValue, (substring: string, ...args: unknown[]) => {\n    replacementPromises.push(resolveValue(replacer, substring, ...args as [...Args]));\n    return substring;\n  });\n  const replacements = await Promise.all(replacementPromises);\n  return str.replaceAll(searchValue, (): string => replacements.shift() ?? throwExpression(new Error('Unexpected empty replacement')));\n}\n\n/**\n * Converts a string into a valid JavaScript variable name by replacing invalid characters with underscores.\n *\n * @param str - The string to convert.\n * @returns The valid variable name.\n */\nexport function makeValidVariableName(str: string): string {\n  return str.replace(/[^a-zA-Z0-9_]/g, '_');\n}\n\n/**\n * Ensures that a string starts with the specified prefix, adding it if necessary.\n *\n * @param str - The string to check.\n * @param prefix - The prefix to ensure.\n * @returns The string that starts with the prefix.\n */\nexport function ensureStartsWith(str: string, prefix: string): string {\n  return str.startsWith(prefix) ? str : prefix + str;\n}\n\n/**\n * Ensures that a string ends with the specified suffix, adding it if necessary.\n *\n * @param str - The string to check.\n * @param suffix - The suffix to ensure.\n * @returns The string that ends with the suffix.\n */\nexport function ensureEndsWith(str: string, suffix: string): string {\n  return str.endsWith(suffix) ? str : str + suffix;\n}\n\n/**\n * Escapes special characters in a string.\n *\n * @param str - The string to escape.\n * @returns The escaped string.\n */\nexport function escape(str: string): string {\n  return replace(str, ESCAPE_MAP);\n}\n\n/**\n * Unescapes a string by replacing escape sequences with their corresponding characters.\n *\n * @param str - The string to unescape.\n * @returns The unescaped string.\n */\nexport function unescape(str: string): string {\n  return replace(str, UNESCAPE_MAP);\n}\n\n/**\n * Replaces occurrences of strings in a given string based on a replacements map.\n *\n * @param str - The string to perform replacements on.\n * @param replacementsMap - An object mapping strings to their replacement values.\n * @returns The modified string with replacements applied.\n */\nexport function replace(str: string, replacementsMap: Record<string, string>): string {\n  const regExp = new RegExp(Object.keys(replacementsMap).map((source) => escapeRegExp(source)).join('|'), 'g');\n  return str.replaceAll(regExp, (source: string) => replacementsMap[source] ?? throwExpression(new Error(`Unexpected replacement source: ${source}`)));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,mBAAgC;AAChC,oBAA6B;AAE7B,2BAA6B;AAd7B,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAI;AAAC,MAAG,OAAO,eAAa,UAAS;AAAC,WAAO,IAAI,IAAI,OAAO,SAAS,IAAI;AAAA,EAAC;AAAC,SAAO,QAAQ,UAAU,EAAE,cAAc,UAAU;AAAC,GAAG;AAC5L,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AAmBA,MAAM,aAAqC;AAAA,EACzC,MAAM;AAAA,EACN,KAAK;AAAA,EACL,KAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AAAA,EACN,KAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AACR;AAKA,MAAM,eAAuC,CAAC;AAC9C,WAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,UAAU,GAAG;AACrD,eAAa,KAAK,IAAI;AACxB;AAWO,SAAS,UAAU,KAAa,QAAgB,UAA4B;AACjF,MAAI,IAAI,WAAW,MAAM,GAAG;AAC1B,WAAO,IAAI,MAAM,OAAO,MAAM;AAAA,EAChC;AAEA,MAAI,UAAU;AACZ,UAAM,IAAI,MAAM,UAAU,GAAG,+BAA+B,MAAM,EAAE;AAAA,EACtE;AAEA,SAAO;AACT;AAWO,SAAS,QAAQ,KAAa,QAAgB,UAA4B;AAC/E,MAAI,IAAI,SAAS,MAAM,GAAG;AACxB,WAAO,IAAI,MAAM,GAAG,CAAC,OAAO,MAAM;AAAA,EACpC;AAEA,MAAI,UAAU;AACZ,UAAM,IAAI,MAAM,UAAU,GAAG,6BAA6B,MAAM,EAAE;AAAA,EACpE;AAEA,SAAO;AACT;AAQO,SAAS,UAAU,KAAqB;AAC7C,SAAO,IAAI,QAAQ,WAAW,GAAG,EAAE,UAAU,KAAK;AACpD;AAWA,eAAsB,gBACpB,KACA,aACA,UACiB;AACjB,QAAM,sBAAyC,CAAC;AAEhD,MAAI,WAAW,aAAa,CAAC,cAAsB,SAAoB;AACrE,wBAAoB,SAAK,mCAAa,UAAU,WAAW,GAAG,IAAiB,CAAC;AAChF,WAAO;AAAA,EACT,CAAC;AACD,QAAM,eAAe,MAAM,QAAQ,IAAI,mBAAmB;AAC1D,SAAO,IAAI,WAAW,aAAa,MAAc,aAAa,MAAM,SAAK,8BAAgB,IAAI,MAAM,8BAA8B,CAAC,CAAC;AACrI;AAQO,SAAS,sBAAsB,KAAqB;AACzD,SAAO,IAAI,QAAQ,kBAAkB,GAAG;AAC1C;AASO,SAAS,iBAAiB,KAAa,QAAwB;AACpE,SAAO,IAAI,WAAW,MAAM,IAAI,MAAM,SAAS;AACjD;AASO,SAAS,eAAe,KAAa,QAAwB;AAClE,SAAO,IAAI,SAAS,MAAM,IAAI,MAAM,MAAM;AAC5C;AAQO,SAAS,OAAO,KAAqB;AAC1C,SAAO,QAAQ,KAAK,UAAU;AAChC;AAQO,SAAS,SAAS,KAAqB;AAC5C,SAAO,QAAQ,KAAK,YAAY;AAClC;AASO,SAAS,QAAQ,KAAa,iBAAiD;AACpF,QAAM,SAAS,IAAI,OAAO,OAAO,KAAK,eAAe,EAAE,IAAI,CAAC,eAAW,4BAAa,MAAM,CAAC,EAAE,KAAK,GAAG,GAAG,GAAG;AAC3G,SAAO,IAAI,WAAW,QAAQ,CAAC,WAAmB,gBAAgB,MAAM,SAAK,8BAAgB,IAAI,MAAM,kCAAkC,MAAM,EAAE,CAAC,CAAC;AACrJ;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/String.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (()=>{if(typeof __filename!==\"string\"){return new URL(window.location.href)}return require(\"node:url\").pathToFileURL(__filename)})();\nvar __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation String\n * Contains utility functions for string operations.\n */\n\nimport { throwExpression } from './Error.ts';\nimport { escapeRegExp } from './RegExp.ts';\nimport type { ValueProvider } from './ValueProvider.ts';\nimport { resolveValue } from './ValueProvider.ts';\n\n/**\n * An asynchronous function that generates replacement strings.\n */\nexport type AsyncReplacer<Args extends unknown[]> = ValueProvider<string, [string, ...Args]>;\n\n/**\n * Mapping of special characters to their escaped counterparts.\n */\nconst ESCAPE_MAP: Record<string, string> = {\n  '\\\\': '\\\\\\\\',\n  '\"': '\\\\\"',\n  '\\'': '\\\\\\'',\n  '\\n': '\\\\n',\n  '\\r': '\\\\r',\n  '\\t': '\\\\t',\n  '\\b': '\\\\b',\n  '\\f': '\\\\f'\n} as const;\n\n/**\n * Mapping of escaped special characters to their unescaped counterparts.\n */\nconst UNESCAPE_MAP: Record<string, string> = {};\nfor (const [key, value] of Object.entries(ESCAPE_MAP)) {\n  UNESCAPE_MAP[value] = key;\n}\n\n/**\n * Trims the specified prefix from the start of a string.\n *\n * @param str - The string to trim.\n * @param prefix - The prefix to remove from the start of the string.\n * @param validate - If true, throws an error if the string does not start with the prefix.\n * @returns The trimmed string.\n * @throws If `validate` is true and the string does not start with the prefix.\n */\nexport function trimStart(str: string, prefix: string, validate?: boolean): string {\n  if (str.startsWith(prefix)) {\n    return str.slice(prefix.length);\n  }\n\n  if (validate) {\n    throw new Error(`String ${str} does not start with prefix ${prefix}`);\n  }\n\n  return str;\n}\n\n/**\n * Trims the specified suffix from the end of a string.\n *\n * @param str - The string to trim.\n * @param suffix - The suffix to remove from the end of the string.\n * @param validate - If true, throws an error if the string does not end with the suffix.\n * @returns The trimmed string.\n * @throws If `validate` is true and the string does not end with the suffix.\n */\nexport function trimEnd(str: string, suffix: string, validate?: boolean): string {\n  if (str.endsWith(suffix)) {\n    return str.slice(0, -suffix.length);\n  }\n\n  if (validate) {\n    throw new Error(`String ${str} does not end with suffix ${suffix}`);\n  }\n\n  return str;\n}\n\n/**\n * Normalizes a string by converting it to the NFC form and replacing non-breaking spaces with regular spaces.\n *\n * @param str - The string to normalize.\n * @returns The normalized string.\n */\nexport function normalize(str: string): string {\n  return str.replace(/\\u00A0|\\u202F/g, ' ').normalize('NFC');\n}\n\n/**\n * Asynchronously replaces all occurrences of a search string or pattern with the results of an asynchronous replacer function.\n *\n * @typeParam Args - The type of additional arguments passed to the replacer function.\n * @param str - The string in which to perform replacements.\n * @param searchValue - The string or regular expression to search for.\n * @param replacer - An asynchronous function that generates replacement strings.\n * @returns A promise that resolves to the string with all replacements made.\n */\nexport async function replaceAllAsync<Args extends unknown[]>(\n  str: string,\n  searchValue: string | RegExp,\n  replacer: AsyncReplacer<Args>\n): Promise<string> {\n  const replacementPromises: Promise<string>[] = [];\n\n  str.replaceAll(searchValue, (substring: string, ...args: unknown[]) => {\n    replacementPromises.push(resolveValue(replacer, substring, ...args as [...Args]));\n    return substring;\n  });\n  const replacements = await Promise.all(replacementPromises);\n  return str.replaceAll(searchValue, (): string => replacements.shift() ?? throwExpression(new Error('Unexpected empty replacement')));\n}\n\n/**\n * Converts a string into a valid JavaScript variable name by replacing invalid characters with underscores.\n *\n * @param str - The string to convert.\n * @returns The valid variable name.\n */\nexport function makeValidVariableName(str: string): string {\n  return str.replace(/[^a-zA-Z0-9_]/g, '_');\n}\n\n/**\n * Ensures that a string starts with the specified prefix, adding it if necessary.\n *\n * @param str - The string to check.\n * @param prefix - The prefix to ensure.\n * @returns The string that starts with the prefix.\n */\nexport function ensureStartsWith(str: string, prefix: string): string {\n  return str.startsWith(prefix) ? str : prefix + str;\n}\n\n/**\n * Ensures that a string ends with the specified suffix, adding it if necessary.\n *\n * @param str - The string to check.\n * @param suffix - The suffix to ensure.\n * @returns The string that ends with the suffix.\n */\nexport function ensureEndsWith(str: string, suffix: string): string {\n  return str.endsWith(suffix) ? str : str + suffix;\n}\n\n/**\n * Escapes special characters in a string.\n *\n * @param str - The string to escape.\n * @returns The escaped string.\n */\nexport function escape(str: string): string {\n  return replace(str, ESCAPE_MAP);\n}\n\n/**\n * Unescapes a string by replacing escape sequences with their corresponding characters.\n *\n * @param str - The string to unescape.\n * @returns The unescaped string.\n */\nexport function unescape(str: string): string {\n  return replace(str, UNESCAPE_MAP);\n}\n\n/**\n * Replaces occurrences of strings in a given string based on a replacements map.\n *\n * @param str - The string to perform replacements on.\n * @param replacementsMap - An object mapping strings to their replacement values.\n * @returns The modified string with replacements applied.\n */\nexport function replace(str: string, replacementsMap: Record<string, string>): string {\n  const regExp = new RegExp(Object.keys(replacementsMap).map((source) => escapeRegExp(source)).join('|'), 'g');\n  return str.replaceAll(regExp, (source: string) => replacementsMap[source] ?? throwExpression(new Error(`Unexpected replacement source: ${source}`)));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,mBAAgC;AAChC,oBAA6B;AAE7B,2BAA6B;AAd7B,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAI;AAAC,MAAG,OAAO,eAAa,UAAS;AAAC,WAAO,IAAI,IAAI,OAAO,SAAS,IAAI;AAAA,EAAC;AAAC,SAAO,QAAQ,UAAU,EAAE,cAAc,UAAU;AAAC,GAAG;AAC5L,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AAmBA,MAAM,aAAqC;AAAA,EACzC,MAAM;AAAA,EACN,KAAK;AAAA,EACL,KAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AAAA,EACN,KAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AACR;AAKA,MAAM,eAAuC,CAAC;AAC9C,WAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,UAAU,GAAG;AACrD,eAAa,KAAK,IAAI;AACxB;AAWO,SAAS,UAAU,KAAa,QAAgB,UAA4B;AACjF,MAAI,IAAI,WAAW,MAAM,GAAG;AAC1B,WAAO,IAAI,MAAM,OAAO,MAAM;AAAA,EAChC;AAEA,MAAI,UAAU;AACZ,UAAM,IAAI,MAAM,UAAU,GAAG,+BAA+B,MAAM,EAAE;AAAA,EACtE;AAEA,SAAO;AACT;AAWO,SAAS,QAAQ,KAAa,QAAgB,UAA4B;AAC/E,MAAI,IAAI,SAAS,MAAM,GAAG;AACxB,WAAO,IAAI,MAAM,GAAG,CAAC,OAAO,MAAM;AAAA,EACpC;AAEA,MAAI,UAAU;AACZ,UAAM,IAAI,MAAM,UAAU,GAAG,6BAA6B,MAAM,EAAE;AAAA,EACpE;AAEA,SAAO;AACT;AAQO,SAAS,UAAU,KAAqB;AAC7C,SAAO,IAAI,QAAQ,kBAAkB,GAAG,EAAE,UAAU,KAAK;AAC3D;AAWA,eAAsB,gBACpB,KACA,aACA,UACiB;AACjB,QAAM,sBAAyC,CAAC;AAEhD,MAAI,WAAW,aAAa,CAAC,cAAsB,SAAoB;AACrE,wBAAoB,SAAK,mCAAa,UAAU,WAAW,GAAG,IAAiB,CAAC;AAChF,WAAO;AAAA,EACT,CAAC;AACD,QAAM,eAAe,MAAM,QAAQ,IAAI,mBAAmB;AAC1D,SAAO,IAAI,WAAW,aAAa,MAAc,aAAa,MAAM,SAAK,8BAAgB,IAAI,MAAM,8BAA8B,CAAC,CAAC;AACrI;AAQO,SAAS,sBAAsB,KAAqB;AACzD,SAAO,IAAI,QAAQ,kBAAkB,GAAG;AAC1C;AASO,SAAS,iBAAiB,KAAa,QAAwB;AACpE,SAAO,IAAI,WAAW,MAAM,IAAI,MAAM,SAAS;AACjD;AASO,SAAS,eAAe,KAAa,QAAwB;AAClE,SAAO,IAAI,SAAS,MAAM,IAAI,MAAM,MAAM;AAC5C;AAQO,SAAS,OAAO,KAAqB;AAC1C,SAAO,QAAQ,KAAK,UAAU;AAChC;AAQO,SAAS,SAAS,KAAqB;AAC5C,SAAO,QAAQ,KAAK,YAAY;AAClC;AASO,SAAS,QAAQ,KAAa,iBAAiD;AACpF,QAAM,SAAS,IAAI,OAAO,OAAO,KAAK,eAAe,EAAE,IAAI,CAAC,eAAW,4BAAa,MAAM,CAAC,EAAE,KAAK,GAAG,GAAG,GAAG;AAC3G,SAAO,IAAI,WAAW,QAAQ,CAAC,WAAmB,gBAAgB,MAAM,SAAK,8BAAgB,IAAI,MAAM,kCAAkC,MAAM,EAAE,CAAC,CAAC;AACrJ;",
  "names": []
}


package/dist/lib/obsidian/AttachmentPath.cjs

@@ -24,12 +24,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var AttachmentPath_exports = {};
 __export(AttachmentPath_exports, {
   getAttachmentFilePath: () => getAttachmentFilePath,
-  getAttachmentFolderPath: () => getAttachmentFolderPath
+  getAttachmentFolderPath: () => getAttachmentFolderPath,
+  getAvailablePathForAttachments: () => getAvailablePathForAttachments
 });
 module.exports = __toCommonJS(AttachmentPath_exports);
+var import_obsidian = require("obsidian");
 var import_implementations = require("obsidian-typings/implementations");
 var import_Path = require("../Path.cjs");
-var import_MetadataCache = require("./MetadataCache.cjs");
+var import_String = require("../String.cjs");
 var import_TAbstractFile = require("./TAbstractFile.cjs");
 var __import_meta_url = globalThis["import.meta.url"] ?? (() => {
   if (typeof __filename !== "string") {
@@ -51,44 +53,45 @@ async function getAttachmentFilePath(app, attachmentPathOrFile, notePathOrFile)
   const note = (0, import_implementations.createTFileInstance)(app.vault, notePath);
   const ext = (0, import_Path.extname)(attachmentPath);
   const fileName = (0, import_Path.basename)(attachmentPath, ext);
-  const unregisters = [];
-  const paths = /* @__PURE__ */ new Set();
-  const originalMkdir = app.vault.adapter.mkdir;
-  const alreadyPatched = originalMkdir.__patched ?? false;
-  if (!alreadyPatched) {
-    app.vault.adapter.mkdir = async (path) => {
-      const fakeFolder = (0, import_implementations.createTFolderInstance)(app.vault, path);
-      const unregister = (0, import_MetadataCache.registerFile)(app, fakeFolder);
-      unregisters.push(unregister);
-      paths.add(path);
-      await Promise.resolve();
-    };
-    app.vault.adapter.mkdir.__patched = true;
+  const internalFn = app.vault.getAvailablePathForAttachments.bind(app.vault);
+  if (internalFn.isExtended) {
+    return internalFn(fileName, ext.slice(1), note, true);
   }
-  let attachmentFolderPath = "";
-  try {
-    attachmentFolderPath = await app.vault.getAvailablePathForAttachments(fileName, ext.slice(1), note);
-    return attachmentFolderPath;
-  } finally {
-    if (!alreadyPatched) {
-      app.vault.adapter.mkdir = originalMkdir;
-      for (const unregister of unregisters) {
-        unregister();
-      }
-      for (const path of paths) {
-        if (path !== attachmentFolderPath) {
-          try {
-            await app.vault.adapter.mkdir(path);
-          } catch {
-          }
-        }
-      }
-    }
+  return await getAvailablePathForAttachments(app, fileName, ext.slice(1), note, true);
+}
+async function getAvailablePathForAttachments(app, filename, extension, file, skipFolderCreation) {
+  let attachmentFolderPath = app.vault.getConfig("attachmentFolderPath");
+  const isCurrentFolder = attachmentFolderPath === "." || attachmentFolderPath === "./";
+  let relativePath = null;
+  if (attachmentFolderPath.startsWith("./")) {
+    relativePath = (0, import_String.trimStart)(attachmentFolderPath, "./");
+  }
+  if (isCurrentFolder) {
+    attachmentFolderPath = file ? file.parent?.path ?? "" : "";
+  } else if (relativePath) {
+    attachmentFolderPath = (file ? file.parent?.getParentPrefix() ?? "" : "") + relativePath;
+  }
+  attachmentFolderPath = (0, import_String.normalize)(normalizeSlashes(attachmentFolderPath));
+  filename = (0, import_String.normalize)(normalizeSlashes(filename));
+  let folder = app.vault.getAbstractFileByPathInsensitive(attachmentFolderPath);
+  if (!folder && relativePath && !skipFolderCreation) {
+    folder = await app.vault.createFolder(attachmentFolderPath);
   }
+  if (folder instanceof import_obsidian.TFolder) {
+    return app.vault.getAvailablePath(folder.getParentPrefix() + filename, extension);
+  } else {
+    return app.vault.getAvailablePath(filename, extension);
+  }
+}
+function normalizeSlashes(path) {
+  path = path.replace(/([\\/])+/g, "/");
+  path = path.replace(/(^\/+|\/+$)/g, "");
+  return path || "/";
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getAttachmentFilePath,
-  getAttachmentFolderPath
+  getAttachmentFolderPath,
+  getAvailablePathForAttachments
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/AttachmentPath.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (()=>{if(typeof __filename!==\"string\"){return new URL(window.location.href)}return require(\"node:url\").pathToFileURL(__filename)})();\nvar __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation AttachmentPath\n * Provides utility functions for working with attachment paths.\n */\n\nimport type {\n  App,\n  TAbstractFile\n} from 'obsidian';\nimport { TFolder } from 'obsidian';\nimport { createTFileInstance } from 'obsidian-typings/implementations';\n\nimport {\n  basename,\n  dirname,\n  extname\n} from '../Path.ts';\nimport {\n  normalize,\n  trimStart\n} from '../String.ts';\nimport { getPath } from './TAbstractFile.ts';\nimport type { PathOrFile } from './TFile.ts';\n\n/**\n * Retrieves the attachment folder path for a given note.\n *\n * @param app - The Obsidian application instance.\n * @param notePathOrFile - The path of the note.\n * @returns A promise that resolves to the attachment folder path.\n */\nexport async function getAttachmentFolderPath(app: App, notePathOrFile: PathOrFile): Promise<string> {\n  return dirname(await getAttachmentFilePath(app, 'DUMMY_FILE.pdf', notePathOrFile));\n}\n\n/**\n * Is overridden wrapper.\n */\nexport interface ExtendedWrapper {\n  /**\n   * Is extended.\n   */\n  isExtended: true;\n}\n\n/**\n * Get available path for attachments function.\n */\nexport type GetAvailablePathForAttachmentsExtendedFn = (filename: string, extension: string, file: TAbstractFile | null, skipFolderCreation?: boolean) => Promise<string>;\n\n/**\n * Retrieves the file path for an attachment within a note.\n *\n * @param app - The Obsidian application instance.\n * @param attachmentPathOrFile - The path of the attachment.\n * @param notePathOrFile - The path of the note.\n * @returns A promise that resolves to the file path of the attachment.\n */\nexport async function getAttachmentFilePath(app: App, attachmentPathOrFile: PathOrFile, notePathOrFile: PathOrFile): Promise<string> {\n  const attachmentPath = getPath(attachmentPathOrFile);\n  const notePath = getPath(notePathOrFile);\n  const note = createTFileInstance(app.vault, notePath);\n  const ext = extname(attachmentPath);\n  const fileName = basename(attachmentPath, ext);\n\n  const internalFn = app.vault.getAvailablePathForAttachments.bind(app.vault);\n  if ((internalFn as Partial<ExtendedWrapper>).isExtended) {\n    return (internalFn as GetAvailablePathForAttachmentsExtendedFn)(fileName, ext.slice(1), note, true);\n  }\n\n  return await getAvailablePathForAttachments(app, fileName, ext.slice(1), note, true);\n}\n\n/**\n * Retrieves the available path for attachments.\n * @param app - The Obsidian application instance.\n * @param filename - Name of the file.\n * @param extension - Extension of the file.\n * @param file - The file to attach to.\n * @param skipFolderCreation - Should folder creation be skipped?\n * @returns A promise that resolves to the available path for attachments.\n */\nexport async function getAvailablePathForAttachments(app: App, filename: string, extension: string, file: TAbstractFile | null, skipFolderCreation: boolean): Promise<string> {\n  let attachmentFolderPath = app.vault.getConfig('attachmentFolderPath') as string;\n  const isCurrentFolder = attachmentFolderPath === '.' || attachmentFolderPath === './';\n  let relativePath = null;\n\n  if (attachmentFolderPath.startsWith('./')) {\n    relativePath = trimStart(attachmentFolderPath, './');\n  }\n\n  if (isCurrentFolder) {\n    attachmentFolderPath = file ? file.parent?.path ?? '' : '';\n  } else if (relativePath) {\n    attachmentFolderPath = (file ? file.parent?.getParentPrefix() ?? '' : '') + relativePath;\n  }\n\n  attachmentFolderPath = normalize(normalizeSlashes(attachmentFolderPath));\n  filename = normalize(normalizeSlashes(filename));\n\n  let folder = app.vault.getAbstractFileByPathInsensitive(attachmentFolderPath);\n\n  if (!folder && relativePath && !skipFolderCreation) {\n    folder = await app.vault.createFolder(attachmentFolderPath);\n  }\n\n  if (folder instanceof TFolder) {\n    return app.vault.getAvailablePath(folder.getParentPrefix() + filename, extension);\n  } else {\n    return app.vault.getAvailablePath(filename, extension);\n  }\n}\n\n/**\n * Normalizes a path by combining multiple slashes into a single slash and removing leading and trailing slashes.\n * @param path - Path to normalize.\n * @returns The normalized path.\n */\nfunction normalizeSlashes(path: string): string {\n  path = path.replace(/([\\\\/])+/g, '/');\n  path = path.replace(/(^\\/+|\\/+$)/g, '');\n  return path || '/';\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,sBAAwB;AACxB,6BAAoC;AAEpC,kBAIO;AACP,oBAGO;AACP,2BAAwB;AA3BxB,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAI;AAAC,MAAG,OAAO,eAAa,UAAS;AAAC,WAAO,IAAI,IAAI,OAAO,SAAS,IAAI;AAAA,EAAC;AAAC,SAAO,QAAQ,UAAU,EAAE,cAAc,UAAU;AAAC,GAAG;AAC5L,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AAgCA,eAAsB,wBAAwB,KAAU,gBAA6C;AACnG,aAAO,qBAAQ,MAAM,sBAAsB,KAAK,kBAAkB,cAAc,CAAC;AACnF;AAyBA,eAAsB,sBAAsB,KAAU,sBAAkC,gBAA6C;AACnI,QAAM,qBAAiB,8BAAQ,oBAAoB;AACnD,QAAM,eAAW,8BAAQ,cAAc;AACvC,QAAM,WAAO,4CAAoB,IAAI,OAAO,QAAQ;AACpD,QAAM,UAAM,qBAAQ,cAAc;AAClC,QAAM,eAAW,sBAAS,gBAAgB,GAAG;AAE7C,QAAM,aAAa,IAAI,MAAM,+BAA+B,KAAK,IAAI,KAAK;AAC1E,MAAK,WAAwC,YAAY;AACvD,WAAQ,WAAwD,UAAU,IAAI,MAAM,CAAC,GAAG,MAAM,IAAI;AAAA,EACpG;AAEA,SAAO,MAAM,+BAA+B,KAAK,UAAU,IAAI,MAAM,CAAC,GAAG,MAAM,IAAI;AACrF;AAWA,eAAsB,+BAA+B,KAAU,UAAkB,WAAmB,MAA4B,oBAA8C;AAC5K,MAAI,uBAAuB,IAAI,MAAM,UAAU,sBAAsB;AACrE,QAAM,kBAAkB,yBAAyB,OAAO,yBAAyB;AACjF,MAAI,eAAe;AAEnB,MAAI,qBAAqB,WAAW,IAAI,GAAG;AACzC,uBAAe,yBAAU,sBAAsB,IAAI;AAAA,EACrD;AAEA,MAAI,iBAAiB;AACnB,2BAAuB,OAAO,KAAK,QAAQ,QAAQ,KAAK;AAAA,EAC1D,WAAW,cAAc;AACvB,4BAAwB,OAAO,KAAK,QAAQ,gBAAgB,KAAK,KAAK,MAAM;AAAA,EAC9E;AAEA,6BAAuB,yBAAU,iBAAiB,oBAAoB,CAAC;AACvE,iBAAW,yBAAU,iBAAiB,QAAQ,CAAC;AAE/C,MAAI,SAAS,IAAI,MAAM,iCAAiC,oBAAoB;AAE5E,MAAI,CAAC,UAAU,gBAAgB,CAAC,oBAAoB;AAClD,aAAS,MAAM,IAAI,MAAM,aAAa,oBAAoB;AAAA,EAC5D;AAEA,MAAI,kBAAkB,yBAAS;AAC7B,WAAO,IAAI,MAAM,iBAAiB,OAAO,gBAAgB,IAAI,UAAU,SAAS;AAAA,EAClF,OAAO;AACL,WAAO,IAAI,MAAM,iBAAiB,UAAU,SAAS;AAAA,EACvD;AACF;AAOA,SAAS,iBAAiB,MAAsB;AAC9C,SAAO,KAAK,QAAQ,aAAa,GAAG;AACpC,SAAO,KAAK,QAAQ,gBAAgB,EAAE;AACtC,SAAO,QAAQ;AACjB;",
  "names": []
}


package/dist/lib/obsidian/AttachmentPath.d.ts

@@ -2,7 +2,7 @@
  * @packageDocumentation AttachmentPath
  * Provides utility functions for working with attachment paths.
  */
-import type { App } from 'obsidian';
+import type { App, TAbstractFile } from 'obsidian';
 import type { PathOrFile } from './TFile.ts';
 /**
  * Retrieves the attachment folder path for a given note.
@@ -12,6 +12,19 @@ import type { PathOrFile } from './TFile.ts';
  * @returns A promise that resolves to the attachment folder path.
  */
 export declare function getAttachmentFolderPath(app: App, notePathOrFile: PathOrFile): Promise<string>;
+/**
+ * Is overridden wrapper.
+ */
+export interface ExtendedWrapper {
+    /**
+     * Is extended.
+     */
+    isExtended: true;
+}
+/**
+ * Get available path for attachments function.
+ */
+export type GetAvailablePathForAttachmentsExtendedFn = (filename: string, extension: string, file: TAbstractFile | null, skipFolderCreation?: boolean) => Promise<string>;
 /**
  * Retrieves the file path for an attachment within a note.
  *
@@ -21,3 +34,13 @@ export declare function getAttachmentFolderPath(app: App, notePathOrFile: PathOr
  * @returns A promise that resolves to the file path of the attachment.
  */
 export declare function getAttachmentFilePath(app: App, attachmentPathOrFile: PathOrFile, notePathOrFile: PathOrFile): Promise<string>;
+/**
+ * Retrieves the available path for attachments.
+ * @param app - The Obsidian application instance.
+ * @param filename - Name of the file.
+ * @param extension - Extension of the file.
+ * @param file - The file to attach to.
+ * @param skipFolderCreation - Should folder creation be skipped?
+ * @returns A promise that resolves to the available path for attachments.
+ */
+export declare function getAvailablePathForAttachments(app: App, filename: string, extension: string, file: TAbstractFile | null, skipFolderCreation: boolean): Promise<string>;

package/dist/lib/obsidian/RenameDeleteHandler.cjs

@@ -0,0 +1,284 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RenameDeleteHandler_exports = {};
+__export(RenameDeleteHandler_exports, {
+  RenameDeleteHandler: () => RenameDeleteHandler
+});
+module.exports = __toCommonJS(RenameDeleteHandler_exports);
+var import_obsidian = require("obsidian");
+var import_implementations = require("obsidian-typings/implementations");
+var import_Object = require("../Object.cjs");
+var import_Path = require("../Path.cjs");
+var import_AttachmentPath = require("./AttachmentPath.cjs");
+var import_Link = require("./Link.cjs");
+var import_MetadataCache = require("./MetadataCache.cjs");
+var import_TAbstractFile = require("./TAbstractFile.cjs");
+var import_Vault = require("./Vault.cjs");
+var __import_meta_url = globalThis["import.meta.url"] ?? (() => {
+  if (typeof __filename !== "string") {
+    return new URL(window.location.href);
+  }
+  return require("node:url").pathToFileURL(__filename);
+})();
+var __process = globalThis["process"] ?? {
+  "cwd": () => "/",
+  "env": {},
+  "platform": "android"
+};
+class RenameDeleteHandler {
+  constructor(app, settingsBuilder) {
+    this.app = app;
+    this.settingsBuilder = settingsBuilder;
+  }
+  renamingPaths = /* @__PURE__ */ new Set();
+  specialRenames = [];
+  async handleRename(file, oldPath) {
+    console.debug(`Handle Rename ${oldPath} -> ${file.path}`);
+    if (this.renamingPaths.has(oldPath)) {
+      return;
+    }
+    if (!(file instanceof import_obsidian.TFile)) {
+      return;
+    }
+    const specialRename = this.specialRenames.find((x) => x.oldPath === file.path);
+    if (specialRename) {
+      await this.app.vault.rename(file, specialRename.tempPath);
+      return;
+    }
+    if (this.app.vault.adapter.insensitive && oldPath.toLowerCase() === file.path.toLowerCase() && (0, import_Path.dirname)(oldPath) === (0, import_Path.dirname)(file.path)) {
+      this.specialRenames.push({
+        oldPath,
+        newPath: file.path,
+        tempPath: (0, import_Path.join)(file.parent?.path ?? "", "__temp__" + file.name)
+      });
+      await this.app.vault.rename(file, oldPath);
+      return;
+    }
+    const updateAllLinks = this.app.fileManager.updateAllLinks;
+    try {
+      this.app.fileManager.updateAllLinks = async () => {
+      };
+      const renameMap = /* @__PURE__ */ new Map();
+      await this.fillRenameMap(file, oldPath, renameMap);
+      for (const oldPath2 of renameMap.keys()) {
+        this.renamingPaths.add(oldPath2);
+      }
+      for (const [oldPath2, newPath2] of renameMap.entries()) {
+        await this.processRename(oldPath2, newPath2, renameMap);
+      }
+      await this.processRename(oldPath, file.path, renameMap);
+    } finally {
+      this.renamingPaths.delete(oldPath);
+      this.app.fileManager.updateAllLinks = updateAllLinks;
+      const specialRename2 = this.specialRenames.find((x) => x.tempPath === file.path);
+      if (specialRename2) {
+        await this.app.vault.rename(file, specialRename2.newPath);
+        this.specialRenames.remove(specialRename2);
+      }
+    }
+  }
+  async handleDelete(file) {
+    console.debug(`Handle Delete ${file.path}`);
+    if (!(0, import_TAbstractFile.isNote)(file)) {
+      return;
+    }
+    if (this.renamingPaths.has(file.path)) {
+      return;
+    }
+    const attachmentFolder = await (0, import_AttachmentPath.getAttachmentFolderPath)(this.app, file.path);
+    await (0, import_Vault.removeFolderSafe)(this.app, attachmentFolder, file.path);
+  }
+  async fillRenameMap(file, oldPath, renameMap) {
+    renameMap.set(oldPath, file.path);
+    if (!(0, import_TAbstractFile.isNote)(file)) {
+      return;
+    }
+    const oldAttachmentFolderPath = await (0, import_AttachmentPath.getAttachmentFolderPath)(this.app, oldPath);
+    const newAttachmentFolderPath = await (0, import_AttachmentPath.getAttachmentFolderPath)(this.app, file.path);
+    const dummyOldAttachmentFolderPath = await (0, import_AttachmentPath.getAttachmentFolderPath)(this.app, (0, import_Path.join)((0, import_Path.dirname)(oldPath), "DUMMY_FILE.md"));
+    const oldAttachmentFolder = this.app.vault.getFolderByPath(oldAttachmentFolderPath);
+    if (!oldAttachmentFolder) {
+      return;
+    }
+    if (oldAttachmentFolderPath === newAttachmentFolderPath) {
+      return;
+    }
+    const children = [];
+    if (oldAttachmentFolderPath === dummyOldAttachmentFolderPath) {
+      const cache = await (0, import_MetadataCache.getCacheSafe)(this.app, file);
+      if (!cache) {
+        return;
+      }
+      for (const link of (0, import_MetadataCache.getAllLinks)(cache)) {
+        const attachmentFile = (0, import_Link.extractLinkFile)(this.app, link, oldPath);
+        if (!attachmentFile) {
+          continue;
+        }
+        if (attachmentFile.path.startsWith(oldAttachmentFolderPath)) {
+          const backlinks = await (0, import_MetadataCache.getBacklinksForFileSafe)(this.app, attachmentFile);
+          if (backlinks.keys().length === 1) {
+            children.push(attachmentFile);
+          }
+        }
+      }
+    } else {
+      import_obsidian.Vault.recurseChildren(oldAttachmentFolder, (child) => {
+        if (child instanceof import_obsidian.TFile) {
+          children.push(child);
+        }
+      });
+    }
+    for (const child of children) {
+      if ((0, import_TAbstractFile.isNote)(child)) {
+        continue;
+      }
+      const relativePath = (0, import_Path.relative)(oldAttachmentFolderPath, child.path);
+      const newDir = (0, import_Path.join)(newAttachmentFolderPath, (0, import_Path.dirname)(relativePath));
+      let newChildPath = (0, import_Path.join)(newDir, child.name);
+      if (child.path !== newChildPath) {
+        newChildPath = this.app.vault.getAvailablePath((0, import_Path.join)(newDir, child.basename), child.extension);
+        renameMap.set(child.path, newChildPath);
+      }
+    }
+  }
+  async processRename(oldPath, newPath, renameMap) {
+    let oldFile = null;
+    try {
+      oldFile = this.app.vault.getFileByPath(oldPath);
+      let newFile = this.app.vault.getFileByPath(newPath);
+      if (oldFile) {
+        await (0, import_Vault.createFolderSafe)(this.app, (0, import_Path.dirname)(newPath));
+        const oldFolder = oldFile.parent;
+        try {
+          if (newFile) {
+            try {
+              await this.app.vault.delete(newFile);
+            } catch (e) {
+              if (this.app.vault.getAbstractFileByPath(newPath)) {
+                throw e;
+              }
+            }
+          }
+          await this.app.vault.rename(oldFile, newPath);
+        } catch (e) {
+          if (!this.app.vault.getAbstractFileByPath(newPath) || this.app.vault.getAbstractFileByPath(oldPath)) {
+            throw e;
+          }
+        }
+        if (this.settingsBuilder().shouldDeleteEmptyFolders) {
+          await (0, import_Vault.removeEmptyFolderHierarchy)(this.app, oldFolder);
+        }
+      }
+      oldFile = (0, import_implementations.createTFileInstance)(this.app.vault, oldPath);
+      newFile = this.app.vault.getFileByPath(newPath);
+      if (!oldFile.deleted || !newFile) {
+        throw new Error(`Could not rename ${oldPath} to ${newPath}`);
+      }
+      const backlinks = await this.getBacklinks(oldFile, newFile);
+      for (const parentNotePath of backlinks.keys()) {
+        let parentNote = this.app.vault.getFileByPath(parentNotePath);
+        if (!parentNote) {
+          const newParentNotePath = renameMap.get(parentNotePath);
+          if (newParentNotePath) {
+            parentNote = this.app.vault.getFileByPath(newParentNotePath);
+          }
+        }
+        if (!parentNote) {
+          console.warn(`Parent note not found: ${parentNotePath}`);
+          continue;
+        }
+        await (0, import_Vault.applyFileChanges)(this.app, parentNote, async () => {
+          if (!oldFile) {
+            return [];
+          }
+          const links = (await this.getBacklinks(oldFile, newFile)).get(parentNotePath) ?? [];
+          const changes = [];
+          for (const link of links) {
+            changes.push({
+              startIndex: link.position.start.offset,
+              endIndex: link.position.end.offset,
+              oldContent: link.original,
+              newContent: (0, import_Link.updateLink)({
+                app: this.app,
+                link,
+                pathOrFile: newFile,
+                oldPathOrFile: oldPath,
+                sourcePathOrFile: parentNote,
+                renameMap
+              })
+            });
+          }
+          return changes;
+        });
+      }
+      if ((0, import_TAbstractFile.isCanvasFile)(newFile)) {
+        await (0, import_Vault.processWithRetry)(this.app, newFile, (content) => {
+          const canvasData = JSON.parse(content);
+          for (const node of canvasData.nodes) {
+            if (node.type !== "file") {
+              continue;
+            }
+            const newPath2 = renameMap.get(node.file);
+            if (!newPath2) {
+              continue;
+            }
+            node.file = newPath2;
+          }
+          return (0, import_Object.toJson)(canvasData);
+        });
+      } else if ((0, import_TAbstractFile.isMarkdownFile)(newFile)) {
+        await (0, import_Link.updateLinksInFile)({
+          app: this.app,
+          pathOrFile: newFile,
+          oldPathOrFile: oldPath,
+          renameMap
+        });
+      }
+    } finally {
+      this.renamingPaths.delete(oldPath);
+    }
+  }
+  async getBacklinks(oldFile, newFile) {
+    const backlinks = /* @__PURE__ */ new Map();
+    const oldLinks = await (0, import_MetadataCache.getBacklinksForFileSafe)(this.app, oldFile);
+    for (const path of oldLinks.keys()) {
+      backlinks.set(path, oldLinks.get(path) ?? []);
+    }
+    if (!newFile) {
+      return backlinks;
+    }
+    const newLinks = await (0, import_MetadataCache.getBacklinksForFileSafe)(this.app, newFile);
+    for (const path of newLinks.keys()) {
+      const links = backlinks.get(path) ?? [];
+      links.push(...newLinks.get(path) ?? []);
+      backlinks.set(path, links);
+    }
+    return backlinks;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RenameDeleteHandler
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/RenameDeleteHandler.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (()=>{if(typeof __filename!==\"string\"){return new URL(window.location.href)}return require(\"node:url\").pathToFileURL(__filename)})();\nvar __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\nimport type {\n  ReferenceCache,\n  TAbstractFile\n} from 'obsidian';\nimport {\n  App,\n  TFile,\n  Vault\n} from 'obsidian';\nimport type { CanvasData } from 'obsidian/canvas.js';\nimport { createTFileInstance } from 'obsidian-typings/implementations';\n\nimport { toJson } from '../Object.ts';\nimport {\n  dirname,\n  join,\n  relative\n} from '../Path.ts';\nimport { getAttachmentFolderPath } from './AttachmentPath.ts';\nimport {\n  extractLinkFile,\n  updateLink,\n  updateLinksInFile\n} from './Link.ts';\nimport {\n  getAllLinks,\n  getBacklinksForFileSafe,\n  getCacheSafe\n} from './MetadataCache.ts';\nimport {\n  isCanvasFile,\n  isMarkdownFile,\n  isNote\n} from './TAbstractFile.ts';\nimport {\n  applyFileChanges,\n  createFolderSafe,\n  processWithRetry,\n  removeEmptyFolderHierarchy,\n  removeFolderSafe\n} from './Vault.ts';\n\ninterface SpecialRename {\n  oldPath: string;\n  newPath: string;\n  tempPath: string;\n}\n\ninterface RenameDeleteHandlerSettings {\n  shouldDeleteEmptyFolders: boolean;\n}\n\n/**\n * Handles renaming and deleting files.\n */\nexport class RenameDeleteHandler {\n  public constructor(private app: App, private settingsBuilder: () => RenameDeleteHandlerSettings) { }\n\n  private renamingPaths = new Set<string>();\n  private specialRenames: SpecialRename[] = [];\n\n  public async handleRename(file: TAbstractFile, oldPath: string): Promise<void> {\n    console.debug(`Handle Rename ${oldPath} -> ${file.path}`);\n\n    if (this.renamingPaths.has(oldPath)) {\n      return;\n    }\n\n    if (!(file instanceof TFile)) {\n      return;\n    }\n\n    const specialRename = this.specialRenames.find((x) => x.oldPath === file.path);\n    if (specialRename) {\n      await this.app.vault.rename(file, specialRename.tempPath);\n      return;\n    }\n\n    if (this.app.vault.adapter.insensitive && oldPath.toLowerCase() === file.path.toLowerCase() && dirname(oldPath) === dirname(file.path)) {\n      this.specialRenames.push({\n        oldPath,\n        newPath: file.path,\n        tempPath: join(file.parent?.path ?? '', '__temp__' + file.name)\n      });\n\n      await this.app.vault.rename(file, oldPath);\n      return;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const updateAllLinks = this.app.fileManager.updateAllLinks;\n    try {\n      this.app.fileManager.updateAllLinks = async (): Promise<void> => {\n        // do nothing\n      };\n\n      const renameMap = new Map<string, string>();\n      await this.fillRenameMap(file, oldPath, renameMap);\n      for (const oldPath of renameMap.keys()) {\n        this.renamingPaths.add(oldPath);\n      }\n\n      for (const [oldPath2, newPath2] of renameMap.entries()) {\n        await this.processRename(oldPath2, newPath2, renameMap);\n      }\n\n      await this.processRename(oldPath, file.path, renameMap);\n    } finally {\n      this.renamingPaths.delete(oldPath);\n      this.app.fileManager.updateAllLinks = updateAllLinks;\n\n      const specialRename = this.specialRenames.find((x) => x.tempPath === file.path);\n      if (specialRename) {\n        await this.app.vault.rename(file, specialRename.newPath);\n        this.specialRenames.remove(specialRename);\n      }\n    }\n  }\n\n  public async handleDelete(file: TAbstractFile): Promise<void> {\n    console.debug(`Handle Delete ${file.path}`);\n    if (!isNote(file)) {\n      return;\n    }\n\n    if (this.renamingPaths.has(file.path)) {\n      return;\n    }\n\n    const attachmentFolder = await getAttachmentFolderPath(this.app, file.path);\n    await removeFolderSafe(this.app, attachmentFolder, file.path);\n  }\n\n  private async fillRenameMap(file: TFile, oldPath: string, renameMap: Map<string, string>): Promise<void> {\n    renameMap.set(oldPath, file.path);\n\n    if (!isNote(file)) {\n      return;\n    }\n\n    const oldAttachmentFolderPath = await getAttachmentFolderPath(this.app, oldPath);\n    const newAttachmentFolderPath = await getAttachmentFolderPath(this.app, file.path);\n    const dummyOldAttachmentFolderPath = await getAttachmentFolderPath(this.app, join(dirname(oldPath), 'DUMMY_FILE.md'));\n\n    const oldAttachmentFolder = this.app.vault.getFolderByPath(oldAttachmentFolderPath);\n\n    if (!oldAttachmentFolder) {\n      return;\n    }\n\n    if (oldAttachmentFolderPath === newAttachmentFolderPath) {\n      return;\n    }\n\n    const children: TFile[] = [];\n\n    if (oldAttachmentFolderPath === dummyOldAttachmentFolderPath) {\n      const cache = await getCacheSafe(this.app, file);\n      if (!cache) {\n        return;\n      }\n      for (const link of getAllLinks(cache)) {\n        const attachmentFile = extractLinkFile(this.app, link, oldPath);\n        if (!attachmentFile) {\n          continue;\n        }\n\n        if (attachmentFile.path.startsWith(oldAttachmentFolderPath)) {\n          const backlinks = await getBacklinksForFileSafe(this.app, attachmentFile);\n          if (backlinks.keys().length === 1) {\n            children.push(attachmentFile);\n          }\n        }\n      }\n    } else {\n      Vault.recurseChildren(oldAttachmentFolder, (child) => {\n        if (child instanceof TFile) {\n          children.push(child);\n        }\n      });\n    }\n\n    for (const child of children) {\n      if (isNote(child)) {\n        continue;\n      }\n      const relativePath = relative(oldAttachmentFolderPath, child.path);\n      const newDir = join(newAttachmentFolderPath, dirname(relativePath));\n      let newChildPath = join(newDir, child.name);\n      if (child.path !== newChildPath) {\n        newChildPath = this.app.vault.getAvailablePath(join(newDir, child.basename), child.extension);\n        renameMap.set(child.path, newChildPath);\n      }\n    }\n  }\n\n  private async processRename(oldPath: string, newPath: string, renameMap: Map<string, string>): Promise<void> {\n    let oldFile: TFile | null = null;\n\n    try {\n      oldFile = this.app.vault.getFileByPath(oldPath);\n      let newFile = this.app.vault.getFileByPath(newPath);\n\n      if (oldFile) {\n        await createFolderSafe(this.app, dirname(newPath));\n        const oldFolder = oldFile.parent;\n        try {\n          if (newFile) {\n            try {\n              await this.app.vault.delete(newFile);\n            } catch (e) {\n              if (this.app.vault.getAbstractFileByPath(newPath)) {\n                throw e;\n              }\n            }\n          }\n          await this.app.vault.rename(oldFile, newPath);\n        } catch (e) {\n          if (!this.app.vault.getAbstractFileByPath(newPath) || this.app.vault.getAbstractFileByPath(oldPath)) {\n            throw e;\n          }\n        }\n        if (this.settingsBuilder().shouldDeleteEmptyFolders) {\n          await removeEmptyFolderHierarchy(this.app, oldFolder);\n        }\n      }\n\n      oldFile = createTFileInstance(this.app.vault, oldPath);\n      newFile = this.app.vault.getFileByPath(newPath);\n\n      if (!oldFile.deleted || !newFile) {\n        throw new Error(`Could not rename ${oldPath} to ${newPath}`);\n      }\n\n      const backlinks = await this.getBacklinks(oldFile, newFile);\n\n      for (const parentNotePath of backlinks.keys()) {\n        let parentNote = this.app.vault.getFileByPath(parentNotePath);\n        if (!parentNote) {\n          const newParentNotePath = renameMap.get(parentNotePath);\n          if (newParentNotePath) {\n            parentNote = this.app.vault.getFileByPath(newParentNotePath);\n          }\n        }\n\n        if (!parentNote) {\n          console.warn(`Parent note not found: ${parentNotePath}`);\n          continue;\n        }\n\n        await applyFileChanges(this.app, parentNote, async () => {\n          if (!oldFile) {\n            return [];\n          }\n          const links\n            = (await this.getBacklinks(oldFile, newFile)).get(parentNotePath) ?? [];\n          const changes = [];\n\n          for (const link of links) {\n            changes.push({\n              startIndex: link.position.start.offset,\n              endIndex: link.position.end.offset,\n              oldContent: link.original,\n              newContent: updateLink({\n                app: this.app,\n                link,\n                pathOrFile: newFile,\n                oldPathOrFile: oldPath,\n                sourcePathOrFile: parentNote,\n                renameMap\n              })\n            });\n          }\n\n          return changes;\n        });\n      }\n\n      if (isCanvasFile(newFile)) {\n        await processWithRetry(this.app, newFile, (content) => {\n          const canvasData = JSON.parse(content) as CanvasData;\n          for (const node of canvasData.nodes) {\n            if (node.type !== 'file') {\n              continue;\n            }\n            const newPath = renameMap.get(node.file);\n            if (!newPath) {\n              continue;\n            }\n            node.file = newPath;\n          }\n          return toJson(canvasData);\n        });\n      } else if (isMarkdownFile(newFile)) {\n        await updateLinksInFile({\n          app: this.app,\n          pathOrFile: newFile,\n          oldPathOrFile: oldPath,\n          renameMap\n        });\n      }\n    } finally {\n      this.renamingPaths.delete(oldPath);\n    }\n  }\n\n  private async getBacklinks(oldFile: TFile, newFile: TFile | null): Promise<Map<string, ReferenceCache[]>> {\n    const backlinks = new Map<string, ReferenceCache[]>();\n    const oldLinks = await getBacklinksForFileSafe(this.app, oldFile);\n    for (const path of oldLinks.keys()) {\n      backlinks.set(path, oldLinks.get(path) ?? []);\n    }\n\n    if (!newFile) {\n      return backlinks;\n    }\n\n    const newLinks = await getBacklinksForFileSafe(this.app, newFile);\n\n    for (const path of newLinks.keys()) {\n      const links = backlinks.get(path) ?? [];\n      links.push(...newLinks.get(path) ?? []);\n      backlinks.set(path, links);\n    }\n\n    return backlinks;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,sBAIO;AAEP,6BAAoC;AAEpC,oBAAuB;AACvB,kBAIO;AACP,4BAAwC;AACxC,kBAIO;AACP,2BAIO;AACP,2BAIO;AACP,mBAMO;AA9CP,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAI;AAAC,MAAG,OAAO,eAAa,UAAS;AAAC,WAAO,IAAI,IAAI,OAAO,SAAS,IAAI;AAAA,EAAC;AAAC,SAAO,QAAQ,UAAU,EAAE,cAAc,UAAU;AAAC,GAAG;AAC5L,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AAwDO,MAAM,oBAAoB;AAAA,EACxB,YAAoB,KAAkB,iBAAoD;AAAtE;AAAkB;AAAA,EAAsD;AAAA,EAE3F,gBAAgB,oBAAI,IAAY;AAAA,EAChC,iBAAkC,CAAC;AAAA,EAE3C,MAAa,aAAa,MAAqB,SAAgC;AAC7E,YAAQ,MAAM,iBAAiB,OAAO,OAAO,KAAK,IAAI,EAAE;AAExD,QAAI,KAAK,cAAc,IAAI,OAAO,GAAG;AACnC;AAAA,IACF;AAEA,QAAI,EAAE,gBAAgB,wBAAQ;AAC5B;AAAA,IACF;AAEA,UAAM,gBAAgB,KAAK,eAAe,KAAK,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI;AAC7E,QAAI,eAAe;AACjB,YAAM,KAAK,IAAI,MAAM,OAAO,MAAM,cAAc,QAAQ;AACxD;AAAA,IACF;AAEA,QAAI,KAAK,IAAI,MAAM,QAAQ,eAAe,QAAQ,YAAY,MAAM,KAAK,KAAK,YAAY,SAAK,qBAAQ,OAAO,UAAM,qBAAQ,KAAK,IAAI,GAAG;AACtI,WAAK,eAAe,KAAK;AAAA,QACvB;AAAA,QACA,SAAS,KAAK;AAAA,QACd,cAAU,kBAAK,KAAK,QAAQ,QAAQ,IAAI,aAAa,KAAK,IAAI;AAAA,MAChE,CAAC;AAED,YAAM,KAAK,IAAI,MAAM,OAAO,MAAM,OAAO;AACzC;AAAA,IACF;AAGA,UAAM,iBAAiB,KAAK,IAAI,YAAY;AAC5C,QAAI;AACF,WAAK,IAAI,YAAY,iBAAiB,YAA2B;AAAA,MAEjE;AAEA,YAAM,YAAY,oBAAI,IAAoB;AAC1C,YAAM,KAAK,cAAc,MAAM,SAAS,SAAS;AACjD,iBAAWA,YAAW,UAAU,KAAK,GAAG;AACtC,aAAK,cAAc,IAAIA,QAAO;AAAA,MAChC;AAEA,iBAAW,CAAC,UAAU,QAAQ,KAAK,UAAU,QAAQ,GAAG;AACtD,cAAM,KAAK,cAAc,UAAU,UAAU,SAAS;AAAA,MACxD;AAEA,YAAM,KAAK,cAAc,SAAS,KAAK,MAAM,SAAS;AAAA,IACxD,UAAE;AACA,WAAK,cAAc,OAAO,OAAO;AACjC,WAAK,IAAI,YAAY,iBAAiB;AAEtC,YAAMC,iBAAgB,KAAK,eAAe,KAAK,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI;AAC9E,UAAIA,gBAAe;AACjB,cAAM,KAAK,IAAI,MAAM,OAAO,MAAMA,eAAc,OAAO;AACvD,aAAK,eAAe,OAAOA,cAAa;AAAA,MAC1C;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAa,aAAa,MAAoC;AAC5D,YAAQ,MAAM,iBAAiB,KAAK,IAAI,EAAE;AAC1C,QAAI,KAAC,6BAAO,IAAI,GAAG;AACjB;AAAA,IACF;AAEA,QAAI,KAAK,cAAc,IAAI,KAAK,IAAI,GAAG;AACrC;AAAA,IACF;AAEA,UAAM,mBAAmB,UAAM,+CAAwB,KAAK,KAAK,KAAK,IAAI;AAC1E,cAAM,+BAAiB,KAAK,KAAK,kBAAkB,KAAK,IAAI;AAAA,EAC9D;AAAA,EAEA,MAAc,cAAc,MAAa,SAAiB,WAA+C;AACvG,cAAU,IAAI,SAAS,KAAK,IAAI;AAEhC,QAAI,KAAC,6BAAO,IAAI,GAAG;AACjB;AAAA,IACF;AAEA,UAAM,0BAA0B,UAAM,+CAAwB,KAAK,KAAK,OAAO;AAC/E,UAAM,0BAA0B,UAAM,+CAAwB,KAAK,KAAK,KAAK,IAAI;AACjF,UAAM,+BAA+B,UAAM,+CAAwB,KAAK,SAAK,sBAAK,qBAAQ,OAAO,GAAG,eAAe,CAAC;AAEpH,UAAM,sBAAsB,KAAK,IAAI,MAAM,gBAAgB,uBAAuB;AAElF,QAAI,CAAC,qBAAqB;AACxB;AAAA,IACF;AAEA,QAAI,4BAA4B,yBAAyB;AACvD;AAAA,IACF;AAEA,UAAM,WAAoB,CAAC;AAE3B,QAAI,4BAA4B,8BAA8B;AAC5D,YAAM,QAAQ,UAAM,mCAAa,KAAK,KAAK,IAAI;AAC/C,UAAI,CAAC,OAAO;AACV;AAAA,MACF;AACA,iBAAW,YAAQ,kCAAY,KAAK,GAAG;AACrC,cAAM,qBAAiB,6BAAgB,KAAK,KAAK,MAAM,OAAO;AAC9D,YAAI,CAAC,gBAAgB;AACnB;AAAA,QACF;AAEA,YAAI,eAAe,KAAK,WAAW,uBAAuB,GAAG;AAC3D,gBAAM,YAAY,UAAM,8CAAwB,KAAK,KAAK,cAAc;AACxE,cAAI,UAAU,KAAK,EAAE,WAAW,GAAG;AACjC,qBAAS,KAAK,cAAc;AAAA,UAC9B;AAAA,QACF;AAAA,MACF;AAAA,IACF,OAAO;AACL,4BAAM,gBAAgB,qBAAqB,CAAC,UAAU;AACpD,YAAI,iBAAiB,uBAAO;AAC1B,mBAAS,KAAK,KAAK;AAAA,QACrB;AAAA,MACF,CAAC;AAAA,IACH;AAEA,eAAW,SAAS,UAAU;AAC5B,cAAI,6BAAO,KAAK,GAAG;AACjB;AAAA,MACF;AACA,YAAM,mBAAe,sBAAS,yBAAyB,MAAM,IAAI;AACjE,YAAM,aAAS,kBAAK,6BAAyB,qBAAQ,YAAY,CAAC;AAClE,UAAI,mBAAe,kBAAK,QAAQ,MAAM,IAAI;AAC1C,UAAI,MAAM,SAAS,cAAc;AAC/B,uBAAe,KAAK,IAAI,MAAM,qBAAiB,kBAAK,QAAQ,MAAM,QAAQ,GAAG,MAAM,SAAS;AAC5F,kBAAU,IAAI,MAAM,MAAM,YAAY;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAc,cAAc,SAAiB,SAAiB,WAA+C;AAC3G,QAAI,UAAwB;AAE5B,QAAI;AACF,gBAAU,KAAK,IAAI,MAAM,cAAc,OAAO;AAC9C,UAAI,UAAU,KAAK,IAAI,MAAM,cAAc,OAAO;AAElD,UAAI,SAAS;AACX,kBAAM,+BAAiB,KAAK,SAAK,qBAAQ,OAAO,CAAC;AACjD,cAAM,YAAY,QAAQ;AAC1B,YAAI;AACF,cAAI,SAAS;AACX,gBAAI;AACF,oBAAM,KAAK,IAAI,MAAM,OAAO,OAAO;AAAA,YACrC,SAAS,GAAG;AACV,kBAAI,KAAK,IAAI,MAAM,sBAAsB,OAAO,GAAG;AACjD,sBAAM;AAAA,cACR;AAAA,YACF;AAAA,UACF;AACA,gBAAM,KAAK,IAAI,MAAM,OAAO,SAAS,OAAO;AAAA,QAC9C,SAAS,GAAG;AACV,cAAI,CAAC,KAAK,IAAI,MAAM,sBAAsB,OAAO,KAAK,KAAK,IAAI,MAAM,sBAAsB,OAAO,GAAG;AACnG,kBAAM;AAAA,UACR;AAAA,QACF;AACA,YAAI,KAAK,gBAAgB,EAAE,0BAA0B;AACnD,oBAAM,yCAA2B,KAAK,KAAK,SAAS;AAAA,QACtD;AAAA,MACF;AAEA,oBAAU,4CAAoB,KAAK,IAAI,OAAO,OAAO;AACrD,gBAAU,KAAK,IAAI,MAAM,cAAc,OAAO;AAE9C,UAAI,CAAC,QAAQ,WAAW,CAAC,SAAS;AAChC,cAAM,IAAI,MAAM,oBAAoB,OAAO,OAAO,OAAO,EAAE;AAAA,MAC7D;AAEA,YAAM,YAAY,MAAM,KAAK,aAAa,SAAS,OAAO;AAE1D,iBAAW,kBAAkB,UAAU,KAAK,GAAG;AAC7C,YAAI,aAAa,KAAK,IAAI,MAAM,cAAc,cAAc;AAC5D,YAAI,CAAC,YAAY;AACf,gBAAM,oBAAoB,UAAU,IAAI,cAAc;AACtD,cAAI,mBAAmB;AACrB,yBAAa,KAAK,IAAI,MAAM,cAAc,iBAAiB;AAAA,UAC7D;AAAA,QACF;AAEA,YAAI,CAAC,YAAY;AACf,kBAAQ,KAAK,0BAA0B,cAAc,EAAE;AACvD;AAAA,QACF;AAEA,kBAAM,+BAAiB,KAAK,KAAK,YAAY,YAAY;AACvD,cAAI,CAAC,SAAS;AACZ,mBAAO,CAAC;AAAA,UACV;AACA,gBAAM,SACD,MAAM,KAAK,aAAa,SAAS,OAAO,GAAG,IAAI,cAAc,KAAK,CAAC;AACxE,gBAAM,UAAU,CAAC;AAEjB,qBAAW,QAAQ,OAAO;AACxB,oBAAQ,KAAK;AAAA,cACX,YAAY,KAAK,SAAS,MAAM;AAAA,cAChC,UAAU,KAAK,SAAS,IAAI;AAAA,cAC5B,YAAY,KAAK;AAAA,cACjB,gBAAY,wBAAW;AAAA,gBACrB,KAAK,KAAK;AAAA,gBACV;AAAA,gBACA,YAAY;AAAA,gBACZ,eAAe;AAAA,gBACf,kBAAkB;AAAA,gBAClB;AAAA,cACF,CAAC;AAAA,YACH,CAAC;AAAA,UACH;AAEA,iBAAO;AAAA,QACT,CAAC;AAAA,MACH;AAEA,cAAI,mCAAa,OAAO,GAAG;AACzB,kBAAM,+BAAiB,KAAK,KAAK,SAAS,CAAC,YAAY;AACrD,gBAAM,aAAa,KAAK,MAAM,OAAO;AACrC,qBAAW,QAAQ,WAAW,OAAO;AACnC,gBAAI,KAAK,SAAS,QAAQ;AACxB;AAAA,YACF;AACA,kBAAMC,WAAU,UAAU,IAAI,KAAK,IAAI;AACvC,gBAAI,CAACA,UAAS;AACZ;AAAA,YACF;AACA,iBAAK,OAAOA;AAAA,UACd;AACA,qBAAO,sBAAO,UAAU;AAAA,QAC1B,CAAC;AAAA,MACH,eAAW,qCAAe,OAAO,GAAG;AAClC,kBAAM,+BAAkB;AAAA,UACtB,KAAK,KAAK;AAAA,UACV,YAAY;AAAA,UACZ,eAAe;AAAA,UACf;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF,UAAE;AACA,WAAK,cAAc,OAAO,OAAO;AAAA,IACnC;AAAA,EACF;AAAA,EAEA,MAAc,aAAa,SAAgB,SAA+D;AACxG,UAAM,YAAY,oBAAI,IAA8B;AACpD,UAAM,WAAW,UAAM,8CAAwB,KAAK,KAAK,OAAO;AAChE,eAAW,QAAQ,SAAS,KAAK,GAAG;AAClC,gBAAU,IAAI,MAAM,SAAS,IAAI,IAAI,KAAK,CAAC,CAAC;AAAA,IAC9C;AAEA,QAAI,CAAC,SAAS;AACZ,aAAO;AAAA,IACT;AAEA,UAAM,WAAW,UAAM,8CAAwB,KAAK,KAAK,OAAO;AAEhE,eAAW,QAAQ,SAAS,KAAK,GAAG;AAClC,YAAM,QAAQ,UAAU,IAAI,IAAI,KAAK,CAAC;AACtC,YAAM,KAAK,GAAG,SAAS,IAAI,IAAI,KAAK,CAAC,CAAC;AACtC,gBAAU,IAAI,MAAM,KAAK;AAAA,IAC3B;AAEA,WAAO;AAAA,EACT;AACF;",
  "names": ["oldPath", "specialRename", "newPath"]
}


package/dist/lib/obsidian/RenameDeleteHandler.d.ts

@@ -0,0 +1,21 @@
+import type { TAbstractFile } from 'obsidian';
+import { App } from 'obsidian';
+interface RenameDeleteHandlerSettings {
+    shouldDeleteEmptyFolders: boolean;
+}
+/**
+ * Handles renaming and deleting files.
+ */
+export declare class RenameDeleteHandler {
+    private app;
+    private settingsBuilder;
+    constructor(app: App, settingsBuilder: () => RenameDeleteHandlerSettings);
+    private renamingPaths;
+    private specialRenames;
+    handleRename(file: TAbstractFile, oldPath: string): Promise<void>;
+    handleDelete(file: TAbstractFile): Promise<void>;
+    private fillRenameMap;
+    private processRename;
+    private getBacklinks;
+}
+export {};

package/dist/lib/obsidian/index.cjs

@@ -46,6 +46,7 @@ __export(obsidian_exports, {
   Modal: () => Modal,
   ObsidianSettings: () => ObsidianSettings,
   Plugin: () => Plugin,
+  RenameDeleteHandler: () => RenameDeleteHandler,
   ResourceUrl: () => ResourceUrl,
   TAbstractFile: () => TAbstractFile,
   TFile: () => TFile,
@@ -66,6 +67,7 @@ var MetadataCache = __toESM(require("./MetadataCache.cjs"), 1);
 var Modal = __toESM(require("./Modal/index.cjs"), 1);
 var ObsidianSettings = __toESM(require("./ObsidianSettings.cjs"), 1);
 var Plugin = __toESM(require("./Plugin/index.cjs"), 1);
+var RenameDeleteHandler = __toESM(require("./RenameDeleteHandler.cjs"), 1);
 var ResourceUrl = __toESM(require("./ResourceUrl.cjs"), 1);
 var TAbstractFile = __toESM(require("./TAbstractFile.cjs"), 1);
 var TFile = __toESM(require("./TFile.cjs"), 1);
@@ -97,10 +99,11 @@ var __process = globalThis["process"] ?? {
   Modal,
   ObsidianSettings,
   Plugin,
+  RenameDeleteHandler,
   ResourceUrl,
   TAbstractFile,
   TFile,
   TFolder,
   Vault
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/obsidian/index.d.ts

@@ -11,6 +11,7 @@ export * as MetadataCache from './MetadataCache.ts';
 export * as Modal from './Modal/index.ts';
 export * as ObsidianSettings from './ObsidianSettings.ts';
 export * as Plugin from './Plugin/index.ts';
+export * as RenameDeleteHandler from './RenameDeleteHandler.ts';
 export * as ResourceUrl from './ResourceUrl.ts';
 export * as TAbstractFile from './TAbstractFile.ts';
 export * as TFile from './TFile.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "3.7.1",
+  "version": "3.9.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development",
   "main": "./dist/lib/index.cjs",
   "types": "./dist/lib/index.d.ts",
@@ -76,7 +76,7 @@
     "js-yaml": "^4.1.0",
     "localforage": "^1.10.0",
     "obsidian": "^1.6.6",
-    "obsidian-typings": "^2.2.1-beta.8",
+    "obsidian-typings": "^2.2.1-beta.11",
     "path-browserify": "^1.0.1",
     "type-fest": "^4.26.0"
   },