obsidian-dev-utils 3.21.0 → 3.22.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 3.22.0
+
+- Refactor `RenameDeleteHandler`
+- Add `chainAsyncFn`
+
 ## 3.21.0
 
 - Add `includeAttachmentExtensionToEmbedAlias`

package/dist/lib/Async.cjs

@@ -25,6 +25,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Async_exports = {};
 __export(Async_exports, {
+  addErrorHandler: () => addErrorHandler,
   asyncFilter: () => asyncFilter,
   asyncFlatMap: () => asyncFlatMap,
   asyncMap: () => asyncMap,
@@ -84,7 +85,14 @@ async function timeout(timeoutInMilliseconds) {
   throw new Error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`);
 }
 function invokeAsyncSafely(promise) {
-  promise.catch(import_Error.emitAsyncErrorEvent);
+  void addErrorHandler(promise);
+}
+async function addErrorHandler(promise) {
+  try {
+    await promise;
+  } catch (asyncError) {
+    (0, import_Error.emitAsyncErrorEvent)(asyncError);
+  }
 }
 function convertAsyncToSync(asyncFunc) {
   return (...args) => {
@@ -119,6 +127,7 @@ async function toArray(iter) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  addErrorHandler,
   asyncFilter,
   asyncFlatMap,
   asyncMap,
@@ -131,4 +140,4 @@ async function toArray(iter) {
   timeout,
   toArray
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Async.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 Async\n * Contains utility functions for asynchronous operations.\n */\n\nimport { emitAsyncErrorEvent } from './Error.ts';\n\n/**\n * A type representing a value that can either be a direct value or a Promise resolving to that value.\n * @typeParam T - The type of the value.\n */\nexport type MaybePromise<T> = T | Promise<T>;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * The maximum time in milliseconds to wait before giving up on retrying.\n   */\n  timeoutInMilliseconds: number;\n\n  /**\n   * The delay in milliseconds between retry attempts.\n   */\n  retryDelayInMilliseconds: number;\n}\n\n/**\n * Retries the provided asynchronous function until it succeeds or the timeout is reached.\n *\n * @param asyncFn - The asynchronous function to retry.\n * @param retryOptions - Optional parameters to configure the retry behavior.\n * @returns A Promise that resolves when the function succeeds or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(asyncFn: () => Promise<boolean>, retryOptions: Partial<RetryOptions> = {}): Promise<void> {\n  const DEFAULT_RETRY_OPTIONS: RetryOptions = {\n    timeoutInMilliseconds: 5000,\n    retryDelayInMilliseconds: 100\n  };\n  const overriddenOptions: RetryOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  await runWithTimeout(overriddenOptions.timeoutInMilliseconds, async () => {\n    let attempt = 0;\n    for (; ;) {\n      attempt++;\n      if (await asyncFn()) {\n        if (attempt > 1) {\n          console.debug(`Retry completed successfully after ${attempt.toString()} attempts`);\n        }\n        return;\n      }\n\n      console.debug(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${overriddenOptions.retryDelayInMilliseconds.toString()} milliseconds`, {\n        asyncFn\n      });\n      await sleep(overriddenOptions.retryDelayInMilliseconds);\n    }\n  });\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param milliseconds - The time to wait in milliseconds.\n * @returns A Promise that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number): Promise<void> {\n  await new Promise((resolve) => setTimeout(resolve, milliseconds));\n}\n\n/**\n * Executes an asynchronous function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.\n *\n * @typeParam R - The type of the result from the asynchronous function.\n * @param timeoutInMilliseconds - The maximum time to wait in milliseconds.\n * @param asyncFn - The asynchronous function to execute.\n * @returns A Promise that resolves with the result of the asynchronous function or rejects if it times out.\n */\nexport async function runWithTimeout<R>(timeoutInMilliseconds: number, asyncFn: () => Promise<R>): Promise<R> {\n  return await Promise.race([asyncFn(), timeout(timeoutInMilliseconds)]);\n}\n\n/**\n * Returns a Promise that rejects after the specified timeout period.\n *\n * @param timeoutInMilliseconds - The timeout period in milliseconds.\n * @returns A Promise that always rejects with a timeout error.\n */\nexport async function timeout(timeoutInMilliseconds: number): Promise<never> {\n  await sleep(timeoutInMilliseconds);\n  throw new Error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`);\n}\n\n/**\n * Invokes a Promise and safely handles any errors by catching them and emitting an async error event.\n *\n * @param promise - The Promise to invoke.\n */\nexport function invokeAsyncSafely(promise: Promise<unknown>): void {\n  promise.catch(emitAsyncErrorEvent);\n}\n\n/**\n * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @param asyncFunc - The asynchronous function to convert.\n * @returns A function that wraps the asynchronous function in a synchronous interface.\n */\nexport function convertAsyncToSync<Args extends unknown[]>(asyncFunc: (...args: Args) => Promise<unknown>): (...args: Args) => void {\n  return (...args: Args): void => {\n    invokeAsyncSafely(asyncFunc(...args));\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a Promise.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @typeParam Result - The type of the function's return value.\n * @param syncFn - The synchronous function to convert.\n * @returns A function that wraps the synchronous function in an asynchronous interface.\n */\nexport function convertSyncToAsync<Args extends unknown[], Result>(syncFn: (...args: Args) => Result): (...args: Args) => Promise<Result> {\n  return async (...args: Args): Promise<Result> => {\n    try {\n      return syncFn(...args);\n    } catch (error) {\n      return await Promise.reject(error as Error);\n    }\n  };\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over.\n * @param callback - The callback function to apply to each element.\n * @returns A Promise that resolves with an array of the results of the callback function.\n */\nexport async function asyncMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U>): Promise<U[]> {\n  return await Promise.all(arr.map(callback));\n}\n\n/**\n * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param arr - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A Promise that resolves with an array of elements that satisfy the predicate function.\n */\nexport async function asyncFilter<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => MaybePromise<boolean>): Promise<T[]> {\n  const predicateResults = await asyncMap(arr, predicate);\n  return arr.filter((_, index) => predicateResults[index]);\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over and flatten.\n * @param callback - The callback function to apply to each element.\n * @returns A Promise that resolves with a flattened array of the results of the callback function.\n */\nexport async function asyncFlatMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U[]>): Promise<U[]> {\n  return (await asyncMap(arr, callback)).flat();\n}\n\n/**\n * Converts an AsyncIterableIterator to an array by consuming all its elements.\n *\n * @typeParam T - The type of elements produced by the AsyncIterableIterator.\n * @param iter - The AsyncIterableIterator to convert.\n * @returns A Promise that resolves with an array of all the elements in the AsyncIterableIterator.\n */\nexport async function toArray<T>(iter: AsyncIterableIterator<T>): Promise<T[]> {\n  const arr: T[] = [];\n  for await (const item of iter) {\n    arr.push(item);\n  }\n  return arr;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,mBAAoC;AAXpC,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;AAoCA,eAAsB,iBAAiB,SAAiC,eAAsC,CAAC,GAAkB;AAC/H,QAAM,wBAAsC;AAAA,IAC1C,uBAAuB;AAAA,IACvB,0BAA0B;AAAA,EAC5B;AACA,QAAM,oBAAkC,EAAE,GAAG,uBAAuB,GAAG,aAAa;AACpF,QAAM,eAAe,kBAAkB,uBAAuB,YAAY;AACxE,QAAI,UAAU;AACd,eAAU;AACR;AACA,UAAI,MAAM,QAAQ,GAAG;AACnB,YAAI,UAAU,GAAG;AACf,kBAAQ,MAAM,sCAAsC,QAAQ,SAAS,CAAC,WAAW;AAAA,QACnF;AACA;AAAA,MACF;AAEA,cAAQ,MAAM,iBAAiB,QAAQ,SAAS,CAAC,8CAA8C,kBAAkB,yBAAyB,SAAS,CAAC,iBAAiB;AAAA,QACnK;AAAA,MACF,CAAC;AACD,YAAM,MAAM,kBAAkB,wBAAwB;AAAA,IACxD;AAAA,EACF,CAAC;AACH;AAQA,eAAsB,MAAM,cAAqC;AAC/D,QAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,YAAY,CAAC;AAClE;AAUA,eAAsB,eAAkB,uBAA+B,SAAuC;AAC5G,SAAO,MAAM,QAAQ,KAAK,CAAC,QAAQ,GAAG,QAAQ,qBAAqB,CAAC,CAAC;AACvE;AAQA,eAAsB,QAAQ,uBAA+C;AAC3E,QAAM,MAAM,qBAAqB;AACjC,QAAM,IAAI,MAAM,gBAAgB,sBAAsB,SAAS,CAAC,eAAe;AACjF;AAOO,SAAS,kBAAkB,SAAiC;AACjE,UAAQ,MAAM,gCAAmB;AACnC;AASO,SAAS,mBAA2C,WAAyE;AAClI,SAAO,IAAI,SAAqB;AAC9B,sBAAkB,UAAU,GAAG,IAAI,CAAC;AAAA,EACtC;AACF;AAUO,SAAS,mBAAmD,QAAuE;AACxI,SAAO,UAAU,SAAgC;AAC/C,QAAI;AACF,aAAO,OAAO,GAAG,IAAI;AAAA,IACvB,SAAS,OAAO;AACd,aAAO,MAAM,QAAQ,OAAO,KAAc;AAAA,IAC5C;AAAA,EACF;AACF;AAWA,eAAsB,SAAe,KAAU,UAAkF;AAC/H,SAAO,MAAM,QAAQ,IAAI,IAAI,IAAI,QAAQ,CAAC;AAC5C;AAUA,eAAsB,YAAe,KAAU,WAAyF;AACtI,QAAM,mBAAmB,MAAM,SAAS,KAAK,SAAS;AACtD,SAAO,IAAI,OAAO,CAAC,GAAG,UAAU,iBAAiB,KAAK,CAAC;AACzD;AAWA,eAAsB,aAAmB,KAAU,UAAoF;AACrI,UAAQ,MAAM,SAAS,KAAK,QAAQ,GAAG,KAAK;AAC9C;AASA,eAAsB,QAAW,MAA8C;AAC7E,QAAM,MAAW,CAAC;AAClB,mBAAiB,QAAQ,MAAM;AAC7B,QAAI,KAAK,IAAI;AAAA,EACf;AACA,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Async.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 Async\n * Contains utility functions for asynchronous operations.\n */\n\nimport { emitAsyncErrorEvent } from './Error.ts';\n\n/**\n * A type representing a value that can either be a direct value or a Promise resolving to that value.\n * @typeParam T - The type of the value.\n */\nexport type MaybePromise<T> = T | Promise<T>;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * The maximum time in milliseconds to wait before giving up on retrying.\n   */\n  timeoutInMilliseconds: number;\n\n  /**\n   * The delay in milliseconds between retry attempts.\n   */\n  retryDelayInMilliseconds: number;\n}\n\n/**\n * Retries the provided asynchronous function until it succeeds or the timeout is reached.\n *\n * @param asyncFn - The asynchronous function to retry.\n * @param retryOptions - Optional parameters to configure the retry behavior.\n * @returns A Promise that resolves when the function succeeds or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(asyncFn: () => Promise<boolean>, retryOptions: Partial<RetryOptions> = {}): Promise<void> {\n  const DEFAULT_RETRY_OPTIONS: RetryOptions = {\n    timeoutInMilliseconds: 5000,\n    retryDelayInMilliseconds: 100\n  };\n  const overriddenOptions: RetryOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  await runWithTimeout(overriddenOptions.timeoutInMilliseconds, async () => {\n    let attempt = 0;\n    for (; ;) {\n      attempt++;\n      if (await asyncFn()) {\n        if (attempt > 1) {\n          console.debug(`Retry completed successfully after ${attempt.toString()} attempts`);\n        }\n        return;\n      }\n\n      console.debug(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${overriddenOptions.retryDelayInMilliseconds.toString()} milliseconds`, {\n        asyncFn\n      });\n      await sleep(overriddenOptions.retryDelayInMilliseconds);\n    }\n  });\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param milliseconds - The time to wait in milliseconds.\n * @returns A Promise that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number): Promise<void> {\n  await new Promise((resolve) => setTimeout(resolve, milliseconds));\n}\n\n/**\n * Executes an asynchronous function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.\n *\n * @typeParam R - The type of the result from the asynchronous function.\n * @param timeoutInMilliseconds - The maximum time to wait in milliseconds.\n * @param asyncFn - The asynchronous function to execute.\n * @returns A Promise that resolves with the result of the asynchronous function or rejects if it times out.\n */\nexport async function runWithTimeout<R>(timeoutInMilliseconds: number, asyncFn: () => Promise<R>): Promise<R> {\n  return await Promise.race([asyncFn(), timeout(timeoutInMilliseconds)]);\n}\n\n/**\n * Returns a Promise that rejects after the specified timeout period.\n *\n * @param timeoutInMilliseconds - The timeout period in milliseconds.\n * @returns A Promise that always rejects with a timeout error.\n */\nexport async function timeout(timeoutInMilliseconds: number): Promise<never> {\n  await sleep(timeoutInMilliseconds);\n  throw new Error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`);\n}\n\n/**\n * Invokes a Promise and safely handles any errors by catching them and emitting an async error event.\n *\n * @param promise - The Promise to invoke.\n */\nexport function invokeAsyncSafely(promise: Promise<unknown>): void {\n  void addErrorHandler(promise);\n}\n\n/**\n * Adds an error handler to a Promise that catches any errors and emits an async error event.\n *\n * @param promise - The Promise to add an error handler to.\n */\nexport async function addErrorHandler(promise: Promise<unknown>): Promise<void> {\n  try {\n    await promise;\n  } catch (asyncError) {\n    emitAsyncErrorEvent(asyncError);\n  }\n}\n\n/**\n * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @param asyncFunc - The asynchronous function to convert.\n * @returns A function that wraps the asynchronous function in a synchronous interface.\n */\nexport function convertAsyncToSync<Args extends unknown[]>(asyncFunc: (...args: Args) => Promise<unknown>): (...args: Args) => void {\n  return (...args: Args): void => {\n    invokeAsyncSafely(asyncFunc(...args));\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a Promise.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @typeParam Result - The type of the function's return value.\n * @param syncFn - The synchronous function to convert.\n * @returns A function that wraps the synchronous function in an asynchronous interface.\n */\nexport function convertSyncToAsync<Args extends unknown[], Result>(syncFn: (...args: Args) => Result): (...args: Args) => Promise<Result> {\n  return async (...args: Args): Promise<Result> => {\n    try {\n      return syncFn(...args);\n    } catch (error) {\n      return await Promise.reject(error as Error);\n    }\n  };\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over.\n * @param callback - The callback function to apply to each element.\n * @returns A Promise that resolves with an array of the results of the callback function.\n */\nexport async function asyncMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U>): Promise<U[]> {\n  return await Promise.all(arr.map(callback));\n}\n\n/**\n * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param arr - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A Promise that resolves with an array of elements that satisfy the predicate function.\n */\nexport async function asyncFilter<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => MaybePromise<boolean>): Promise<T[]> {\n  const predicateResults = await asyncMap(arr, predicate);\n  return arr.filter((_, index) => predicateResults[index]);\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over and flatten.\n * @param callback - The callback function to apply to each element.\n * @returns A Promise that resolves with a flattened array of the results of the callback function.\n */\nexport async function asyncFlatMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U[]>): Promise<U[]> {\n  return (await asyncMap(arr, callback)).flat();\n}\n\n/**\n * Converts an AsyncIterableIterator to an array by consuming all its elements.\n *\n * @typeParam T - The type of elements produced by the AsyncIterableIterator.\n * @param iter - The AsyncIterableIterator to convert.\n * @returns A Promise that resolves with an array of all the elements in the AsyncIterableIterator.\n */\nexport async function toArray<T>(iter: AsyncIterableIterator<T>): Promise<T[]> {\n  const arr: T[] = [];\n  for await (const item of iter) {\n    arr.push(item);\n  }\n  return arr;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,mBAAoC;AAXpC,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;AAoCA,eAAsB,iBAAiB,SAAiC,eAAsC,CAAC,GAAkB;AAC/H,QAAM,wBAAsC;AAAA,IAC1C,uBAAuB;AAAA,IACvB,0BAA0B;AAAA,EAC5B;AACA,QAAM,oBAAkC,EAAE,GAAG,uBAAuB,GAAG,aAAa;AACpF,QAAM,eAAe,kBAAkB,uBAAuB,YAAY;AACxE,QAAI,UAAU;AACd,eAAU;AACR;AACA,UAAI,MAAM,QAAQ,GAAG;AACnB,YAAI,UAAU,GAAG;AACf,kBAAQ,MAAM,sCAAsC,QAAQ,SAAS,CAAC,WAAW;AAAA,QACnF;AACA;AAAA,MACF;AAEA,cAAQ,MAAM,iBAAiB,QAAQ,SAAS,CAAC,8CAA8C,kBAAkB,yBAAyB,SAAS,CAAC,iBAAiB;AAAA,QACnK;AAAA,MACF,CAAC;AACD,YAAM,MAAM,kBAAkB,wBAAwB;AAAA,IACxD;AAAA,EACF,CAAC;AACH;AAQA,eAAsB,MAAM,cAAqC;AAC/D,QAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,YAAY,CAAC;AAClE;AAUA,eAAsB,eAAkB,uBAA+B,SAAuC;AAC5G,SAAO,MAAM,QAAQ,KAAK,CAAC,QAAQ,GAAG,QAAQ,qBAAqB,CAAC,CAAC;AACvE;AAQA,eAAsB,QAAQ,uBAA+C;AAC3E,QAAM,MAAM,qBAAqB;AACjC,QAAM,IAAI,MAAM,gBAAgB,sBAAsB,SAAS,CAAC,eAAe;AACjF;AAOO,SAAS,kBAAkB,SAAiC;AACjE,OAAK,gBAAgB,OAAO;AAC9B;AAOA,eAAsB,gBAAgB,SAA0C;AAC9E,MAAI;AACF,UAAM;AAAA,EACR,SAAS,YAAY;AACnB,0CAAoB,UAAU;AAAA,EAChC;AACF;AASO,SAAS,mBAA2C,WAAyE;AAClI,SAAO,IAAI,SAAqB;AAC9B,sBAAkB,UAAU,GAAG,IAAI,CAAC;AAAA,EACtC;AACF;AAUO,SAAS,mBAAmD,QAAuE;AACxI,SAAO,UAAU,SAAgC;AAC/C,QAAI;AACF,aAAO,OAAO,GAAG,IAAI;AAAA,IACvB,SAAS,OAAO;AACd,aAAO,MAAM,QAAQ,OAAO,KAAc;AAAA,IAC5C;AAAA,EACF;AACF;AAWA,eAAsB,SAAe,KAAU,UAAkF;AAC/H,SAAO,MAAM,QAAQ,IAAI,IAAI,IAAI,QAAQ,CAAC;AAC5C;AAUA,eAAsB,YAAe,KAAU,WAAyF;AACtI,QAAM,mBAAmB,MAAM,SAAS,KAAK,SAAS;AACtD,SAAO,IAAI,OAAO,CAAC,GAAG,UAAU,iBAAiB,KAAK,CAAC;AACzD;AAWA,eAAsB,aAAmB,KAAU,UAAoF;AACrI,UAAQ,MAAM,SAAS,KAAK,QAAQ,GAAG,KAAK;AAC9C;AASA,eAAsB,QAAW,MAA8C;AAC7E,QAAM,MAAW,CAAC;AAClB,mBAAiB,QAAQ,MAAM;AAC7B,QAAI,KAAK,IAAI;AAAA,EACf;AACA,SAAO;AACT;",
  "names": []
}


package/dist/lib/Async.d.ts

@@ -57,6 +57,12 @@ export declare function timeout(timeoutInMilliseconds: number): Promise<never>;
  * @param promise - The Promise to invoke.
  */
 export declare function invokeAsyncSafely(promise: Promise<unknown>): void;
+/**
+ * Adds an error handler to a Promise that catches any errors and emits an async error event.
+ *
+ * @param promise - The Promise to add an error handler to.
+ */
+export declare function addErrorHandler(promise: Promise<unknown>): Promise<void>;
 /**
  * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.
  *

package/dist/lib/obsidian/Callout.cjs

@@ -30,9 +30,9 @@ __export(Callout_exports, {
   wrapForCallout: () => wrapForCallout
 });
 module.exports = __toCommonJS(Callout_exports);
-var import_Async = require('../Async.cjs');
 var import_Error = require('../Error.cjs');
 var import_ValueProvider = require('../ValueProvider.cjs');
+var import_ChainedPromise = require('./ChainedPromise.cjs');
 var import_Dataview = require('./Dataview.cjs');
 var __import_meta_url = globalThis["import.meta.url"] ?? (() => {
   if (typeof __filename !== "string") {
@@ -79,7 +79,7 @@ function renderCallout(options) {
     for (const entry of entries) {
       if (entry.isIntersecting) {
         observer.unobserve(entry.target);
-        (0, import_Async.invokeAsyncSafely)(loadContent());
+        (0, import_ChainedPromise.chainAsyncFn)(dv.app, loadContent);
       }
     }
   });
@@ -106,4 +106,4 @@ function wrapForCallout(content) {
   renderCallout,
   wrapForCallout
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL29ic2lkaWFuL0NhbGxvdXQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbInZhciBfX2ltcG9ydF9tZXRhX3VybCA9IGdsb2JhbFRoaXNbJ2ltcG9ydC5tZXRhLnVybCddID8/ICgoKT0+e2lmKHR5cGVvZiBfX2ZpbGVuYW1lIT09XCJzdHJpbmdcIil7cmV0dXJuIG5ldyBVUkwod2luZG93LmxvY2F0aW9uLmhyZWYpfXJldHVybiByZXF1aXJlKFwibm9kZTp1cmxcIikucGF0aFRvRmlsZVVSTChfX2ZpbGVuYW1lKX0pKCk7XG52YXIgX19wcm9jZXNzID0gZ2xvYmFsVGhpc1sncHJvY2VzcyddID8/IHtcbiAgXCJjd2RcIjogKCk9PlwiL1wiLFxuICBcImVudlwiOiB7fSxcbiAgXCJwbGF0Zm9ybVwiOiBcImFuZHJvaWRcIlxufTtcbi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uIENhbGxvdXRcbiAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIHV0aWxpdHkgZnVuY3Rpb25zIGZvciByZW5kZXJpbmcgY2FsbG91dHMgaW4gRGF0YXZpZXcuXG4gKi9cblxuaW1wb3J0IHsgdGhyb3dFeHByZXNzaW9uIH0gZnJvbSAnLi4vRXJyb3IudHMnO1xuaW1wb3J0IHR5cGUgeyBWYWx1ZVByb3ZpZGVyIH0gZnJvbSAnLi4vVmFsdWVQcm92aWRlci50cyc7XG5pbXBvcnQgeyByZXNvbHZlVmFsdWUgfSBmcm9tICcuLi9WYWx1ZVByb3ZpZGVyLnRzJztcbmltcG9ydCB7IGNoYWluQXN5bmNGbiB9IGZyb20gJy4vQ2hhaW5lZFByb21pc2UudHMnO1xuaW1wb3J0IHR5cGUgeyBEYXRhdmlld0lubGluZUFwaSB9IGZyb20gJy4vRGF0YXZpZXcudHMnO1xuaW1wb3J0IHsgZ2V0UmVuZGVyZWRDb250YWluZXIgfSBmcm9tICcuL0RhdGF2aWV3LnRzJztcblxuLyoqXG4gKiBFbnVtIHJlcHJlc2VudGluZyB0aGUgbW9kZSBvZiBhIGNhbGxvdXQuXG4gKi9cbmV4cG9ydCBlbnVtIENhbGxvdXRNb2RlIHtcbiAgLyoqIERlZmF1bHQgbW9kZSwgd2l0aCBubyBzcGVjaWFsIGJlaGF2aW9yLiAqL1xuICBEZWZhdWx0LFxuXG4gIC8qKiBGb2xkYWJsZSBtb2RlIHdpdGggdGhlIGNhbGxvdXQgY29sbGFwc2VkLiAqL1xuICBGb2xkYWJsZUNvbGxhcHNlZCxcblxuICAvKiogRm9sZGFibGUgbW9kZSB3aXRoIHRoZSBjYWxsb3V0IGV4cGFuZGVkLiAqL1xuICBGb2xkYWJsZUV4cGFuZGVkXG59XG5cbi8qKlxuICogUmV0dXJucyB0aGUgbW9kaWZpZXIgc3RyaW5nIGJhc2VkIG9uIHRoZSBjYWxsb3V0IG1vZGUuXG4gKlxuICogQHBhcmFtIG1vZGUgLSBUaGUgbW9kZSBvZiB0aGUgY2FsbG91dC5cbiAqIEByZXR1cm5zIFRoZSBjb3JyZXNwb25kaW5nIG1vZGlmaWVyIHN0cmluZy5cbiAqL1xuZnVuY3Rpb24gZ2V0TW9kaWZpZXIobW9kZTogQ2FsbG91dE1vZGUpOiBzdHJpbmcge1xuICBzd2l0Y2ggKG1vZGUpIHtcbiAgICBjYXNlIENhbGxvdXRNb2RlLkZvbGRhYmxlQ29sbGFwc2VkOlxuICAgICAgcmV0dXJuICctJztcbiAgICBjYXNlIENhbGxvdXRNb2RlLkZvbGRhYmxlRXhwYW5kZWQ6XG4gICAgICByZXR1cm4gJysnO1xuICAgIGRlZmF1bHQ6XG4gICAgICByZXR1cm4gJyc7XG4gIH1cbn1cblxuLyoqXG4gKiBPcHRpb25zIGZvciByZW5kZXJpbmcgYSBjYWxsb3V0IGJsb2NrIGluIERhdGF2aWV3LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFJlbmRlckNhbGxvdXRPcHRpb25zIHtcbiAgLyoqXG4gICAqIFRoZSBEYXRhdmlld0lubGluZUFwaSBpbnN0YW5jZS5cbiAgICovXG4gIGR2OiBEYXRhdmlld0lubGluZUFwaTtcblxuICAvKipcbiAgICogVGhlIHR5cGUgb2YgdGhlIGNhbGxvdXQsIGRlZmF1bHQgaXMgYFwiTk9URVwiYC5cbiAgICovXG4gIHR5cGU/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFRoZSBjYWxsb3V0IG1vZGUsIGRlZmF1bHQgaXMgYENhbGxvdXRNb2RlLkZvbGRhYmxlQ29sbGFwc2VkYC5cbiAgICovXG4gIG1vZGU/OiBDYWxsb3V0TW9kZTtcblxuICAvKipcbiAgICogVGhlIGhlYWRlciB0ZXh0IG9mIHRoZSBjYWxsb3V0LCBkZWZhdWx0IGlzIGFuIGVtcHR5IHN0cmluZy5cbiAgICovXG4gIGhlYWRlcj86IHN0cmluZztcblxuICAvKipcbiAgICogQW4gb3B0aW9uYWwgcHJvdmlkZXIgZm9yIHRoZSBjb250ZW50LCB3aGljaCBjYW4gYmUgZWl0aGVyIGEgc3RyaW5nIG9yIGEgTm9kZS5cbiAgICovXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8taW52YWxpZC12b2lkLXR5cGVcbiAgY29udGVudFByb3ZpZGVyPzogVmFsdWVQcm92aWRlcjxzdHJpbmcgfCBOb2RlIHwgdm9pZD47XG59XG5cbi8qKlxuICogUmVuZGVycyBhIGNhbGxvdXQgYmxvY2sgaW4gRGF0YXZpZXcuXG4gKlxuICogQHBhcmFtIG9wdGlvbnMgLSBUaGUgb3B0aW9ucyBmb3IgcmVuZGVyaW5nIHRoZSBjYWxsb3V0LlxuICovXG5leHBvcnQgZnVuY3Rpb24gcmVuZGVyQ2FsbG91dChvcHRpb25zOiBSZW5kZXJDYWxsb3V0T3B0aW9ucyk6IHZvaWQge1xuICBjb25zdCB7XG4gICAgZHYsXG4gICAgdHlwZSA9ICdOT1RFJyxcbiAgICBtb2RlID0gQ2FsbG91dE1vZGUuRm9sZGFibGVDb2xsYXBzZWQsXG4gICAgaGVhZGVyID0gJycsXG4gICAgY29udGVudFByb3ZpZGVyID0gJydcbiAgfSA9IG9wdGlvbnM7XG4gIGNvbnN0IG1vZGlmaWVyID0gZ2V0TW9kaWZpZXIobW9kZSk7XG4gIGNvbnN0IGNhbGxvdXQgPSBkdi5wYXJhZ3JhcGgoYD4gWyEke3R5cGV9XSR7bW9kaWZpZXJ9ICR7aGVhZGVyfVxcbj5cXG4+IDxkaXYgY2xhc3M9XCJjb250ZW50XCI+PC9kaXY+YCk7XG4gIGNvbnN0IGNvbnRlbnREaXYgPSBjYWxsb3V0LnF1ZXJ5U2VsZWN0b3I8SFRNTERpdkVsZW1lbnQ+KCcuY29udGVudCcpID8/IHRocm93RXhwcmVzc2lvbihuZXcgRXJyb3IoJ0NvbnRlbnQgZGl2IG5vdCBmb3VuZCcpKTtcbiAgZHYucGFyYWdyYXBoKCdMb2FkaW5nLi4uIFx1MjNGMycsIHsgY29udGFpbmVyOiBjb250ZW50RGl2IH0pO1xuXG4gIGNvbnN0IG9ic2VydmVyID0gbmV3IEludGVyc2VjdGlvbk9ic2VydmVyKChlbnRyaWVzOiBJbnRlcnNlY3Rpb25PYnNlcnZlckVudHJ5W10pID0+IHtcbiAgICBmb3IgKGNvbnN0IGVudHJ5IG9mIGVudHJpZXMpIHtcbiAgICAgIGlmIChlbnRyeS5pc0ludGVyc2VjdGluZykge1xuICAgICAgICBvYnNlcnZlci51bm9ic2VydmUoZW50cnkudGFyZ2V0KTtcbiAgICAgICAgY2hhaW5Bc3luY0ZuKGR2LmFwcCwgbG9hZENvbnRlbnQpO1xuICAgICAgfVxuICAgIH1cbiAgfSk7XG4gIG9ic2VydmVyLm9ic2VydmUoY29udGVudERpdik7XG5cbiAgYXN5bmMgZnVuY3Rpb24gbG9hZENvbnRlbnQoKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgYXdhaXQgc2xlZXAoNTApO1xuICAgIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8taW52YWxpZC12b2lkLXR5cGVcbiAgICBsZXQgY29udGVudDogc3RyaW5nIHwgTm9kZSB8IHZvaWQgfCB1bmRlZmluZWQ7XG5cbiAgICBjb25zdCBwYXJhZ3JhcGggPSBhd2FpdCBnZXRSZW5kZXJlZENvbnRhaW5lcihkdiwgYXN5bmMgKCkgPT4ge1xuICAgICAgY29udGVudCA9IGF3YWl0IHJlc29sdmVWYWx1ZShjb250ZW50UHJvdmlkZXIpO1xuICAgIH0pO1xuXG4gICAgY29udGVudCA/Pz0gcGFyYWdyYXBoO1xuXG4gICAgY29udGVudERpdi5lbXB0eSgpO1xuICAgIGR2LnBhcmFncmFwaChjb250ZW50LCB7IGNvbnRhaW5lcjogY29udGVudERpdiB9KTtcbiAgfVxufVxuXG4vKipcbiAqIFdyYXBzIHRoZSBwcm92aWRlZCBjb250ZW50IGluIGJsb2NrcXVvdGUgc3ludGF4IGZvciBhIGNhbGxvdXQuXG4gKlxuICogQHBhcmFtIGNvbnRlbnQgLSBUaGUgY29udGVudCB0byB3cmFwLlxuICogQHJldHVybnMgVGhlIGNvbnRlbnQgd3JhcHBlZCBpbiBibG9ja3F1b3RlIHN5bnRheC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHdyYXBGb3JDYWxsb3V0KGNvbnRlbnQ6IHN0cmluZyk6IHN0cmluZyB7XG4gIGNvbnN0IGxpbmVzID0gY29udGVudC5zcGxpdCgnXFxuJyk7XG4gIGNvbnN0IHByZWZpeGVkTGluZXMgPSBsaW5lcy5tYXAoKGxpbmUpID0+IGA+ICR7bGluZX1gKTtcbiAgcmV0dXJuIHByZWZpeGVkTGluZXMuam9pbignXFxuJyk7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFXQSxtQkFBZ0M7QUFFaEMsMkJBQTZCO0FBQzdCLDRCQUE2QjtBQUU3QixzQkFBcUM7QUFoQnJDLElBQUksb0JBQW9CLFdBQVcsaUJBQWlCLE1BQU0sTUFBSTtBQUFDLE1BQUcsT0FBTyxlQUFhLFVBQVM7QUFBQyxXQUFPLElBQUksSUFBSSxPQUFPLFNBQVMsSUFBSTtBQUFBLEVBQUM7QUFBQyxTQUFPLFFBQVEsVUFBVSxFQUFFLGNBQWMsVUFBVTtBQUFDLEdBQUc7QUFDNUwsSUFBSSxZQUFZLFdBQVcsU0FBUyxLQUFLO0FBQUEsRUFDdkMsT0FBTyxNQUFJO0FBQUEsRUFDWCxPQUFPLENBQUM7QUFBQSxFQUNSLFlBQVk7QUFDZDtBQWdCTyxJQUFLLGNBQUwsa0JBQUtBLGlCQUFMO0FBRUwsRUFBQUEsMEJBQUE7QUFHQSxFQUFBQSwwQkFBQTtBQUdBLEVBQUFBLDBCQUFBO0FBUlUsU0FBQUE7QUFBQSxHQUFBO0FBaUJaLFNBQVMsWUFBWSxNQUEyQjtBQUM5QyxVQUFRLE1BQU07QUFBQSxJQUNaLEtBQUs7QUFDSCxhQUFPO0FBQUEsSUFDVCxLQUFLO0FBQ0gsYUFBTztBQUFBLElBQ1Q7QUFDRSxhQUFPO0FBQUEsRUFDWDtBQUNGO0FBc0NPLFNBQVMsY0FBYyxTQUFxQztBQUNqRSxRQUFNO0FBQUEsSUFDSjtBQUFBLElBQ0EsT0FBTztBQUFBLElBQ1AsT0FBTztBQUFBLElBQ1AsU0FBUztBQUFBLElBQ1Qsa0JBQWtCO0FBQUEsRUFDcEIsSUFBSTtBQUNKLFFBQU0sV0FBVyxZQUFZLElBQUk7QUFDakMsUUFBTSxVQUFVLEdBQUcsVUFBVSxPQUFPLElBQUksSUFBSSxRQUFRLElBQUksTUFBTTtBQUFBO0FBQUEsOEJBQW9DO0FBQ2xHLFFBQU0sYUFBYSxRQUFRLGNBQThCLFVBQVUsU0FBSyw4QkFBZ0IsSUFBSSxNQUFNLHVCQUF1QixDQUFDO0FBQzFILEtBQUcsVUFBVSxxQkFBZ0IsRUFBRSxXQUFXLFdBQVcsQ0FBQztBQUV0RCxRQUFNLFdBQVcsSUFBSSxxQkFBcUIsQ0FBQyxZQUF5QztBQUNsRixlQUFXLFNBQVMsU0FBUztBQUMzQixVQUFJLE1BQU0sZ0JBQWdCO0FBQ3hCLGlCQUFTLFVBQVUsTUFBTSxNQUFNO0FBQy9CLGdEQUFhLEdBQUcsS0FBSyxXQUFXO0FBQUEsTUFDbEM7QUFBQSxJQUNGO0FBQUEsRUFDRixDQUFDO0FBQ0QsV0FBUyxRQUFRLFVBQVU7QUFFM0IsaUJBQWUsY0FBNkI7QUFDMUMsVUFBTSxNQUFNLEVBQUU7QUFFZCxRQUFJO0FBRUosVUFBTSxZQUFZLFVBQU0sc0NBQXFCLElBQUksWUFBWTtBQUMzRCxnQkFBVSxVQUFNLG1DQUFhLGVBQWU7QUFBQSxJQUM5QyxDQUFDO0FBRUQsZ0JBQVk7QUFFWixlQUFXLE1BQU07QUFDakIsT0FBRyxVQUFVLFNBQVMsRUFBRSxXQUFXLFdBQVcsQ0FBQztBQUFBLEVBQ2pEO0FBQ0Y7QUFRTyxTQUFTLGVBQWUsU0FBeUI7QUFDdEQsUUFBTSxRQUFRLFFBQVEsTUFBTSxJQUFJO0FBQ2hDLFFBQU0sZ0JBQWdCLE1BQU0sSUFBSSxDQUFDLFNBQVMsS0FBSyxJQUFJLEVBQUU7QUFDckQsU0FBTyxjQUFjLEtBQUssSUFBSTtBQUNoQzsiLAogICJuYW1lcyI6IFsiQ2FsbG91dE1vZGUiXQp9Cg==

package/dist/lib/obsidian/ChainedPromise.cjs

@@ -0,0 +1,55 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function patchRequireEsmDefault(){const __require=require;require=Object.assign(id=>{const module=__require(id);return module.__esModule&&module.default?module.default:module},__require)})()
+
+"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 ChainedPromise_exports = {};
+__export(ChainedPromise_exports, {
+  chainAsyncFn: () => chainAsyncFn
+});
+module.exports = __toCommonJS(ChainedPromise_exports);
+var import_Async = require('../Async.cjs');
+var import_App = require('./App.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"
+};
+function getChainedPromiseWrapper(app) {
+  return (0, import_App.getObsidianDevUtilsState)(app, "chainedPromise", Promise.resolve());
+}
+function chainAsyncFn(app, asyncFn) {
+  const chainedPromiseWrapper = getChainedPromiseWrapper(app);
+  chainedPromiseWrapper.value = chainedPromiseWrapper.value.then(() => (0, import_Async.addErrorHandler)(asyncFn()));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chainAsyncFn
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL29ic2lkaWFuL0NoYWluZWRQcm9taXNlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJ2YXIgX19pbXBvcnRfbWV0YV91cmwgPSBnbG9iYWxUaGlzWydpbXBvcnQubWV0YS51cmwnXSA/PyAoKCk9PntpZih0eXBlb2YgX19maWxlbmFtZSE9PVwic3RyaW5nXCIpe3JldHVybiBuZXcgVVJMKHdpbmRvdy5sb2NhdGlvbi5ocmVmKX1yZXR1cm4gcmVxdWlyZShcIm5vZGU6dXJsXCIpLnBhdGhUb0ZpbGVVUkwoX19maWxlbmFtZSl9KSgpO1xudmFyIF9fcHJvY2VzcyA9IGdsb2JhbFRoaXNbJ3Byb2Nlc3MnXSA/PyB7XG4gIFwiY3dkXCI6ICgpPT5cIi9cIixcbiAgXCJlbnZcIjoge30sXG4gIFwicGxhdGZvcm1cIjogXCJhbmRyb2lkXCJcbn07XG5pbXBvcnQgdHlwZSB7IEFwcCB9IGZyb20gJ29ic2lkaWFuJztcblxuaW1wb3J0IHsgYWRkRXJyb3JIYW5kbGVyIH0gZnJvbSAnLi4vQXN5bmMudHMnO1xuaW1wb3J0IHR5cGUgeyBWYWx1ZVdyYXBwZXIgfSBmcm9tICcuL0FwcC50cyc7XG5pbXBvcnQgeyBnZXRPYnNpZGlhbkRldlV0aWxzU3RhdGUgfSBmcm9tICcuL0FwcC50cyc7XG5cbmZ1bmN0aW9uIGdldENoYWluZWRQcm9taXNlV3JhcHBlcihhcHA6IEFwcCk6IFZhbHVlV3JhcHBlcjxQcm9taXNlPHZvaWQ+PiB7XG4gIHJldHVybiBnZXRPYnNpZGlhbkRldlV0aWxzU3RhdGUoYXBwLCAnY2hhaW5lZFByb21pc2UnLCBQcm9taXNlLnJlc29sdmUoKSk7XG59XG5cbi8qKlxuICogQ2hhaW5zIGFuIGFzeW5jaHJvbm91cyBmdW5jdGlvbiB0byBiZSBleGVjdXRlZCBhZnRlciB0aGUgcHJldmlvdXMgYXN5bmNocm9ub3VzIGZ1bmN0aW9uIGNvbXBsZXRlcy5cbiAqXG4gKiBAcGFyYW0gYXBwIC0gVGhlIE9ic2lkaWFuIGFwcGxpY2F0aW9uIGluc3RhbmNlLlxuICogQHBhcmFtIGFzeW5jRm4gLSBUaGUgYXN5bmNocm9ub3VzIGZ1bmN0aW9uIHRvIGNoYWluLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY2hhaW5Bc3luY0ZuKGFwcDogQXBwLCBhc3luY0ZuOiAoKSA9PiBQcm9taXNlPHZvaWQ+KTogdm9pZCB7XG4gIGNvbnN0IGNoYWluZWRQcm9taXNlV3JhcHBlciA9IGdldENoYWluZWRQcm9taXNlV3JhcHBlcihhcHApO1xuICBjaGFpbmVkUHJvbWlzZVdyYXBwZXIudmFsdWUgPSBjaGFpbmVkUHJvbWlzZVdyYXBwZXIudmFsdWUudGhlbigoKSA9PiBhZGRFcnJvckhhbmRsZXIoYXN5bmNGbigpKSk7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVFBLG1CQUFnQztBQUVoQyxpQkFBeUM7QUFWekMsSUFBSSxvQkFBb0IsV0FBVyxpQkFBaUIsTUFBTSxNQUFJO0FBQUMsTUFBRyxPQUFPLGVBQWEsVUFBUztBQUFDLFdBQU8sSUFBSSxJQUFJLE9BQU8sU0FBUyxJQUFJO0FBQUEsRUFBQztBQUFDLFNBQU8sUUFBUSxVQUFVLEVBQUUsY0FBYyxVQUFVO0FBQUMsR0FBRztBQUM1TCxJQUFJLFlBQVksV0FBVyxTQUFTLEtBQUs7QUFBQSxFQUN2QyxPQUFPLE1BQUk7QUFBQSxFQUNYLE9BQU8sQ0FBQztBQUFBLEVBQ1IsWUFBWTtBQUNkO0FBT0EsU0FBUyx5QkFBeUIsS0FBdUM7QUFDdkUsYUFBTyxxQ0FBeUIsS0FBSyxrQkFBa0IsUUFBUSxRQUFRLENBQUM7QUFDMUU7QUFRTyxTQUFTLGFBQWEsS0FBVSxTQUFvQztBQUN6RSxRQUFNLHdCQUF3Qix5QkFBeUIsR0FBRztBQUMxRCx3QkFBc0IsUUFBUSxzQkFBc0IsTUFBTSxLQUFLLFVBQU0sOEJBQWdCLFFBQVEsQ0FBQyxDQUFDO0FBQ2pHOyIsCiAgIm5hbWVzIjogW10KfQo=

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

@@ -0,0 +1,8 @@
+import type { App } from 'obsidian';
+/**
+ * Chains an asynchronous function to be executed after the previous asynchronous function completes.
+ *
+ * @param app - The Obsidian application instance.
+ * @param asyncFn - The asynchronous function to chain.
+ */
+export declare function chainAsyncFn(app: App, asyncFn: () => Promise<void>): void;

package/dist/lib/obsidian/MetadataCache.cjs

@@ -28,6 +28,7 @@ __export(MetadataCache_exports, {
   ensureMetadataCacheReady: () => ensureMetadataCacheReady,
   getAllLinks: () => getAllLinks,
   getBacklinksForFileSafe: () => getBacklinksForFileSafe,
+  getBacklinksMap: () => getBacklinksMap,
   getCacheSafe: () => getCacheSafe,
   getFrontMatterSafe: () => getFrontMatterSafe,
   registerFile: () => registerFile,
@@ -130,6 +131,19 @@ async function getBacklinksForFileSafe(app, pathOrFile, retryOptions = {}) {
   }, overriddenOptions);
   return backlinks;
 }
+async function getBacklinksMap(app, pathOrFiles, retryOptions = {}) {
+  const map = /* @__PURE__ */ new Map();
+  for (const pathOrFile of pathOrFiles) {
+    const customArrayDict = await getBacklinksForFileSafe(app, pathOrFile, retryOptions);
+    for (const path of customArrayDict.keys()) {
+      const mapLinks = map.get(path) ?? [];
+      const pathLinks = customArrayDict.get(path) ?? [];
+      mapLinks.push(...pathLinks);
+      map.set(path, mapLinks);
+    }
+  }
+  return map;
+}
 async function saveNote(app, pathOrFile) {
   if (!(0, import_TAbstractFile.isMarkdownFile)(pathOrFile)) {
     return;
@@ -194,9 +208,10 @@ async function ensureMetadataCacheReady(app) {
   ensureMetadataCacheReady,
   getAllLinks,
   getBacklinksForFileSafe,
+  getBacklinksMap,
   getCacheSafe,
   getFrontMatterSafe,
   registerFile,
   tempRegisterFileAndRun
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/MetadataCache.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 MetadataCache\n * This module provides utility functions for working with the metadata cache in Obsidian.\n */\n\nimport type {\n  App,\n  CachedMetadata,\n  LinkCache,\n  MarkdownView,\n  ReferenceCache,\n  TAbstractFile\n} from 'obsidian';\nimport { TFile } from 'obsidian';\nimport type { CustomArrayDict } from 'obsidian-typings';\nimport {\n  createTFolderInstance,\n  parentFolderPath\n} from 'obsidian-typings/implementations';\n\nimport type { RetryOptions } from '../Async.ts';\nimport { retryWithTimeout } from '../Async.ts';\nimport { throwExpression } from '../Error.ts';\nimport type { CombinedFrontMatter } from './FrontMatter.ts';\nimport {\n  getPath,\n  isMarkdownFile\n} from './TAbstractFile.ts';\nimport type { PathOrFile } from './TFile.ts';\nimport {\n  getFile,\n  getFileOrNull\n} from './TFile.ts';\n\n/**\n * Retrieves the cached metadata for a given file or path.\n *\n * @param app - The Obsidian app instance.\n * @param fileOrPath - The file or path to retrieve the metadata for.\n * @param retryOptions - Optional retry options for the retrieval process.\n * @returns The cached metadata for the file, or null if it doesn't exist.\n */\nexport async function getCacheSafe(app: App, fileOrPath: PathOrFile, retryOptions: Partial<RetryOptions> = {}): Promise<CachedMetadata | null> {\n  const DEFAULT_RETRY_OPTIONS: Partial<RetryOptions> = { timeoutInMilliseconds: 60000 };\n  const overriddenOptions: Partial<RetryOptions> = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  let cache: CachedMetadata | null = null;\n\n  await retryWithTimeout(async () => {\n    const file = getFileOrNull(app, fileOrPath);\n\n    if (!file || file.deleted) {\n      cache = null;\n      return true;\n    }\n\n    await saveNote(app, file);\n\n    const fileInfo = app.metadataCache.getFileInfo(file.path);\n    const stat = await app.vault.adapter.stat(file.path);\n\n    if (!fileInfo) {\n      console.debug(`File cache info for ${file.path} is missing`);\n      return false;\n    } else if (!stat) {\n      console.debug(`File stat for ${file.path} is missing`);\n      return false;\n    } else if (fileInfo.mtime < stat.mtime) {\n      console.debug(`File cache info for ${file.path} is from ${new Date(fileInfo.mtime).toString()} which is older than the file modification timestamp ${new Date(stat.mtime).toString()}`);\n      return false;\n    } else {\n      cache = app.metadataCache.getFileCache(file);\n      if (!cache) {\n        console.debug(`File cache for ${file.path} is missing`);\n        return false;\n      } else {\n        return true;\n      }\n    }\n  }, overriddenOptions);\n\n  return cache;\n}\n\n/**\n * Retrieves all links from the provided cache.\n *\n * @param cache - The cached metadata.\n * @returns An array of reference caches representing the links.\n */\nexport function getAllLinks(cache: CachedMetadata): ReferenceCache[] {\n  let links: ReferenceCache[] = [];\n\n  if (cache.links) {\n    links.push(...cache.links);\n  }\n\n  if (cache.embeds) {\n    links.push(...cache.embeds);\n  }\n\n  links.sort((a, b) => a.position.start.offset - b.position.start.offset);\n\n  // BUG: https://forum.obsidian.md/t/bug-duplicated-links-in-metadatacache-inside-footnotes/85551\n  links = links.filter((link, index) => {\n    if (index === 0) {\n      return true;\n    }\n    const previousLink = links[index - 1] ?? throwExpression(new Error('Previous link not found'));\n    return link.position.start.offset !== previousLink.position.start.offset;\n  });\n\n  return links;\n}\n\n/**\n * Retrieves the backlinks for a file safely.\n *\n * @param app - The Obsidian application instance.\n * @param pathOrFile - The path or file object.\n * @param retryOptions - Optional retry options.\n * @returns A promise that resolves to an array dictionary of backlinks.\n */\nexport async function getBacklinksForFileSafe(app: App, pathOrFile: PathOrFile, retryOptions: Partial<RetryOptions> = {}): Promise<CustomArrayDict<LinkCache>> {\n  const DEFAULT_RETRY_OPTIONS: Partial<RetryOptions> = { timeoutInMilliseconds: 60000 };\n  const overriddenOptions: Partial<RetryOptions> = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  let backlinks: CustomArrayDict<LinkCache> = null as unknown as CustomArrayDict<LinkCache>;\n  await retryWithTimeout(async () => {\n    const file = getFile(app, pathOrFile);\n    await ensureMetadataCacheReady(app);\n    backlinks = tempRegisterFileAndRun(app, file, () => app.metadataCache.getBacklinksForFile(file));\n    for (const notePath of backlinks.keys()) {\n      const note = app.vault.getFileByPath(notePath);\n      if (!note) {\n        return false;\n      }\n\n      await saveNote(app, note);\n\n      const content = await app.vault.read(note);\n      const links = backlinks.get(notePath) ?? throwExpression(new Error('Backlinks not found'));\n      for (const link of links) {\n        const actualLink = content.slice(link.position.start.offset, link.position.end.offset);\n        if (actualLink !== link.original) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }, overriddenOptions);\n\n  return backlinks;\n}\n\n/**\n * Saves the specified note in the Obsidian app.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The note to be saved.\n * @returns A promise that resolves when the note is saved.\n */\nasync function saveNote(app: App, pathOrFile: PathOrFile): Promise<void> {\n  if (!isMarkdownFile(pathOrFile)) {\n    return;\n  }\n\n  const path = getPath(pathOrFile);\n\n  for (const leaf of app.workspace.getLeavesOfType('markdown')) {\n    const view = leaf.view as MarkdownView;\n    if (view.file?.path === path) {\n      await view.save();\n    }\n  }\n}\n\n/**\n * Retrieves the front matter from the metadata cache safely.\n *\n * @typeParam CustomFrontMatter - The type of custom front matter.\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file to retrieve the front matter from.\n * @returns The combined front matter.\n */\nexport async function getFrontMatterSafe<CustomFrontMatter = unknown>(app: App, pathOrFile: PathOrFile): Promise<CombinedFrontMatter<CustomFrontMatter>> {\n  const cache = await getCacheSafe(app, pathOrFile);\n  return (cache?.frontmatter ?? {}) as CombinedFrontMatter<CustomFrontMatter>;\n}\n\n/**\n * Temporarily registers a file and runs a function.\n *\n * @param app - The Obsidian app instance.\n * @param file - The file to temporarily register.\n * @param fn - The function to run.\n * @returns The result of the function.\n */\nexport function tempRegisterFileAndRun<T>(app: App, file: TAbstractFile, fn: () => T): T {\n  const unregister = registerFile(app, file);\n\n  try {\n    return fn();\n  } finally {\n    unregister();\n  }\n}\n\n/***\n * Registers a file in the Obsidian app.\n *\n * @param app - The Obsidian app instance.\n * @param file - The file to register.\n * @returns A function that unregisters the file.\n */\nexport function registerFile(app: App, file: TAbstractFile): () => void {\n  if (!file.deleted) {\n    return () => {\n      // Do nothing\n    };\n  }\n\n  const deletedPaths: string[] = [];\n\n  let deletedFile: TAbstractFile = file;\n\n  while (deletedFile.deleted) {\n    deletedPaths.push(deletedFile.path);\n    app.vault.fileMap[deletedFile.path] = deletedFile;\n    deletedFile = deletedFile.parent ?? createTFolderInstance(app.vault, parentFolderPath(deletedFile.path));\n  }\n\n  if (file instanceof TFile) {\n    app.metadataCache.uniqueFileLookup.add(file.name.toLowerCase(), file);\n  }\n\n  return () => {\n    for (const path of deletedPaths) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete app.vault.fileMap[path];\n    }\n\n    if (file instanceof TFile) {\n      app.metadataCache.uniqueFileLookup.remove(file.name.toLowerCase(), file);\n    }\n  };\n}\n\n/**\n * Ensures that the metadata cache is ready for all files.\n * @param app - The Obsidian app instance.\n * @returns A promise that resolves when the metadata cache is ready.\n */\nexport async function ensureMetadataCacheReady(app: App): Promise<void> {\n  for (const [path, cache] of Object.entries(app.metadataCache.fileCache)) {\n    if (!cache.hash) {\n      continue;\n    }\n\n    if (app.metadataCache.metadataCache[cache.hash]) {\n      continue;\n    }\n\n    await getCacheSafe(app, path);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/MetadataCache.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 MetadataCache\n * This module provides utility functions for working with the metadata cache in Obsidian.\n */\n\nimport type {\n  App,\n  CachedMetadata,\n  MarkdownView,\n  ReferenceCache,\n  TAbstractFile\n} from 'obsidian';\nimport { TFile } from 'obsidian';\nimport type { CustomArrayDict } from 'obsidian-typings';\nimport {\n  createTFolderInstance,\n  parentFolderPath\n} from 'obsidian-typings/implementations';\n\nimport type { RetryOptions } from '../Async.ts';\nimport { retryWithTimeout } from '../Async.ts';\nimport { throwExpression } from '../Error.ts';\nimport type { CombinedFrontMatter } from './FrontMatter.ts';\nimport {\n  getPath,\n  isMarkdownFile\n} from './TAbstractFile.ts';\nimport type { PathOrFile } from './TFile.ts';\nimport {\n  getFile,\n  getFileOrNull\n} from './TFile.ts';\n\n/**\n * Retrieves the cached metadata for a given file or path.\n *\n * @param app - The Obsidian app instance.\n * @param fileOrPath - The file or path to retrieve the metadata for.\n * @param retryOptions - Optional retry options for the retrieval process.\n * @returns The cached metadata for the file, or null if it doesn't exist.\n */\nexport async function getCacheSafe(app: App, fileOrPath: PathOrFile, retryOptions: Partial<RetryOptions> = {}): Promise<CachedMetadata | null> {\n  const DEFAULT_RETRY_OPTIONS: Partial<RetryOptions> = { timeoutInMilliseconds: 60000 };\n  const overriddenOptions: Partial<RetryOptions> = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  let cache: CachedMetadata | null = null;\n\n  await retryWithTimeout(async () => {\n    const file = getFileOrNull(app, fileOrPath);\n\n    if (!file || file.deleted) {\n      cache = null;\n      return true;\n    }\n\n    await saveNote(app, file);\n\n    const fileInfo = app.metadataCache.getFileInfo(file.path);\n    const stat = await app.vault.adapter.stat(file.path);\n\n    if (!fileInfo) {\n      console.debug(`File cache info for ${file.path} is missing`);\n      return false;\n    } else if (!stat) {\n      console.debug(`File stat for ${file.path} is missing`);\n      return false;\n    } else if (fileInfo.mtime < stat.mtime) {\n      console.debug(`File cache info for ${file.path} is from ${new Date(fileInfo.mtime).toString()} which is older than the file modification timestamp ${new Date(stat.mtime).toString()}`);\n      return false;\n    } else {\n      cache = app.metadataCache.getFileCache(file);\n      if (!cache) {\n        console.debug(`File cache for ${file.path} is missing`);\n        return false;\n      } else {\n        return true;\n      }\n    }\n  }, overriddenOptions);\n\n  return cache;\n}\n\n/**\n * Retrieves all links from the provided cache.\n *\n * @param cache - The cached metadata.\n * @returns An array of reference caches representing the links.\n */\nexport function getAllLinks(cache: CachedMetadata): ReferenceCache[] {\n  let links: ReferenceCache[] = [];\n\n  if (cache.links) {\n    links.push(...cache.links);\n  }\n\n  if (cache.embeds) {\n    links.push(...cache.embeds);\n  }\n\n  links.sort((a, b) => a.position.start.offset - b.position.start.offset);\n\n  // BUG: https://forum.obsidian.md/t/bug-duplicated-links-in-metadatacache-inside-footnotes/85551\n  links = links.filter((link, index) => {\n    if (index === 0) {\n      return true;\n    }\n    const previousLink = links[index - 1] ?? throwExpression(new Error('Previous link not found'));\n    return link.position.start.offset !== previousLink.position.start.offset;\n  });\n\n  return links;\n}\n\n/**\n * Retrieves the backlinks for a file safely.\n *\n * @param app - The Obsidian application instance.\n * @param pathOrFile - The path or file object.\n * @param retryOptions - Optional retry options.\n * @returns A promise that resolves to an array dictionary of backlinks.\n */\nexport async function getBacklinksForFileSafe(app: App, pathOrFile: PathOrFile, retryOptions: Partial<RetryOptions> = {}): Promise<CustomArrayDict<ReferenceCache>> {\n  const DEFAULT_RETRY_OPTIONS: Partial<RetryOptions> = { timeoutInMilliseconds: 60000 };\n  const overriddenOptions: Partial<RetryOptions> = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  let backlinks: CustomArrayDict<ReferenceCache> = null as unknown as CustomArrayDict<ReferenceCache>;\n  await retryWithTimeout(async () => {\n    const file = getFile(app, pathOrFile);\n    await ensureMetadataCacheReady(app);\n    backlinks = tempRegisterFileAndRun(app, file, () => app.metadataCache.getBacklinksForFile(file));\n    for (const notePath of backlinks.keys()) {\n      const note = app.vault.getFileByPath(notePath);\n      if (!note) {\n        return false;\n      }\n\n      await saveNote(app, note);\n\n      const content = await app.vault.read(note);\n      const links = backlinks.get(notePath) ?? throwExpression(new Error('Backlinks not found'));\n      for (const link of links) {\n        const actualLink = content.slice(link.position.start.offset, link.position.end.offset);\n        if (actualLink !== link.original) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }, overriddenOptions);\n\n  return backlinks;\n}\n\n/**\n * Gets the backlinks map for the specified files.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFiles - The paths or files to get the backlinks for.\n * @param retryOptions - Optional retry options.\n * @returns A promise that resolves to a map of backlinks.\n */\nexport async function getBacklinksMap(app: App, pathOrFiles: PathOrFile[], retryOptions: Partial<RetryOptions> = {}): Promise<Map<string, ReferenceCache[]>> {\n  const map = new Map<string, ReferenceCache[]>();\n  for (const pathOrFile of pathOrFiles) {\n    const customArrayDict = await getBacklinksForFileSafe(app, pathOrFile, retryOptions);\n    for (const path of customArrayDict.keys()) {\n      const mapLinks = map.get(path) ?? [];\n      const pathLinks = customArrayDict.get(path) ?? [];\n      mapLinks.push(...pathLinks);\n      map.set(path, mapLinks);\n    }\n  }\n  return map;\n}\n\n/**\n * Saves the specified note in the Obsidian app.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The note to be saved.\n * @returns A promise that resolves when the note is saved.\n */\nasync function saveNote(app: App, pathOrFile: PathOrFile): Promise<void> {\n  if (!isMarkdownFile(pathOrFile)) {\n    return;\n  }\n\n  const path = getPath(pathOrFile);\n\n  for (const leaf of app.workspace.getLeavesOfType('markdown')) {\n    const view = leaf.view as MarkdownView;\n    if (view.file?.path === path) {\n      await view.save();\n    }\n  }\n}\n\n/**\n * Retrieves the front matter from the metadata cache safely.\n *\n * @typeParam CustomFrontMatter - The type of custom front matter.\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file to retrieve the front matter from.\n * @returns The combined front matter.\n */\nexport async function getFrontMatterSafe<CustomFrontMatter = unknown>(app: App, pathOrFile: PathOrFile): Promise<CombinedFrontMatter<CustomFrontMatter>> {\n  const cache = await getCacheSafe(app, pathOrFile);\n  return (cache?.frontmatter ?? {}) as CombinedFrontMatter<CustomFrontMatter>;\n}\n\n/**\n * Temporarily registers a file and runs a function.\n *\n * @param app - The Obsidian app instance.\n * @param file - The file to temporarily register.\n * @param fn - The function to run.\n * @returns The result of the function.\n */\nexport function tempRegisterFileAndRun<T>(app: App, file: TAbstractFile, fn: () => T): T {\n  const unregister = registerFile(app, file);\n\n  try {\n    return fn();\n  } finally {\n    unregister();\n  }\n}\n\n/***\n * Registers a file in the Obsidian app.\n *\n * @param app - The Obsidian app instance.\n * @param file - The file to register.\n * @returns A function that unregisters the file.\n */\nexport function registerFile(app: App, file: TAbstractFile): () => void {\n  if (!file.deleted) {\n    return () => {\n      // Do nothing\n    };\n  }\n\n  const deletedPaths: string[] = [];\n\n  let deletedFile: TAbstractFile = file;\n\n  while (deletedFile.deleted) {\n    deletedPaths.push(deletedFile.path);\n    app.vault.fileMap[deletedFile.path] = deletedFile;\n    deletedFile = deletedFile.parent ?? createTFolderInstance(app.vault, parentFolderPath(deletedFile.path));\n  }\n\n  if (file instanceof TFile) {\n    app.metadataCache.uniqueFileLookup.add(file.name.toLowerCase(), file);\n  }\n\n  return () => {\n    for (const path of deletedPaths) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete app.vault.fileMap[path];\n    }\n\n    if (file instanceof TFile) {\n      app.metadataCache.uniqueFileLookup.remove(file.name.toLowerCase(), file);\n    }\n  };\n}\n\n/**\n * Ensures that the metadata cache is ready for all files.\n * @param app - The Obsidian app instance.\n * @returns A promise that resolves when the metadata cache is ready.\n */\nexport async function ensureMetadataCacheReady(app: App): Promise<void> {\n  for (const [path, cache] of Object.entries(app.metadataCache.fileCache)) {\n    if (!cache.hash) {\n      continue;\n    }\n\n    if (app.metadataCache.metadataCache[cache.hash]) {\n      continue;\n    }\n\n    await getCacheSafe(app, path);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -2,7 +2,7 @@
  * @packageDocumentation MetadataCache
  * This module provides utility functions for working with the metadata cache in Obsidian.
  */
-import type { App, CachedMetadata, LinkCache, ReferenceCache, TAbstractFile } from 'obsidian';
+import type { App, CachedMetadata, ReferenceCache, TAbstractFile } from 'obsidian';
 import type { CustomArrayDict } from 'obsidian-typings';
 import type { RetryOptions } from '../Async.ts';
 import type { CombinedFrontMatter } from './FrontMatter.ts';
@@ -31,7 +31,16 @@ export declare function getAllLinks(cache: CachedMetadata): ReferenceCache[];
  * @param retryOptions - Optional retry options.
  * @returns A promise that resolves to an array dictionary of backlinks.
  */
-export declare function getBacklinksForFileSafe(app: App, pathOrFile: PathOrFile, retryOptions?: Partial<RetryOptions>): Promise<CustomArrayDict<LinkCache>>;
+export declare function getBacklinksForFileSafe(app: App, pathOrFile: PathOrFile, retryOptions?: Partial<RetryOptions>): Promise<CustomArrayDict<ReferenceCache>>;
+/**
+ * Gets the backlinks map for the specified files.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFiles - The paths or files to get the backlinks for.
+ * @param retryOptions - Optional retry options.
+ * @returns A promise that resolves to a map of backlinks.
+ */
+export declare function getBacklinksMap(app: App, pathOrFiles: PathOrFile[], retryOptions?: Partial<RetryOptions>): Promise<Map<string, ReferenceCache[]>>;
 /**
  * Retrieves the front matter from the metadata cache safely.
  *

package/dist/lib/obsidian/Plugin/PluginBase.cjs

@@ -29,8 +29,8 @@ __export(PluginBase_exports, {
 });
 module.exports = __toCommonJS(PluginBase_exports);
 var import_obsidian = require('obsidian');
-var import_Async = require('../../Async.cjs');
 var import_Error = require('../../Error.cjs');
+var import_ChainedPromise = require('../ChainedPromise.cjs');
 var import_PluginSettings = require('./PluginSettings.cjs');
 var __import_meta_url = globalThis["import.meta.url"] ?? (() => {
   if (typeof __filename !== "string") {
@@ -48,7 +48,7 @@ class PluginBase extends import_obsidian.Plugin {
   notice;
   _abortSignal;
   /**
-   * Gets the AbortSignal used for aborting asynchronous operations.
+   * Gets the AbortSignal used for aborting long-running operations.
    *
    * @returns The abort signal.
    */
@@ -75,15 +75,15 @@ class PluginBase extends import_obsidian.Plugin {
    * Called when the plugin is loaded
    */
   onload() {
-    (0, import_Async.invokeAsyncSafely)((async () => {
+    this.register((0, import_Error.registerAsyncErrorEventHandler)(() => {
+      this.showNotice("An unhandled error occurred. Please check the console for more information.");
+    }));
+    (0, import_ChainedPromise.chainAsyncFn)(this.app, async () => {
       await this.loadSettings();
       const pluginSettingsTab = this.createPluginSettingsTab();
       if (pluginSettingsTab) {
         this.addSettingTab(pluginSettingsTab);
       }
-      this.register((0, import_Error.registerAsyncErrorEventHandler)(() => {
-        this.showNotice("An unhandled error occurred. Please check the console for more information.");
-      }));
       const abortController = new AbortController();
       this._abortSignal = abortController.signal;
       this.register(() => {
@@ -91,7 +91,7 @@ class PluginBase extends import_obsidian.Plugin {
       });
       await this.onloadComplete();
       this.app.workspace.onLayoutReady(this.onLayoutReady.bind(this));
-    })());
+    });
   }
   /**
    * Called when the layout is ready. This method can be overridden by subclasses to perform actions once
@@ -99,7 +99,6 @@ class PluginBase extends import_obsidian.Plugin {
    *
    * @returns A promise or void indicating the completion of the layout setup.
    */
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
   onLayoutReady() {
   }
   /**
@@ -147,4 +146,4 @@ ${message}`);
 0 && (module.exports = {
   PluginBase
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/Plugin/PluginBase.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 PluginBase\n * Base class for Obsidian plugins providing utility methods for settings management, error handling, and notifications.\n *\n * This class simplifies the process of managing plugin settings, displaying notifications, and handling errors.\n * Subclasses should implement methods to create default settings and settings tabs, and complete plugin-specific\n * loading tasks.\n */\n\nimport {\n  Notice,\n  Plugin,\n  PluginSettingTab\n} from 'obsidian';\n\nimport type { MaybePromise } from '../../Async.ts';\nimport { invokeAsyncSafely } from '../../Async.ts';\nimport { registerAsyncErrorEventHandler } from '../../Error.ts';\nimport {\n  clonePluginSettings,\n  loadPluginSettings\n} from './PluginSettings.ts';\n\n/**\n * Base class for creating Obsidian plugins with built-in support for settings management, error handling, and notifications.\n *\n * @typeParam PluginSettings - The type representing the plugin settings object.\n */\nexport abstract class PluginBase<PluginSettings extends object> extends Plugin {\n  private _settings!: PluginSettings;\n  private notice?: Notice;\n  private _abortSignal!: AbortSignal;\n\n  /**\n   * Gets the AbortSignal used for aborting asynchronous operations.\n   *\n   * @returns The abort signal.\n   */\n  protected get abortSignal(): AbortSignal {\n    return this._abortSignal;\n  }\n\n  /**\n   * Gets a copy of the current plugin settings.\n   *\n   * @returns A copy of the plugin settings.\n   */\n  public get settingsCopy(): PluginSettings {\n    return clonePluginSettings(this.createDefaultPluginSettings.bind(this), this.settings);\n  }\n\n  /**\n   * Gets the plugin settings.\n   *\n   * @returns The plugin settings.\n   */\n  protected get settings(): PluginSettings {\n    return this._settings;\n  }\n\n  /**\n   * Creates the default plugin settings. This method must be implemented by subclasses.\n   *\n   * @returns The default plugin settings.\n   */\n  protected abstract createDefaultPluginSettings(): PluginSettings;\n\n  /**\n   * Creates a plugin settings tab. This method must be implemented by subclasses.\n   *\n   * @returns The settings tab or null if not applicable.\n   */\n  protected abstract createPluginSettingsTab(): PluginSettingTab | null;\n\n  /**\n   * Called when the plugin is loaded\n   */\n  public override onload(): void {\n    invokeAsyncSafely((async (): Promise<void> => {\n      await this.loadSettings();\n      const pluginSettingsTab = this.createPluginSettingsTab();\n      if (pluginSettingsTab) {\n        this.addSettingTab(pluginSettingsTab);\n      }\n      this.register(registerAsyncErrorEventHandler(() => {\n        this.showNotice('An unhandled error occurred. Please check the console for more information.');\n      }));\n\n      const abortController = new AbortController();\n      this._abortSignal = abortController.signal;\n      this.register(() => {\n        abortController.abort();\n      });\n      await this.onloadComplete();\n      this.app.workspace.onLayoutReady(this.onLayoutReady.bind(this));\n    })());\n  }\n\n  /**\n   * Called when the plugin loading is complete. This method must be implemented by subclasses to perform\n   * any additional setup required after loading is complete.\n   *\n   * @returns A promise or void indicating the completion of the load process.\n   */\n  protected abstract onloadComplete(): MaybePromise<void>;\n\n  /**\n   * Called when the layout is ready. This method can be overridden by subclasses to perform actions once\n   * the layout is ready.\n   *\n   * @returns A promise or void indicating the completion of the layout setup.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  protected onLayoutReady(): MaybePromise<void> { }\n\n  /**\n   * Loads the plugin settings from the saved data.\n   *\n   * @returns A promise that resolves when the settings are loaded.\n   */\n  private async loadSettings(): Promise<void> {\n    const data = await this.loadData() as unknown;\n    this._settings = await this.parseSettings(data);\n  }\n\n  /**\n   * Parses the provided settings data and returns the parsed `PluginSettings`.\n   *\n   * @param data - The raw data to be parsed into `PluginSettings`.\n   * @returns A promise that resolves to `PluginSettings` or the settings directly.\n   */\n  protected parseSettings(data: unknown): MaybePromise<PluginSettings> {\n    return loadPluginSettings(this.createDefaultPluginSettings.bind(this), data);\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @param newSettings - The new settings to save.\n   * @returns A promise that resolves when the settings are saved.\n   */\n  public async saveSettings(newSettings: PluginSettings): Promise<void> {\n    this._settings = clonePluginSettings(this.createDefaultPluginSettings.bind(this), newSettings);\n    await this.saveData(this.settings);\n  }\n\n  /**\n   * Displays a notice message to the user.\n   *\n   * @param message - The message to display.\n   */\n  protected showNotice(message: string): void {\n    if (this.notice) {\n      this.notice.hide();\n    }\n\n    this.notice = new Notice(`${this.manifest.name}\\n${message}`);\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,sBAIO;AAGP,mBAAkC;AAClC,mBAA+C;AAC/C,4BAGO;AA3BP,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;AA6BO,MAAe,mBAAkD,uBAAO;AAAA,EACrE;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOR,IAAc,cAA2B;AACvC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAW,eAA+B;AACxC,eAAO,2CAAoB,KAAK,4BAA4B,KAAK,IAAI,GAAG,KAAK,QAAQ;AAAA,EACvF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAc,WAA2B;AACvC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAmBgB,SAAe;AAC7B,yCAAmB,YAA2B;AAC5C,YAAM,KAAK,aAAa;AACxB,YAAM,oBAAoB,KAAK,wBAAwB;AACvD,UAAI,mBAAmB;AACrB,aAAK,cAAc,iBAAiB;AAAA,MACtC;AACA,WAAK,aAAS,6CAA+B,MAAM;AACjD,aAAK,WAAW,6EAA6E;AAAA,MAC/F,CAAC,CAAC;AAEF,YAAM,kBAAkB,IAAI,gBAAgB;AAC5C,WAAK,eAAe,gBAAgB;AACpC,WAAK,SAAS,MAAM;AAClB,wBAAgB,MAAM;AAAA,MACxB,CAAC;AACD,YAAM,KAAK,eAAe;AAC1B,WAAK,IAAI,UAAU,cAAc,KAAK,cAAc,KAAK,IAAI,CAAC;AAAA,IAChE,GAAG,CAAC;AAAA,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBU,gBAAoC;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOhD,MAAc,eAA8B;AAC1C,UAAM,OAAO,MAAM,KAAK,SAAS;AACjC,SAAK,YAAY,MAAM,KAAK,cAAc,IAAI;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,cAAc,MAA6C;AACnE,eAAO,0CAAmB,KAAK,4BAA4B,KAAK,IAAI,GAAG,IAAI;AAAA,EAC7E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,aAAa,aAA4C;AACpE,SAAK,gBAAY,2CAAoB,KAAK,4BAA4B,KAAK,IAAI,GAAG,WAAW;AAC7F,UAAM,KAAK,SAAS,KAAK,QAAQ;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOU,WAAW,SAAuB;AAC1C,QAAI,KAAK,QAAQ;AACf,WAAK,OAAO,KAAK;AAAA,IACnB;AAEA,SAAK,SAAS,IAAI,uBAAO,GAAG,KAAK,SAAS,IAAI;AAAA,EAAK,OAAO,EAAE;AAAA,EAC9D;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/Plugin/PluginBase.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 PluginBase\n * Base class for Obsidian plugins providing utility methods for settings management, error handling, and notifications.\n *\n * This class simplifies the process of managing plugin settings, displaying notifications, and handling errors.\n * Subclasses should implement methods to create default settings and settings tabs, and complete plugin-specific\n * loading tasks.\n */\n\nimport {\n  Notice,\n  Plugin,\n  PluginSettingTab\n} from 'obsidian';\n\nimport type { MaybePromise } from '../../Async.ts';\nimport { registerAsyncErrorEventHandler } from '../../Error.ts';\nimport { chainAsyncFn } from '../ChainedPromise.ts';\nimport {\n  clonePluginSettings,\n  loadPluginSettings\n} from './PluginSettings.ts';\n\n/**\n * Base class for creating Obsidian plugins with built-in support for settings management, error handling, and notifications.\n *\n * @typeParam PluginSettings - The type representing the plugin settings object.\n */\nexport abstract class PluginBase<PluginSettings extends object> extends Plugin {\n  private _settings!: PluginSettings;\n  private notice?: Notice;\n  private _abortSignal!: AbortSignal;\n\n  /**\n   * Gets the AbortSignal used for aborting long-running operations.\n   *\n   * @returns The abort signal.\n   */\n  protected get abortSignal(): AbortSignal {\n    return this._abortSignal;\n  }\n\n  /**\n   * Gets a copy of the current plugin settings.\n   *\n   * @returns A copy of the plugin settings.\n   */\n  public get settingsCopy(): PluginSettings {\n    return clonePluginSettings(this.createDefaultPluginSettings.bind(this), this.settings);\n  }\n\n  /**\n   * Gets the plugin settings.\n   *\n   * @returns The plugin settings.\n   */\n  protected get settings(): PluginSettings {\n    return this._settings;\n  }\n\n  /**\n   * Creates the default plugin settings. This method must be implemented by subclasses.\n   *\n   * @returns The default plugin settings.\n   */\n  protected abstract createDefaultPluginSettings(): PluginSettings;\n\n  /**\n   * Creates a plugin settings tab. This method must be implemented by subclasses.\n   *\n   * @returns The settings tab or null if not applicable.\n   */\n  protected abstract createPluginSettingsTab(): PluginSettingTab | null;\n\n  /**\n   * Called when the plugin is loaded\n   */\n  public override onload(): void {\n    this.register(registerAsyncErrorEventHandler(() => {\n      this.showNotice('An unhandled error occurred. Please check the console for more information.');\n    }));\n\n    chainAsyncFn(this.app, async (): Promise<void> => {\n      await this.loadSettings();\n      const pluginSettingsTab = this.createPluginSettingsTab();\n      if (pluginSettingsTab) {\n        this.addSettingTab(pluginSettingsTab);\n      }\n\n      const abortController = new AbortController();\n      this._abortSignal = abortController.signal;\n      this.register(() => {\n        abortController.abort();\n      });\n      await this.onloadComplete();\n      this.app.workspace.onLayoutReady(this.onLayoutReady.bind(this));\n    });\n  }\n\n  /**\n   * Called when the plugin loading is complete. This method must be implemented by subclasses to perform\n   * any additional setup required after loading is complete.\n   *\n   * @returns A promise or void indicating the completion of the load process.\n   */\n  protected abstract onloadComplete(): MaybePromise<void>;\n\n  /**\n   * Called when the layout is ready. This method can be overridden by subclasses to perform actions once\n   * the layout is ready.\n   *\n   * @returns A promise or void indicating the completion of the layout setup.\n   */\n  protected onLayoutReady(): MaybePromise<void> {\n    // Does nothing by default.\n  }\n\n  /**\n   * Loads the plugin settings from the saved data.\n   *\n   * @returns A promise that resolves when the settings are loaded.\n   */\n  private async loadSettings(): Promise<void> {\n    const data = await this.loadData() as unknown;\n    this._settings = await this.parseSettings(data);\n  }\n\n  /**\n   * Parses the provided settings data and returns the parsed `PluginSettings`.\n   *\n   * @param data - The raw data to be parsed into `PluginSettings`.\n   * @returns A promise that resolves to `PluginSettings` or the settings directly.\n   */\n  protected parseSettings(data: unknown): MaybePromise<PluginSettings> {\n    return loadPluginSettings(this.createDefaultPluginSettings.bind(this), data);\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @param newSettings - The new settings to save.\n   * @returns A promise that resolves when the settings are saved.\n   */\n  public async saveSettings(newSettings: PluginSettings): Promise<void> {\n    this._settings = clonePluginSettings(this.createDefaultPluginSettings.bind(this), newSettings);\n    await this.saveData(this.settings);\n  }\n\n  /**\n   * Displays a notice message to the user.\n   *\n   * @param message - The message to display.\n   */\n  protected showNotice(message: string): void {\n    if (this.notice) {\n      this.notice.hide();\n    }\n\n    this.notice = new Notice(`${this.manifest.name}\\n${message}`);\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,sBAIO;AAGP,mBAA+C;AAC/C,4BAA6B;AAC7B,4BAGO;AA3BP,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;AA6BO,MAAe,mBAAkD,uBAAO;AAAA,EACrE;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOR,IAAc,cAA2B;AACvC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAW,eAA+B;AACxC,eAAO,2CAAoB,KAAK,4BAA4B,KAAK,IAAI,GAAG,KAAK,QAAQ;AAAA,EACvF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAc,WAA2B;AACvC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAmBgB,SAAe;AAC7B,SAAK,aAAS,6CAA+B,MAAM;AACjD,WAAK,WAAW,6EAA6E;AAAA,IAC/F,CAAC,CAAC;AAEF,4CAAa,KAAK,KAAK,YAA2B;AAChD,YAAM,KAAK,aAAa;AACxB,YAAM,oBAAoB,KAAK,wBAAwB;AACvD,UAAI,mBAAmB;AACrB,aAAK,cAAc,iBAAiB;AAAA,MACtC;AAEA,YAAM,kBAAkB,IAAI,gBAAgB;AAC5C,WAAK,eAAe,gBAAgB;AACpC,WAAK,SAAS,MAAM;AAClB,wBAAgB,MAAM;AAAA,MACxB,CAAC;AACD,YAAM,KAAK,eAAe;AAC1B,WAAK,IAAI,UAAU,cAAc,KAAK,cAAc,KAAK,IAAI,CAAC;AAAA,IAChE,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBU,gBAAoC;AAAA,EAE9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAc,eAA8B;AAC1C,UAAM,OAAO,MAAM,KAAK,SAAS;AACjC,SAAK,YAAY,MAAM,KAAK,cAAc,IAAI;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,cAAc,MAA6C;AACnE,eAAO,0CAAmB,KAAK,4BAA4B,KAAK,IAAI,GAAG,IAAI;AAAA,EAC7E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,aAAa,aAA4C;AACpE,SAAK,gBAAY,2CAAoB,KAAK,4BAA4B,KAAK,IAAI,GAAG,WAAW;AAC7F,UAAM,KAAK,SAAS,KAAK,QAAQ;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOU,WAAW,SAAuB;AAC1C,QAAI,KAAK,QAAQ;AACf,WAAK,OAAO,KAAK;AAAA,IACnB;AAEA,SAAK,SAAS,IAAI,uBAAO,GAAG,KAAK,SAAS,IAAI;AAAA,EAAK,OAAO,EAAE;AAAA,EAC9D;AACF;",
  "names": []
}


package/dist/lib/obsidian/Plugin/PluginBase.d.ts

@@ -18,7 +18,7 @@ export declare abstract class PluginBase<PluginSettings extends object> extends
     private notice?;
     private _abortSignal;
     /**
-     * Gets the AbortSignal used for aborting asynchronous operations.
+     * Gets the AbortSignal used for aborting long-running operations.
      *
      * @returns The abort signal.
      */

package/dist/lib/obsidian/RenameDeleteHandler.cjs

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

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


package/dist/lib/obsidian/index.cjs

@@ -39,6 +39,7 @@ __export(obsidian_exports, {
   AttachmentPath: () => AttachmentPath,
   Backlink: () => Backlink,
   Callout: () => Callout,
+  ChainedPromise: () => ChainedPromise,
   Dataview: () => Dataview,
   DataviewLink: () => DataviewLink,
   FrontMatter: () => FrontMatter,
@@ -60,6 +61,7 @@ var App = __toESM(require('./App.cjs'), 1);
 var AttachmentPath = __toESM(require('./AttachmentPath.cjs'), 1);
 var Backlink = __toESM(require('./Backlink.cjs'), 1);
 var Callout = __toESM(require('./Callout.cjs'), 1);
+var ChainedPromise = __toESM(require('./ChainedPromise.cjs'), 1);
 var Dataview = __toESM(require('./Dataview.cjs'), 1);
 var DataviewLink = __toESM(require('./DataviewLink.cjs'), 1);
 var FrontMatter = __toESM(require('./FrontMatter.cjs'), 1);
@@ -92,6 +94,7 @@ var __process = globalThis["process"] ?? {
   AttachmentPath,
   Backlink,
   Callout,
+  ChainedPromise,
   Dataview,
   DataviewLink,
   FrontMatter,
@@ -108,4 +111,4 @@ var __process = globalThis["process"] ?? {
   TFolder,
   Vault
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL29ic2lkaWFuL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJ2YXIgX19pbXBvcnRfbWV0YV91cmwgPSBnbG9iYWxUaGlzWydpbXBvcnQubWV0YS51cmwnXSA/PyAoKCk9PntpZih0eXBlb2YgX19maWxlbmFtZSE9PVwic3RyaW5nXCIpe3JldHVybiBuZXcgVVJMKHdpbmRvdy5sb2NhdGlvbi5ocmVmKX1yZXR1cm4gcmVxdWlyZShcIm5vZGU6dXJsXCIpLnBhdGhUb0ZpbGVVUkwoX19maWxlbmFtZSl9KSgpO1xudmFyIF9fcHJvY2VzcyA9IGdsb2JhbFRoaXNbJ3Byb2Nlc3MnXSA/PyB7XG4gIFwiY3dkXCI6ICgpPT5cIi9cIixcbiAgXCJlbnZcIjoge30sXG4gIFwicGxhdGZvcm1cIjogXCJhbmRyb2lkXCJcbn07XG4vKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgQXBwIGZyb20gJy4vQXBwLnRzJztcbmV4cG9ydCAqIGFzIEF0dGFjaG1lbnRQYXRoIGZyb20gJy4vQXR0YWNobWVudFBhdGgudHMnO1xuZXhwb3J0ICogYXMgQmFja2xpbmsgZnJvbSAnLi9CYWNrbGluay50cyc7XG5leHBvcnQgKiBhcyBDYWxsb3V0IGZyb20gJy4vQ2FsbG91dC50cyc7XG5leHBvcnQgKiBhcyBEYXRhdmlldyBmcm9tICcuL0RhdGF2aWV3LnRzJztcbmV4cG9ydCAqIGFzIERhdGF2aWV3TGluayBmcm9tICcuL0RhdGF2aWV3TGluay50cyc7XG5leHBvcnQgKiBhcyBGcm9udE1hdHRlciBmcm9tICcuL0Zyb250TWF0dGVyLnRzJztcbmV4cG9ydCAqIGFzIExpbmsgZnJvbSAnLi9MaW5rLnRzJztcbmV4cG9ydCAqIGFzIE1hcmtkb3duQ29kZUJsb2NrUHJvY2Vzc29yIGZyb20gJy4vTWFya2Rvd25Db2RlQmxvY2tQcm9jZXNzb3IudHMnO1xuZXhwb3J0ICogYXMgTWV0YWRhdGFDYWNoZSBmcm9tICcuL01ldGFkYXRhQ2FjaGUudHMnO1xuZXhwb3J0ICogYXMgTW9kYWwgZnJvbSAnLi9Nb2RhbC9pbmRleC50cyc7XG5leHBvcnQgKiBhcyBPYnNpZGlhblNldHRpbmdzIGZyb20gJy4vT2JzaWRpYW5TZXR0aW5ncy50cyc7XG5leHBvcnQgKiBhcyBQbHVnaW4gZnJvbSAnLi9QbHVnaW4vaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgUmVuYW1lRGVsZXRlSGFuZGxlciBmcm9tICcuL1JlbmFtZURlbGV0ZUhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgUmVzb3VyY2VVcmwgZnJvbSAnLi9SZXNvdXJjZVVybC50cyc7XG5leHBvcnQgKiBhcyBUQWJzdHJhY3RGaWxlIGZyb20gJy4vVEFic3RyYWN0RmlsZS50cyc7XG5leHBvcnQgKiBhcyBURmlsZSBmcm9tICcuL1RGaWxlLnRzJztcbmV4cG9ydCAqIGFzIFRGb2xkZXIgZnJvbSAnLi9URm9sZGVyLnRzJztcbmV4cG9ydCAqIGFzIFZhdWx0IGZyb20gJy4vVmF1bHQudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBUUEsVUFBcUI7QUFDckIscUJBQWdDO0FBQ2hDLGVBQTBCO0FBQzFCLGNBQXlCO0FBQ3pCLGVBQTBCO0FBQzFCLG1CQUE4QjtBQUM5QixrQkFBNkI7QUFDN0IsV0FBc0I7QUFDdEIsaUNBQTRDO0FBQzVDLG9CQUErQjtBQUMvQixZQUF1QjtBQUN2Qix1QkFBa0M7QUFDbEMsYUFBd0I7QUFDeEIsMEJBQXFDO0FBQ3JDLGtCQUE2QjtBQUM3QixvQkFBK0I7QUFDL0IsWUFBdUI7QUFDdkIsY0FBeUI7QUFDekIsWUFBdUI7QUExQnZCLElBQUksb0JBQW9CLFdBQVcsaUJBQWlCLE1BQU0sTUFBSTtBQUFDLE1BQUcsT0FBTyxlQUFhLFVBQVM7QUFBQyxXQUFPLElBQUksSUFBSSxPQUFPLFNBQVMsSUFBSTtBQUFBLEVBQUM7QUFBQyxTQUFPLFFBQVEsVUFBVSxFQUFFLGNBQWMsVUFBVTtBQUFDLEdBQUc7QUFDNUwsSUFBSSxZQUFZLFdBQVcsU0FBUyxLQUFLO0FBQUEsRUFDdkMsT0FBTyxNQUFJO0FBQUEsRUFDWCxPQUFPLENBQUM7QUFBQSxFQUNSLFlBQVk7QUFDZDsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -2,6 +2,7 @@ export * as App from './App.ts';
 export * as AttachmentPath from './AttachmentPath.ts';
 export * as Backlink from './Backlink.ts';
 export * as Callout from './Callout.ts';
+export * as ChainedPromise from './ChainedPromise.ts';
 export * as Dataview from './Dataview.ts';
 export * as DataviewLink from './DataviewLink.ts';
 export * as FrontMatter from './FrontMatter.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "3.21.0",
+  "version": "3.22.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",