obsidian-dev-utils 84.6.1 → 85.1.0

package/dist/lib/esm/obsidian/loop.d.mts

@@ -6,6 +6,21 @@
  */
 import type { Promisable } from 'type-fest';
 import type { PluginNoticeComponent } from './components/plugin-notice-component.mjs';
+/**
+ * Parameters for the {@link LoopParams.buildNoticeMessage} callback.
+ *
+ * @typeParam T - The type of the items to loop over.
+ */
+export interface LoopBuildNoticeMessageParams<T> {
+    /**
+     * The current item.
+     */
+    readonly item: T;
+    /**
+     * A string representing the current iteration.
+     */
+    readonly iterationStr: string;
+}
 /**
  * Options for {@link loop}.
  *
@@ -19,11 +34,10 @@ export interface LoopParams<T> {
     /**
      * Build a notice message for each item.
      *
-     * @param item - The current item.
-     * @param iterationStr - A string representing the current iteration.
+     * @param params - The parameters for building the notice message.
      * @returns A string to display in the notice.
      */
-    buildNoticeMessage(item: T, iterationStr: string): string;
+    buildNoticeMessage(params: LoopBuildNoticeMessageParams<T>): string;
     /**
      * Items to loop over.
      */

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

@@ -79,7 +79,7 @@ async function loop(params) {
     }
     iterationCount++;
     const iterationStr = `# ${String(iterationCount)} / ${String(items.length)}`;
-    const message = fullOptions.buildNoticeMessage(item, iterationStr);
+    const message = fullOptions.buildNoticeMessage({ item, iterationStr });
     if (!fullOptions.shouldShowProgressBar) {
       notice?.setMessage(message);
     }
@@ -136,4 +136,4 @@ async function loop(params) {
 export {
   loop
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/loop.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for looping in Obsidian.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { Notice } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport { abortSignalNever } from '../abort-controller.ts';\nimport {\n  invokeAsyncSafely,\n  requestAnimationFrameAsync\n} from '../async.ts';\nimport { getLibDebugger } from '../debug.ts';\nimport {\n  ASYNC_WRAPPER_ERROR_MESSAGE,\n  CustomStackTraceError,\n  emitAsyncErrorEvent,\n  getStackTrace\n} from '../error.ts';\nimport { noop } from '../function.ts';\nimport { addPluginCssClasses } from './plugin/plugin-context.ts';\n\n/**\n * Options for {@link loop}.\n *\n * @typeParam T - The type of the items to loop over.\n */\nexport interface LoopParams<T> {\n  /**\n   * An optional abort signal to cancel the loop.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * Build a notice message for each item.\n   *\n   * @param item - The current item.\n   * @param iterationStr - A string representing the current iteration.\n   * @returns A string to display in the notice.\n   */\n  buildNoticeMessage(item: T, iterationStr: string): string;\n\n  /**\n   * Items to loop over.\n   */\n  readonly items: T[];\n\n  /**\n   * A timeout for the notice before it is shown.\n   *\n   * @default `500`\n   */\n  readonly noticeBeforeShownTimeoutInMilliseconds?: number;\n\n  /**\n   * A minimum timeout for the notice.\n   *\n   * @default `2000`\n   */\n  readonly noticeMinTimeoutInMilliseconds?: number;\n\n  /**\n   * A component to show notices.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * Process each item.\n   *\n   * @param item - The current item.\n   */\n  processItem(item: T): Promisable<void>;\n\n  /**\n   * A title of the progress bar.\n   *\n   * @default `''`\n   */\n  readonly progressBarTitle?: string;\n\n  /**\n   * Whether to continue the loop on error.\n   *\n   * @default `true`\n   */\n  readonly shouldContinueOnError?: boolean;\n\n  /**\n   * Whether to show a notice.\n   *\n   * @default `true`\n   */\n  readonly shouldShowNotice?: boolean;\n\n  /**\n   * Whether to show a progress bar.\n   *\n   * @default `true`\n   */\n  readonly shouldShowProgressBar?: boolean;\n\n  /**\n   * A threshold for the UI update.\n   *\n   * @default `100`\n   */\n  readonly uiUpdateThresholdInMilliseconds?: number;\n}\n\n/**\n * Loops over a list of items and processes each item.\n *\n * @typeParam T - The type of the items to loop over.\n * @param params - The parameters for the loop.\n */\nexport async function loop<T>(params: LoopParams<T>): Promise<void> {\n  const DEFAULT_OPTIONS = {\n    abortSignal: abortSignalNever(),\n    /* v8 ignore start -- buildNoticeMessage is required in LoopParams and always overridden by the spread. */\n    buildNoticeMessage(): string {\n      throw new Error('buildNoticeMessage is required');\n    },\n    /* v8 ignore stop */\n    items: [],\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    noticeBeforeShownTimeoutInMilliseconds: 500,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    noticeMinTimeoutInMilliseconds: 2000,\n    processItem: noop,\n    progressBarTitle: '',\n    shouldContinueOnError: true,\n    shouldShowNotice: true,\n    shouldShowProgressBar: true,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    uiUpdateThresholdInMilliseconds: 100\n  };\n\n  const fullOptions: Required<LoopParams<T>> = {\n    ...DEFAULT_OPTIONS,\n    ...params\n  };\n\n  const stackTrace = getStackTrace(1);\n\n  const items = fullOptions.items;\n  let iterationCount = 0;\n  let notice = null as Notice | null;\n  let isDone = false;\n  invokeAsyncSafely(() => showNotice());\n\n  const noticeMinTimeoutPromise = sleep(fullOptions.noticeMinTimeoutInMilliseconds);\n  const progressBarEl = createEl('progress');\n  addPluginCssClasses(progressBarEl, 'loop');\n  progressBarEl.max = items.length;\n\n  let lastUIUpdateTimestamp = performance.now();\n\n  for (const item of items) {\n    if (fullOptions.abortSignal.aborted) {\n      notice?.hide();\n      return;\n    }\n    iterationCount++;\n    const iterationStr = `# ${String(iterationCount)} / ${String(items.length)}`;\n    const message = fullOptions.buildNoticeMessage(item, iterationStr);\n    if (!fullOptions.shouldShowProgressBar) {\n      notice?.setMessage(message);\n    }\n    getLibDebugger('Loop')(message);\n\n    try {\n      if (performance.now() - lastUIUpdateTimestamp > fullOptions.uiUpdateThresholdInMilliseconds) {\n        await requestAnimationFrameAsync();\n        lastUIUpdateTimestamp = performance.now();\n      }\n      await fullOptions.processItem(item);\n    } catch (error) {\n      console.error('Error processing item', item);\n      if (!fullOptions.shouldContinueOnError) {\n        notice?.hide();\n        throw new CustomStackTraceError({\n          cause: error,\n          message: 'loop failed',\n          stackTrace\n        });\n      }\n\n      emitAsyncErrorEvent(\n        new CustomStackTraceError({\n          cause: error,\n          message: ASYNC_WRAPPER_ERROR_MESSAGE,\n          stackTrace\n        })\n      );\n    }\n    progressBarEl.value++;\n  }\n  if (notice) {\n    await noticeMinTimeoutPromise;\n  }\n  notice?.hide();\n  isDone = true;\n\n  async function showNotice(): Promise<void> {\n    if (!fullOptions.shouldShowNotice) {\n      return;\n    }\n    await sleep(fullOptions.noticeBeforeShownTimeoutInMilliseconds);\n    if (isDone) {\n      return;\n    }\n    notice = params.pluginNoticeComponent.showNotice('', {});\n    if (!fullOptions.shouldShowProgressBar) {\n      return;\n    }\n    const fragment = createFragment();\n    fragment.createDiv({ text: fullOptions.progressBarTitle });\n    fragment.appendChild(progressBarEl);\n    notice.setMessage(fragment);\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,cAAc;AAIvB,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,sBAAsB;AAC/B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AACrB,SAAS,2BAA2B;AA+FpC,eAAsB,KAAQ,QAAsC;AAClE,QAAM,kBAAkB;AAAA,IACtB,aAAa,iBAAiB;AAAA;AAAA,IAE9B,qBAA6B;AAC3B,YAAM,IAAI,MAAM,gCAAgC;AAAA,IAClD;AAAA;AAAA,IAEA,OAAO,CAAC;AAAA;AAAA,IAER,wCAAwC;AAAA;AAAA,IAExC,gCAAgC;AAAA,IAChC,aAAa;AAAA,IACb,kBAAkB;AAAA,IAClB,uBAAuB;AAAA,IACvB,kBAAkB;AAAA,IAClB,uBAAuB;AAAA;AAAA,IAEvB,iCAAiC;AAAA,EACnC;AAEA,QAAM,cAAuC;AAAA,IAC3C,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AAEA,QAAM,aAAa,cAAc,CAAC;AAElC,QAAM,QAAQ,YAAY;AAC1B,MAAI,iBAAiB;AACrB,MAAI,SAAS;AACb,MAAI,SAAS;AACb,oBAAkB,MAAM,WAAW,CAAC;AAEpC,QAAM,0BAA0B,MAAM,YAAY,8BAA8B;AAChF,QAAM,gBAAgB,SAAS,UAAU;AACzC,sBAAoB,eAAe,MAAM;AACzC,gBAAc,MAAM,MAAM;AAE1B,MAAI,wBAAwB,YAAY,IAAI;AAE5C,aAAW,QAAQ,OAAO;AACxB,QAAI,YAAY,YAAY,SAAS;AACnC,cAAQ,KAAK;AACb;AAAA,IACF;AACA;AACA,UAAM,eAAe,KAAK,OAAO,cAAc,CAAC,MAAM,OAAO,MAAM,MAAM,CAAC;AAC1E,UAAM,UAAU,YAAY,mBAAmB,MAAM,YAAY;AACjE,QAAI,CAAC,YAAY,uBAAuB;AACtC,cAAQ,WAAW,OAAO;AAAA,IAC5B;AACA,mBAAe,MAAM,EAAE,OAAO;AAE9B,QAAI;AACF,UAAI,YAAY,IAAI,IAAI,wBAAwB,YAAY,iCAAiC;AAC3F,cAAM,2BAA2B;AACjC,gCAAwB,YAAY,IAAI;AAAA,MAC1C;AACA,YAAM,YAAY,YAAY,IAAI;AAAA,IACpC,SAAS,OAAO;AACd,cAAQ,MAAM,yBAAyB,IAAI;AAC3C,UAAI,CAAC,YAAY,uBAAuB;AACtC,gBAAQ,KAAK;AACb,cAAM,IAAI,sBAAsB;AAAA,UAC9B,OAAO;AAAA,UACP,SAAS;AAAA,UACT;AAAA,QACF,CAAC;AAAA,MACH;AAEA;AAAA,QACE,IAAI,sBAAsB;AAAA,UACxB,OAAO;AAAA,UACP,SAAS;AAAA,UACT;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AACA,kBAAc;AAAA,EAChB;AACA,MAAI,QAAQ;AACV,UAAM;AAAA,EACR;AACA,UAAQ,KAAK;AACb,WAAS;AAET,iBAAe,aAA4B;AACzC,QAAI,CAAC,YAAY,kBAAkB;AACjC;AAAA,IACF;AACA,UAAM,MAAM,YAAY,sCAAsC;AAC9D,QAAI,QAAQ;AACV;AAAA,IACF;AACA,aAAS,OAAO,sBAAsB,WAAW,IAAI,CAAC,CAAC;AACvD,QAAI,CAAC,YAAY,uBAAuB;AACtC;AAAA,IACF;AACA,UAAM,WAAW,eAAe;AAChC,aAAS,UAAU,EAAE,MAAM,YAAY,iBAAiB,CAAC;AACzD,aAAS,YAAY,aAAa;AAClC,WAAO,WAAW,QAAQ;AAAA,EAC5B;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/loop.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for looping in Obsidian.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { Notice } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport { abortSignalNever } from '../abort-controller.ts';\nimport {\n  invokeAsyncSafely,\n  requestAnimationFrameAsync\n} from '../async.ts';\nimport { getLibDebugger } from '../debug.ts';\nimport {\n  ASYNC_WRAPPER_ERROR_MESSAGE,\n  CustomStackTraceError,\n  emitAsyncErrorEvent,\n  getStackTrace\n} from '../error.ts';\nimport { noop } from '../function.ts';\nimport { addPluginCssClasses } from './plugin/plugin-context.ts';\n\n/**\n * Parameters for the {@link LoopParams.buildNoticeMessage} callback.\n *\n * @typeParam T - The type of the items to loop over.\n */\nexport interface LoopBuildNoticeMessageParams<T> {\n  /**\n   * The current item.\n   */\n  readonly item: T;\n\n  /**\n   * A string representing the current iteration.\n   */\n  readonly iterationStr: string;\n}\n\n/**\n * Options for {@link loop}.\n *\n * @typeParam T - The type of the items to loop over.\n */\nexport interface LoopParams<T> {\n  /**\n   * An optional abort signal to cancel the loop.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * Build a notice message for each item.\n   *\n   * @param params - The parameters for building the notice message.\n   * @returns A string to display in the notice.\n   */\n  buildNoticeMessage(params: LoopBuildNoticeMessageParams<T>): string;\n\n  /**\n   * Items to loop over.\n   */\n  readonly items: T[];\n\n  /**\n   * A timeout for the notice before it is shown.\n   *\n   * @default `500`\n   */\n  readonly noticeBeforeShownTimeoutInMilliseconds?: number;\n\n  /**\n   * A minimum timeout for the notice.\n   *\n   * @default `2000`\n   */\n  readonly noticeMinTimeoutInMilliseconds?: number;\n\n  /**\n   * A component to show notices.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * Process each item.\n   *\n   * @param item - The current item.\n   */\n  processItem(item: T): Promisable<void>;\n\n  /**\n   * A title of the progress bar.\n   *\n   * @default `''`\n   */\n  readonly progressBarTitle?: string;\n\n  /**\n   * Whether to continue the loop on error.\n   *\n   * @default `true`\n   */\n  readonly shouldContinueOnError?: boolean;\n\n  /**\n   * Whether to show a notice.\n   *\n   * @default `true`\n   */\n  readonly shouldShowNotice?: boolean;\n\n  /**\n   * Whether to show a progress bar.\n   *\n   * @default `true`\n   */\n  readonly shouldShowProgressBar?: boolean;\n\n  /**\n   * A threshold for the UI update.\n   *\n   * @default `100`\n   */\n  readonly uiUpdateThresholdInMilliseconds?: number;\n}\n\n/**\n * Loops over a list of items and processes each item.\n *\n * @typeParam T - The type of the items to loop over.\n * @param params - The parameters for the loop.\n */\nexport async function loop<T>(params: LoopParams<T>): Promise<void> {\n  const DEFAULT_OPTIONS = {\n    abortSignal: abortSignalNever(),\n    /* v8 ignore start -- buildNoticeMessage is required in LoopParams and always overridden by the spread. */\n    buildNoticeMessage(): string {\n      throw new Error('buildNoticeMessage is required');\n    },\n    /* v8 ignore stop */\n    items: [],\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    noticeBeforeShownTimeoutInMilliseconds: 500,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    noticeMinTimeoutInMilliseconds: 2000,\n    processItem: noop,\n    progressBarTitle: '',\n    shouldContinueOnError: true,\n    shouldShowNotice: true,\n    shouldShowProgressBar: true,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    uiUpdateThresholdInMilliseconds: 100\n  };\n\n  const fullOptions: Required<LoopParams<T>> = {\n    ...DEFAULT_OPTIONS,\n    ...params\n  };\n\n  const stackTrace = getStackTrace(1);\n\n  const items = fullOptions.items;\n  let iterationCount = 0;\n  let notice = null as Notice | null;\n  let isDone = false;\n  invokeAsyncSafely(() => showNotice());\n\n  const noticeMinTimeoutPromise = sleep(fullOptions.noticeMinTimeoutInMilliseconds);\n  const progressBarEl = createEl('progress');\n  addPluginCssClasses(progressBarEl, 'loop');\n  progressBarEl.max = items.length;\n\n  let lastUIUpdateTimestamp = performance.now();\n\n  for (const item of items) {\n    if (fullOptions.abortSignal.aborted) {\n      notice?.hide();\n      return;\n    }\n    iterationCount++;\n    const iterationStr = `# ${String(iterationCount)} / ${String(items.length)}`;\n    const message = fullOptions.buildNoticeMessage({ item, iterationStr });\n    if (!fullOptions.shouldShowProgressBar) {\n      notice?.setMessage(message);\n    }\n    getLibDebugger('Loop')(message);\n\n    try {\n      if (performance.now() - lastUIUpdateTimestamp > fullOptions.uiUpdateThresholdInMilliseconds) {\n        await requestAnimationFrameAsync();\n        lastUIUpdateTimestamp = performance.now();\n      }\n      await fullOptions.processItem(item);\n    } catch (error) {\n      console.error('Error processing item', item);\n      if (!fullOptions.shouldContinueOnError) {\n        notice?.hide();\n        throw new CustomStackTraceError({\n          cause: error,\n          message: 'loop failed',\n          stackTrace\n        });\n      }\n\n      emitAsyncErrorEvent(\n        new CustomStackTraceError({\n          cause: error,\n          message: ASYNC_WRAPPER_ERROR_MESSAGE,\n          stackTrace\n        })\n      );\n    }\n    progressBarEl.value++;\n  }\n  if (notice) {\n    await noticeMinTimeoutPromise;\n  }\n  notice?.hide();\n  isDone = true;\n\n  async function showNotice(): Promise<void> {\n    if (!fullOptions.shouldShowNotice) {\n      return;\n    }\n    await sleep(fullOptions.noticeBeforeShownTimeoutInMilliseconds);\n    if (isDone) {\n      return;\n    }\n    notice = params.pluginNoticeComponent.showNotice('', {});\n    if (!fullOptions.shouldShowProgressBar) {\n      return;\n    }\n    const fragment = createFragment();\n    fragment.createDiv({ text: fullOptions.progressBarTitle });\n    fragment.appendChild(progressBarEl);\n    notice.setMessage(fragment);\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,cAAc;AAIvB,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,sBAAsB;AAC/B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AACrB,SAAS,2BAA2B;AA+GpC,eAAsB,KAAQ,QAAsC;AAClE,QAAM,kBAAkB;AAAA,IACtB,aAAa,iBAAiB;AAAA;AAAA,IAE9B,qBAA6B;AAC3B,YAAM,IAAI,MAAM,gCAAgC;AAAA,IAClD;AAAA;AAAA,IAEA,OAAO,CAAC;AAAA;AAAA,IAER,wCAAwC;AAAA;AAAA,IAExC,gCAAgC;AAAA,IAChC,aAAa;AAAA,IACb,kBAAkB;AAAA,IAClB,uBAAuB;AAAA,IACvB,kBAAkB;AAAA,IAClB,uBAAuB;AAAA;AAAA,IAEvB,iCAAiC;AAAA,EACnC;AAEA,QAAM,cAAuC;AAAA,IAC3C,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AAEA,QAAM,aAAa,cAAc,CAAC;AAElC,QAAM,QAAQ,YAAY;AAC1B,MAAI,iBAAiB;AACrB,MAAI,SAAS;AACb,MAAI,SAAS;AACb,oBAAkB,MAAM,WAAW,CAAC;AAEpC,QAAM,0BAA0B,MAAM,YAAY,8BAA8B;AAChF,QAAM,gBAAgB,SAAS,UAAU;AACzC,sBAAoB,eAAe,MAAM;AACzC,gBAAc,MAAM,MAAM;AAE1B,MAAI,wBAAwB,YAAY,IAAI;AAE5C,aAAW,QAAQ,OAAO;AACxB,QAAI,YAAY,YAAY,SAAS;AACnC,cAAQ,KAAK;AACb;AAAA,IACF;AACA;AACA,UAAM,eAAe,KAAK,OAAO,cAAc,CAAC,MAAM,OAAO,MAAM,MAAM,CAAC;AAC1E,UAAM,UAAU,YAAY,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACrE,QAAI,CAAC,YAAY,uBAAuB;AACtC,cAAQ,WAAW,OAAO;AAAA,IAC5B;AACA,mBAAe,MAAM,EAAE,OAAO;AAE9B,QAAI;AACF,UAAI,YAAY,IAAI,IAAI,wBAAwB,YAAY,iCAAiC;AAC3F,cAAM,2BAA2B;AACjC,gCAAwB,YAAY,IAAI;AAAA,MAC1C;AACA,YAAM,YAAY,YAAY,IAAI;AAAA,IACpC,SAAS,OAAO;AACd,cAAQ,MAAM,yBAAyB,IAAI;AAC3C,UAAI,CAAC,YAAY,uBAAuB;AACtC,gBAAQ,KAAK;AACb,cAAM,IAAI,sBAAsB;AAAA,UAC9B,OAAO;AAAA,UACP,SAAS;AAAA,UACT;AAAA,QACF,CAAC;AAAA,MACH;AAEA;AAAA,QACE,IAAI,sBAAsB;AAAA,UACxB,OAAO;AAAA,UACP,SAAS;AAAA,UACT;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AACA,kBAAc;AAAA,EAChB;AACA,MAAI,QAAQ;AACV,UAAM;AAAA,EACR;AACA,UAAQ,KAAK;AACb,WAAS;AAET,iBAAe,aAA4B;AACzC,QAAI,CAAC,YAAY,kBAAkB;AACjC;AAAA,IACF;AACA,UAAM,MAAM,YAAY,sCAAsC;AAC9D,QAAI,QAAQ;AACV;AAAA,IACF;AACA,aAAS,OAAO,sBAAsB,WAAW,IAAI,CAAC,CAAC;AACvD,QAAI,CAAC,YAAY,uBAAuB;AACtC;AAAA,IACF;AACA,UAAM,WAAW,eAAe;AAChC,aAAS,UAAU,EAAE,MAAM,YAAY,iBAAiB,CAAC;AACzD,aAAS,YAAY,aAAa;AAClC,WAAO,WAAW,QAAQ;AAAA,EAC5B;AACF;",
  "names": []
}


package/dist/lib/esm/obsidian/markdown-code-block-processor-registrar.d.mts

@@ -41,7 +41,10 @@ type PluginMarkdownCodeBlockProcessorRegistrarRegisterMarkdownCodeBlockProcessor
  * A registrar for markdown code block processors.
  */
 export declare class PluginMarkdownCodeBlockProcessorRegistrar implements MarkdownCodeBlockProcessorRegistrar {
-    private readonly plugin;
+    /**
+     * The Obsidian plugin instance the code block processors are registered with.
+     */
+    protected readonly plugin: Plugin;
     /**
      * Creates a new markdown code block processor registrar.
      *

package/dist/lib/esm/obsidian/markdown-code-block-processor-registrar.mjs

@@ -23,6 +23,9 @@ if you want to view the source, please visit the github repository of this plugi
 
 import { normalizePromisable } from "../async.mjs";
 class PluginMarkdownCodeBlockProcessorRegistrar {
+  /**
+   * The Obsidian plugin instance the code block processors are registered with.
+   */
   plugin;
   /**
    * Creates a new markdown code block processor registrar.
@@ -45,4 +48,4 @@ class PluginMarkdownCodeBlockProcessorRegistrar {
 export {
   PluginMarkdownCodeBlockProcessorRegistrar
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/markdown-post-processor-registrar.d.mts

@@ -42,7 +42,7 @@ type PluginMarkdownPostProcessorRegistrarRegisterMarkdownPostProcessorParams = M
  * Markdown post processor registrar in an Obsidian plugin.
  */
 export declare class PluginMarkdownPostProcessorRegistrar implements MarkdownPostProcessorRegistrar {
-    private readonly plugin;
+    protected readonly plugin: Plugin;
     /**
      * Creates a new instance of the {@link PluginMarkdownPostProcessorRegistrar} class.
      *

package/dist/lib/esm/obsidian/markdown-post-processor-registrar.mjs

@@ -45,4 +45,4 @@ class PluginMarkdownPostProcessorRegistrar {
 export {
   PluginMarkdownPostProcessorRegistrar
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/metadata-cache.d.mts

@@ -9,6 +9,63 @@ import type { App, CachedMetadata, Reference, TAbstractFile } from 'obsidian';
 import type { RetryOptions } from '../async.mjs';
 import type { PathOrFile } from './file-system.mjs';
 import type { CombinedFrontmatter } from './frontmatter.mjs';
+import type { ParseLinkFrontmatterReference, ParseLinkFrontmatterReferenceWithOffsets, ParseLinkReference } from './parse-link.mjs';
+/**
+ * A parsing feature that was applied when computing a {@link CachedMetadataEx}.
+ */
+export declare enum CachedMetadataExFeature {
+    /**
+     * The external links parsed from the note content body.
+     */
+    ExternalLinks = "ExternalLinks",
+    /**
+     * The external links parsed from single-link note frontmatter values.
+     */
+    FrontmatterExternalLinks = "FrontmatterExternalLinks",
+    /**
+     * The external links parsed from multi-link note frontmatter values.
+     */
+    MultiValueFrontmatterExternalLinks = "MultiValueFrontmatterExternalLinks",
+    /**
+     * The internal links parsed from multi-link note frontmatter values, which Obsidian does not natively cache.
+     */
+    MultiValueFrontmatterLinks = "MultiValueFrontmatterLinks",
+    /**
+     * Obsidian's native metadata parsing (internal links, embeds, frontmatter links).
+     */
+    Native = "Native"
+}
+/**
+ * An extended {@link CachedMetadata} that records which parsing {@link CachedMetadataExFeature}s were
+ * applied (via {@link CachedMetadataEx.features}) and carries the resulting external links. Each links
+ * array is populated only when its corresponding feature is present in {@link CachedMetadataEx.features}.
+ */
+export interface CachedMetadataEx extends CachedMetadata {
+    /**
+     * The external links parsed from the note content body. Populated only when
+     * {@link CachedMetadataExFeature.ExternalLinks} is applied.
+     */
+    externalLinks?: ParseLinkReference[];
+    /**
+     * The parsing features that were applied when computing this cache.
+     */
+    readonly features: CachedMetadataExFeature[];
+    /**
+     * The external links parsed from single-link (single-value) note frontmatter values. Populated only
+     * when {@link CachedMetadataExFeature.FrontmatterExternalLinks} is applied.
+     */
+    frontmatterExternalLinks?: ParseLinkFrontmatterReference[];
+    /**
+     * The external links parsed from multi-link (multi-value) note frontmatter values. Populated only when
+     * {@link CachedMetadataExFeature.MultiValueFrontmatterExternalLinks} is applied.
+     */
+    multiValueFrontmatterExternalLinks?: ParseLinkFrontmatterReferenceWithOffsets[];
+    /**
+     * The internal links parsed from multi-link (multi-value) note frontmatter values. Populated only when
+     * {@link CachedMetadataExFeature.MultiValueFrontmatterLinks} is applied.
+     */
+    multiValueFrontmatterLinks?: ParseLinkFrontmatterReferenceWithOffsets[];
+}
 /**
  * Options for {@link getBacklinksForFileSafe}.
  */
@@ -45,6 +102,101 @@ export interface GetBacklinksForFileSafeWrapper {
      */
     safe(pathOrFile: PathOrFile): Promise<CustomArrayDict<Reference>>;
 }
+/**
+ * Options for {@link getCacheSafe}.
+ */
+export type GetCacheSafeOptions = ParseCacheOptions;
+/**
+ * Params for {@link getLinks}.
+ */
+export interface GetLinksParams {
+    /**
+     * The cached metadata to retrieve the links from.
+     */
+    readonly cache: CachedMetadata;
+    /**
+     * Whether to include the embeds (`cache.embeds`).
+     *
+     * @default `true`
+     */
+    readonly shouldIncludeEmbeds?: boolean;
+    /**
+     * Whether to include the external links parsed from the note body. Requires the cache to be a
+     * {@link CachedMetadataEx}.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeExternalLinks?: boolean;
+    /**
+     * Whether to include the external links parsed from single-link (single-value) note frontmatter
+     * values. Requires the cache to be a {@link CachedMetadataEx}.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeFrontmatterExternalLinks?: boolean;
+    /**
+     * Whether to include the frontmatter links (`cache.frontmatterLinks`).
+     *
+     * @default `true`
+     */
+    readonly shouldIncludeFrontmatterLinks?: boolean;
+    /**
+     * Whether to include the external links parsed from multi-link (multi-value) note frontmatter values,
+     * i.e. the offset-carrying frontmatter external links (narrowed via
+     * {@link isFrontmatterLinkCacheWithOffsets}). Requires the cache to be a {@link CachedMetadataEx}.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeMultiValueFrontmatterExternalLinks?: boolean;
+    /**
+     * Whether to include the internal links parsed from multi-link (multi-value) note frontmatter values.
+     * Requires the cache to be a {@link CachedMetadataEx}.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeMultiValueFrontmatterLinks?: boolean;
+    /**
+     * Whether to include the reference links (`cache.links`).
+     *
+     * @default `true`
+     */
+    readonly shouldIncludeReferences?: boolean;
+}
+/**
+ * Options for the parsing performed by {@link getCacheSafe} and {@link parseMetadata} beyond Obsidian's
+ * native metadata parsing. Each option is opt-in; enabling it adds the corresponding
+ * {@link CachedMetadataExFeature} and populates the matching links array.
+ */
+export interface ParseCacheOptions {
+    /**
+     * Whether to parse the external links from the note content body.
+     *
+     * @default `false`
+     */
+    readonly shouldParseExternalLinks?: boolean;
+    /**
+     * Whether to parse the external links from single-link (single-value) note frontmatter values.
+     *
+     * @default `false`
+     */
+    readonly shouldParseFrontmatterExternalLinks?: boolean;
+    /**
+     * Whether to parse the external links from multi-link (multi-value) note frontmatter values.
+     *
+     * @default `false`
+     */
+    readonly shouldParseMultiValueFrontmatterExternalLinks?: boolean;
+    /**
+     * Whether to parse the internal links from multi-link (multi-value) note frontmatter values.
+     *
+     * @default `false`
+     */
+    readonly shouldParseMultiValueFrontmatterLinks?: boolean;
+}
+/**
+ * Options for {@link parseMetadata}.
+ */
+export type ParseMetadataOptions = ParseCacheOptions;
 /**
  * Parameters for {@link registerFileCacheForNonExistingFile}.
  */
@@ -69,13 +221,6 @@ export interface RegisterFileCacheForNonExistingFileParams {
  * @returns A {@link Promise} that resolves when the metadata cache is ready.
  */
 export declare function ensureMetadataCacheReady(app: App): Promise<void>;
-/**
- * Retrieves all links from the provided cache.
- *
- * @param cache - The cached metadata.
- * @returns An array of reference caches representing the links.
- */
-export declare function getAllLinks(cache: CachedMetadata): Reference[];
 /**
  * Retrieves the backlinks for a file or path.
  * NOTE: The file may be non-existent.
@@ -97,9 +242,10 @@ export declare function getBacklinksForFileSafe(params: GetBacklinksForFileSafeP
  *
  * @param app - The Obsidian app instance.
  * @param fileOrPath - The file or path to retrieve the metadata for.
+ * @param options - The parse options controlling which additional links to parse.
  * @returns The cached metadata for the file, or `null` if it doesn't exist.
  */
-export declare function getCacheSafe(app: App, fileOrPath: PathOrFile): Promise<CachedMetadata | null>;
+export declare function getCacheSafe(app: App, fileOrPath: PathOrFile, options?: GetCacheSafeOptions): Promise<CachedMetadataEx | null>;
 /**
  * Retrieves the front matter from the metadata cache safely.
  *
@@ -109,14 +255,30 @@ export declare function getCacheSafe(app: App, fileOrPath: PathOrFile): Promise<
  * @returns The combined front matter.
  */
 export declare function getFrontmatterSafe<CustomFrontmatter = unknown>(app: App, pathOrFile: PathOrFile): Promise<CombinedFrontmatter<CustomFrontmatter>>;
+/**
+ * Retrieves the selected links from the provided cache.
+ *
+ * @param params - The parameters for retrieving the links.
+ * @returns An array of references representing the selected links.
+ */
+export declare function getLinks(params: GetLinksParams): Reference[];
+/**
+ * Determines whether a cache is a {@link CachedMetadataEx} (i.e. it was computed with external-link
+ * parsing enabled).
+ *
+ * @param cache - The cache to check.
+ * @returns `true` if the cache is a {@link CachedMetadataEx}, otherwise `false`.
+ */
+export declare function isCachedMetadataEx(cache: CachedMetadata): cache is CachedMetadataEx;
 /**
  * Parses the metadata for a given string.
  *
  * @param app - The Obsidian app instance.
  * @param str - The string to parse the metadata for.
+ * @param options - The parse options controlling which additional links to parse.
  * @returns The parsed metadata.
  */
-export declare function parseMetadata(app: App, str: string): Promise<CachedMetadata>;
+export declare function parseMetadata(app: App, str: string, options?: ParseMetadataOptions): Promise<CachedMetadataEx>;
 /**
  * Registers the file cache for a non-existing file.
  *