obsidian-dev-utils 50.0.0 → 51.0.1

package/dist/lib/esm/obsidian/async-with-notice.d.mts

@@ -0,0 +1,82 @@
+/**
+ * @packageDocumentation
+ *
+ * Provides a utility to execute an asynchronous function with a notice.
+ */
+import type { Promisable } from 'type-fest';
+import type { RetryOptions } from '../async.mjs';
+/**
+ * Options for {@link retryWithTimeoutNotice}.
+ */
+export interface RetryWithTimeoutNoticeParams {
+    /**
+     * The operation function to execute.
+     *
+     * @param abortSignal - The abort signal to listen to.
+     * @returns The result of the function.
+     */
+    readonly operationFn: (this: void, abortSignal: AbortSignal) => Promisable<boolean>;
+    /**
+     * The name of the operation.
+     */
+    readonly operationName?: string;
+    /**
+     * The retry options.
+     */
+    readonly retryOptions?: RetryOptions;
+    /**
+     * Whether to show a timeout notice. Default is `true`.
+     */
+    readonly shouldShowTimeoutNotice?: boolean;
+    /**
+     * The stack trace of the source function.
+     */
+    readonly stackTrace?: string;
+}
+/**
+ * Options for {@link runWithTimeout}.
+ */
+export interface RunWithTimeoutNoticeParams<Result> {
+    /**
+     * The context of the function.
+     */
+    readonly context?: unknown;
+    /**
+     * The operation function to execute.
+     *
+     * @param abortSignal - The abort signal to listen to.
+     * @returns The result of the function.
+     */
+    readonly operationFn: (abortSignal: AbortSignal) => Promisable<Result>;
+    /**
+     * The name of the operation.
+     */
+    readonly operationName?: string;
+    /**
+     * Whether to show a timeout notice. Default is `true`.
+     */
+    readonly shouldShowTimeoutNotice?: boolean;
+    /**
+     * The stack trace of the source function.
+     */
+    readonly stackTrace?: string;
+    /**
+     * The maximum time to wait in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * Retries the provided function until it returns `true` or the timeout is reached and displays a notice if the function times out.
+ *
+ * @param params - The parameters for the function.
+ * @returns A {@link Promise} that resolves when the function returns `true` or rejects when the timeout is reached.
+ */
+export declare function retryWithTimeoutNotice(params: RetryWithTimeoutNoticeParams): Promise<void>;
+/**
+ * Executes a function with a timeout and displays a notice if the function times out.
+ *
+ * @typeParam R - The type of the result from the asynchronous function.
+ * @param params - The parameters for the function.
+ * @returns The result of the function.
+ */
+export declare function runWithTimeoutNotice<Result>(params: RunWithTimeoutNoticeParams<Result>): Promise<Result>;

package/dist/lib/esm/obsidian/async-with-notice.mjs

@@ -0,0 +1,96 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { Notice } from "obsidian";
+import {
+  retryWithTimeout,
+  runWithTimeout
+} from "../async.mjs";
+import { getDebugger } from "../debug.mjs";
+import { t } from "./i18n/i18n.mjs";
+async function retryWithTimeoutNotice(params) {
+  return retryWithTimeout({
+    ...params,
+    onTimeout: params.shouldShowTimeoutNotice ? onTimeoutNotice : onTimeoutWithoutNotice
+  });
+}
+async function runWithTimeoutNotice(params) {
+  return runWithTimeout({
+    ...params,
+    onTimeout: params.shouldShowTimeoutNotice ? onTimeoutNotice : onTimeoutWithoutNotice
+  });
+}
+function onTimeoutNotice(ctx) {
+  const startTime = Math.trunc(performance.now() - ctx.duration);
+  let runningTimeEl;
+  let intervalId;
+  const SECOND_IN_MILLISECONDS = 1e3;
+  const notice = new Notice(createFragment((f) => {
+    if (ctx.operationName) {
+      f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.operation));
+      f.appendText(": ");
+      f.appendText(ctx.operationName);
+      f.createEl("br");
+    }
+    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.timedOut, { duration: ctx.duration }));
+    f.createEl("br");
+    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.runningFor));
+    f.appendText(" ");
+    runningTimeEl = f.createSpan();
+    f.appendText(" ");
+    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.milliseconds));
+    f.createEl("br");
+    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.terminateOperation));
+    f.createEl("br");
+    const button = f.createEl("button", {
+      text: t(($) => $.obsidianDevUtils.buttons.cancel)
+    });
+    button.addEventListener("click", () => {
+      ctx.terminateOperation();
+      clearInterval(intervalId);
+      notice.hide();
+    });
+  }));
+  updateRunningTime();
+  intervalId = window.setInterval(updateRunningTime, SECOND_IN_MILLISECONDS);
+  ctx.onOperationCompleted(() => {
+    clearInterval(intervalId);
+    notice.hide();
+  });
+  function updateRunningTime() {
+    const runningTimeInMilliseconds = Math.max(ctx.duration, Math.round((performance.now() - startTime) / SECOND_IN_MILLISECONDS) * SECOND_IN_MILLISECONDS);
+    runningTimeEl.textContent = String(runningTimeInMilliseconds);
+  }
+}
+function onTimeoutWithoutNotice(ctx) {
+  const startTime = Math.trunc(performance.now() - ctx.duration);
+  ctx.onOperationCompleted(() => {
+    getDebugger("AsyncWithNotice:onTimeoutWithoutNotice")("Operation completed after timeout", {
+      operationName: ctx.operationName,
+      totalDuration: Math.trunc(performance.now() - startTime)
+    });
+  });
+}
+export {
+  retryWithTimeoutNotice,
+  runWithTimeoutNotice
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/async-with-notice.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Provides a utility to execute an asynchronous function with a notice.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { Notice } from 'obsidian';\n\nimport type {\n  RetryOptions,\n  TimeoutContext\n} from '../async.ts';\n\nimport {\n  retryWithTimeout,\n  runWithTimeout\n} from '../async.ts';\nimport { getDebugger } from '../debug.ts';\nimport { t } from './i18n/i18n.ts';\n\n/**\n * Options for {@link retryWithTimeoutNotice}.\n */\nexport interface RetryWithTimeoutNoticeParams {\n  /**\n   * The operation function to execute.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   * @returns The result of the function.\n   */\n  readonly operationFn: (this: void, abortSignal: AbortSignal) => Promisable<boolean>;\n\n  /**\n   * The name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * The retry options.\n   */\n  readonly retryOptions?: RetryOptions;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string;\n}\n\n/**\n * Options for {@link runWithTimeout}.\n */\nexport interface RunWithTimeoutNoticeParams<Result> {\n  /**\n   * The context of the function.\n   */\n  readonly context?: unknown;\n\n  /**\n   * The operation function to execute.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   * @returns The result of the function.\n   */\n  readonly operationFn: (abortSignal: AbortSignal) => Promisable<Result>;\n\n  /**\n   * The name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The maximum time to wait in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Retries the provided function until it returns `true` or the timeout is reached and displays a notice if the function times out.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves when the function returns `true` or rejects when the timeout is reached.\n */\nexport async function retryWithTimeoutNotice(params: RetryWithTimeoutNoticeParams): Promise<void> {\n  return retryWithTimeout({\n    ...params,\n    onTimeout: params.shouldShowTimeoutNotice ? onTimeoutNotice : onTimeoutWithoutNotice\n  });\n}\n\n/**\n * Executes a function with a timeout and displays a notice if the function times out.\n *\n * @typeParam R - The type of the result from the asynchronous function.\n * @param params - The parameters for the function.\n * @returns The result of the function.\n */\nexport async function runWithTimeoutNotice<Result>(params: RunWithTimeoutNoticeParams<Result>): Promise<Result> {\n  return runWithTimeout({\n    ...params,\n    onTimeout: params.shouldShowTimeoutNotice ? onTimeoutNotice : onTimeoutWithoutNotice\n  });\n}\n\nfunction onTimeoutNotice(ctx: TimeoutContext): void {\n  const startTime = Math.trunc(performance.now() - ctx.duration);\n  let runningTimeEl: HTMLSpanElement;\n  let intervalId: number;\n  const SECOND_IN_MILLISECONDS = 1000;\n\n  const notice = new Notice(createFragment((f) => {\n    if (ctx.operationName) {\n      f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.operation));\n      f.appendText(': ');\n      f.appendText(ctx.operationName);\n      f.createEl('br');\n    }\n    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.timedOut, { duration: ctx.duration }));\n    f.createEl('br');\n    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.runningFor));\n    f.appendText(' ');\n    runningTimeEl = f.createSpan();\n    f.appendText(' ');\n    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.milliseconds));\n    f.createEl('br');\n    f.appendText(t(($) => $.obsidianDevUtils.asyncWithNotice.terminateOperation));\n    f.createEl('br');\n    const button = f.createEl('button', {\n      text: t(($) => $.obsidianDevUtils.buttons.cancel)\n    });\n    button.addEventListener('click', () => {\n      ctx.terminateOperation();\n      clearInterval(intervalId);\n      notice.hide();\n    });\n  }));\n\n  updateRunningTime();\n  intervalId = window.setInterval(updateRunningTime, SECOND_IN_MILLISECONDS);\n\n  ctx.onOperationCompleted(() => {\n    clearInterval(intervalId);\n    notice.hide();\n  });\n\n  function updateRunningTime(): void {\n    const runningTimeInMilliseconds = Math.max(ctx.duration, Math.round((performance.now() - startTime) / SECOND_IN_MILLISECONDS) * SECOND_IN_MILLISECONDS);\n    runningTimeEl.textContent = String(runningTimeInMilliseconds);\n  }\n}\n\nfunction onTimeoutWithoutNotice(ctx: TimeoutContext): void {\n  const startTime = Math.trunc(performance.now() - ctx.duration);\n\n  ctx.onOperationCompleted(() => {\n    getDebugger('AsyncWithNotice:onTimeoutWithoutNotice')('Operation completed after timeout', {\n      operationName: ctx.operationName,\n      totalDuration: Math.trunc(performance.now() - startTime)\n    });\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,cAAc;AAOvB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,mBAAmB;AAC5B,SAAS,SAAS;AA+ElB,eAAsB,uBAAuB,QAAqD;AAChG,SAAO,iBAAiB;AAAA,IACtB,GAAG;AAAA,IACH,WAAW,OAAO,0BAA0B,kBAAkB;AAAA,EAChE,CAAC;AACH;AASA,eAAsB,qBAA6B,QAA6D;AAC9G,SAAO,eAAe;AAAA,IACpB,GAAG;AAAA,IACH,WAAW,OAAO,0BAA0B,kBAAkB;AAAA,EAChE,CAAC;AACH;AAEA,SAAS,gBAAgB,KAA2B;AAClD,QAAM,YAAY,KAAK,MAAM,YAAY,IAAI,IAAI,IAAI,QAAQ;AAC7D,MAAI;AACJ,MAAI;AACJ,QAAM,yBAAyB;AAE/B,QAAM,SAAS,IAAI,OAAO,eAAe,CAAC,MAAM;AAC9C,QAAI,IAAI,eAAe;AACrB,QAAE,WAAW,EAAE,CAAC,MAAM,EAAE,iBAAiB,gBAAgB,SAAS,CAAC;AACnE,QAAE,WAAW,IAAI;AACjB,QAAE,WAAW,IAAI,aAAa;AAC9B,QAAE,SAAS,IAAI;AAAA,IACjB;AACA,MAAE,WAAW,EAAE,CAAC,MAAM,EAAE,iBAAiB,gBAAgB,UAAU,EAAE,UAAU,IAAI,SAAS,CAAC,CAAC;AAC9F,MAAE,SAAS,IAAI;AACf,MAAE,WAAW,EAAE,CAAC,MAAM,EAAE,iBAAiB,gBAAgB,UAAU,CAAC;AACpE,MAAE,WAAW,GAAG;AAChB,oBAAgB,EAAE,WAAW;AAC7B,MAAE,WAAW,GAAG;AAChB,MAAE,WAAW,EAAE,CAAC,MAAM,EAAE,iBAAiB,gBAAgB,YAAY,CAAC;AACtE,MAAE,SAAS,IAAI;AACf,MAAE,WAAW,EAAE,CAAC,MAAM,EAAE,iBAAiB,gBAAgB,kBAAkB,CAAC;AAC5E,MAAE,SAAS,IAAI;AACf,UAAM,SAAS,EAAE,SAAS,UAAU;AAAA,MAClC,MAAM,EAAE,CAAC,MAAM,EAAE,iBAAiB,QAAQ,MAAM;AAAA,IAClD,CAAC;AACD,WAAO,iBAAiB,SAAS,MAAM;AACrC,UAAI,mBAAmB;AACvB,oBAAc,UAAU;AACxB,aAAO,KAAK;AAAA,IACd,CAAC;AAAA,EACH,CAAC,CAAC;AAEF,oBAAkB;AAClB,eAAa,OAAO,YAAY,mBAAmB,sBAAsB;AAEzE,MAAI,qBAAqB,MAAM;AAC7B,kBAAc,UAAU;AACxB,WAAO,KAAK;AAAA,EACd,CAAC;AAED,WAAS,oBAA0B;AACjC,UAAM,4BAA4B,KAAK,IAAI,IAAI,UAAU,KAAK,OAAO,YAAY,IAAI,IAAI,aAAa,sBAAsB,IAAI,sBAAsB;AACtJ,kBAAc,cAAc,OAAO,yBAAyB;AAAA,EAC9D;AACF;AAEA,SAAS,uBAAuB,KAA2B;AACzD,QAAM,YAAY,KAAK,MAAM,YAAY,IAAI,IAAI,IAAI,QAAQ;AAE7D,MAAI,qBAAqB,MAAM;AAC7B,gBAAY,wCAAwC,EAAE,qCAAqC;AAAA,MACzF,eAAe,IAAI;AAAA,MACnB,eAAe,KAAK,MAAM,YAAY,IAAI,IAAI,SAAS;AAAA,IACzD,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/obsidian/attachment-path.d.mts

@@ -0,0 +1,181 @@
+/**
+ * @packageDocumentation
+ *
+ * Provides utility functions for working with attachment paths.
+ */
+import type { App, FileStats, Vault } from 'obsidian';
+import type { PathOrFile } from './file-system.mjs';
+/**
+ * A context for an attachment path.
+ */
+export declare enum AttachmentPathContext {
+    /**
+     * A context for a delete note.
+     */
+    DeleteNote = "DeleteNote",
+    /**
+     * A context for a rename note.
+     */
+    RenameNote = "RenameNote",
+    /**
+     * An unknown context.
+     */
+    Unknown = "Unknown"
+}
+/**
+ * Options for the get available path for attachments extended function.
+ */
+export interface GetAvailablePathForAttachmentsExtendedFnParams {
+    /**
+     * A base name of the attachment.
+     */
+    readonly attachmentFileBaseName: string;
+    /**
+     * A content of the attachment file.
+     */
+    readonly attachmentFileContent?: ArrayBuffer | undefined;
+    /**
+     * An extension of the attachment.
+     */
+    readonly attachmentFileExtension: string;
+    /**
+     * A stats of the attachment file.
+     */
+    readonly attachmentFileStat?: FileStats | undefined;
+    /**
+     * A context.
+     */
+    readonly context: AttachmentPathContext;
+    /**
+     * A path or file of the note.
+     */
+    readonly notePathOrFile: null | PathOrFile;
+    /**
+     * A path or file of the old attachment.
+     */
+    readonly oldAttachmentPathOrFile: PathOrFile;
+    /**
+     * A path or file of the old note.
+     */
+    readonly oldNotePathOrFile?: PathOrFile | undefined;
+    /**
+     * Should the duplicate check be skipped.
+     */
+    readonly shouldSkipDuplicateCheck?: boolean;
+    /**
+     * Should the generated attachment file name be skipped.
+     */
+    readonly shouldSkipGeneratedAttachmentFileName?: boolean;
+    /**
+     * Should missing attachment folder creation be skipped.
+     */
+    readonly shouldSkipMissingAttachmentFolderCreation: boolean | undefined;
+}
+/**
+ * {@link Vault.getAvailablePathForAttachments} extended wrapper.
+ */
+export interface GetAvailablePathForAttachmentsFnExtended extends GetAvailablePathForAttachmentsFn {
+    /**
+     * Get available path for attachments with additional params.
+     *
+     * @param params - Parameters for the get available path for attachments.
+     * @returns A {@link Promise} that resolves to the available path for attachments.
+     */
+    extended(params: GetAvailablePathForAttachmentsExtendedFnParams): Promise<string>;
+}
+type GetAvailablePathForAttachmentsFn = Vault['getAvailablePathForAttachments'];
+/**
+ * Dummy path.
+ */
+export declare const DUMMY_PATH = "__DUMMY__";
+/**
+ * Options for the getAttachmentFilePath function.
+ */
+export interface GetAttachmentFilePathParams {
+    /**
+     * An Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * A context.
+     */
+    readonly context: AttachmentPathContext;
+    /**
+     * A path of the note.
+     */
+    readonly notePathOrFile: PathOrFile;
+    /**
+     * A path of the attachment.
+     */
+    readonly oldAttachmentPathOrFile: PathOrFile;
+    /**
+     * A path of the old note.
+     */
+    readonly oldNotePathOrFile?: PathOrFile | undefined;
+    /**
+     * Should the duplicate check be skipped.
+     */
+    readonly shouldSkipDuplicateCheck: boolean;
+}
+/**
+ * Options for the getAvailablePathForAttachments function.
+ */
+export interface GetAvailablePathForAttachmentsParams {
+    /**
+     * An Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * A base name of the attachment.
+     */
+    readonly attachmentFileBaseName: string;
+    /**
+     * An extension of the attachment.
+     */
+    readonly attachmentFileExtension: string;
+    /**
+     * A file to attach to.
+     */
+    readonly notePathOrFile: null | PathOrFile;
+    /**
+     * Should the duplicate check be skipped.
+     */
+    readonly shouldSkipDuplicateCheck?: boolean;
+    /**
+     * Should missing attachment folder creation be skipped.
+     */
+    readonly shouldSkipMissingAttachmentFolderCreation?: boolean;
+}
+/**
+ * Retrieves the file path for an attachment within a note.
+ *
+ * @param params - Parameters for the get attachment file path function.
+ * @returns A {@link Promise} that resolves to the file path of the attachment.
+ */
+export declare function getAttachmentFilePath(params: GetAttachmentFilePathParams): Promise<string>;
+/**
+ * Retrieves the attachment folder path for a given note.
+ *
+ * @param app - The Obsidian application instance.
+ * @param notePathOrFile - The path of the note.
+ * @param context - The context.
+ * @returns A {@link Promise} that resolves to the attachment folder path.
+ */
+export declare function getAttachmentFolderPath(app: App, notePathOrFile: PathOrFile, context?: AttachmentPathContext): Promise<string>;
+/**
+ * Retrieves the available path for attachments.
+ *
+ * @param params - Parameters for the get available path for attachments function.
+ * @returns A {@link Promise} that resolves to the available path for attachments.
+ */
+export declare function getAvailablePathForAttachments(params: GetAvailablePathForAttachmentsParams): Promise<string>;
+/**
+ * Checks if a note has its own attachment folder.
+ *
+ * @param app - The Obsidian application instance.
+ * @param path - The path of the note.
+ * @param context - The context.
+ * @returns A {@link Promise} that resolves to a boolean indicating whether the note has its own attachment folder.
+ */
+export declare function hasOwnAttachmentFolder(app: App, path: string, context?: AttachmentPathContext): Promise<boolean>;
+export {};

package/dist/lib/esm/obsidian/attachment-path.mjs

@@ -0,0 +1,139 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { parentFolderPath } from "obsidian-typings/implementations";
+import {
+  basename,
+  dirname,
+  extname,
+  join,
+  makeFileName
+} from "../path.mjs";
+import {
+  normalize,
+  replaceAll,
+  trimStart
+} from "../string.mjs";
+import {
+  getFileOrNull,
+  getFolder,
+  getFolderOrNull,
+  getPath,
+  MARKDOWN_FILE_EXTENSION
+} from "./file-system.mjs";
+var AttachmentPathContext = /* @__PURE__ */ ((AttachmentPathContext2) => {
+  AttachmentPathContext2["DeleteNote"] = "DeleteNote";
+  AttachmentPathContext2["RenameNote"] = "RenameNote";
+  AttachmentPathContext2["Unknown"] = "Unknown";
+  return AttachmentPathContext2;
+})(AttachmentPathContext || {});
+const DUMMY_PATH = "__DUMMY__";
+async function getAttachmentFilePath(params) {
+  const {
+    app,
+    notePathOrFile,
+    oldAttachmentPathOrFile,
+    shouldSkipDuplicateCheck
+  } = params;
+  const attachmentPath = getPath(app, oldAttachmentPathOrFile);
+  const attachmentFileExtension = extname(attachmentPath);
+  const attachmentFileBaseName = basename(attachmentPath, attachmentFileExtension);
+  const attachmentFile = getFileOrNull(app, attachmentPath);
+  const extendedFn = app.vault.getAvailablePathForAttachments.extended;
+  if (extendedFn) {
+    return extendedFn({
+      attachmentFileBaseName,
+      attachmentFileContent: attachmentFile ? await app.vault.readBinary(attachmentFile) : void 0,
+      attachmentFileExtension: attachmentFileExtension.slice(1),
+      attachmentFileStat: attachmentFile?.stat,
+      context: params.context,
+      notePathOrFile,
+      oldAttachmentPathOrFile: params.oldAttachmentPathOrFile,
+      oldNotePathOrFile: params.oldNotePathOrFile,
+      shouldSkipDuplicateCheck,
+      shouldSkipMissingAttachmentFolderCreation: true
+    });
+  }
+  return await getAvailablePathForAttachments({
+    app,
+    attachmentFileBaseName,
+    attachmentFileExtension: attachmentFileExtension.slice(1),
+    notePathOrFile,
+    shouldSkipDuplicateCheck,
+    shouldSkipMissingAttachmentFolderCreation: true
+  });
+}
+async function getAttachmentFolderPath(app, notePathOrFile, context = "Unknown" /* Unknown */) {
+  return parentFolderPath(
+    await getAttachmentFilePath({
+      app,
+      context,
+      notePathOrFile,
+      oldAttachmentPathOrFile: DUMMY_PATH,
+      shouldSkipDuplicateCheck: true
+    })
+  );
+}
+async function getAvailablePathForAttachments(params) {
+  const {
+    app,
+    attachmentFileExtension,
+    notePathOrFile,
+    shouldSkipDuplicateCheck,
+    shouldSkipMissingAttachmentFolderCreation
+  } = params;
+  let attachmentFolderPath = app.vault.getConfig("attachmentFolderPath");
+  const isCurrentFolder = attachmentFolderPath === "." || attachmentFolderPath === "./";
+  const relativePath = attachmentFolderPath.startsWith("./") ? trimStart(attachmentFolderPath, "./") : null;
+  const noteFileOrNull = getFileOrNull(app, notePathOrFile);
+  if (isCurrentFolder) {
+    attachmentFolderPath = noteFileOrNull ? noteFileOrNull.parent?.path ?? "" : "";
+  } else if (relativePath) {
+    attachmentFolderPath = (noteFileOrNull ? noteFileOrNull.parent?.getParentPrefix() ?? "" : "") + relativePath;
+  }
+  attachmentFolderPath = normalize(normalizeSlashes(attachmentFolderPath));
+  const attachmentFileBaseName = normalize(normalizeSlashes(params.attachmentFileBaseName));
+  let folder = getFolderOrNull(app, attachmentFolderPath, true);
+  if (!folder && relativePath) {
+    folder = shouldSkipMissingAttachmentFolderCreation ? getFolder(app, attachmentFolderPath, true) : await app.vault.createFolder(attachmentFolderPath);
+  }
+  const prefix = folder?.getParentPrefix() ?? "";
+  return shouldSkipDuplicateCheck ? makeFileName(prefix + attachmentFileBaseName, attachmentFileExtension) : app.vault.getAvailablePath(prefix + attachmentFileBaseName, attachmentFileExtension);
+}
+async function hasOwnAttachmentFolder(app, path, context = "Unknown" /* Unknown */) {
+  const attachmentFolderPath = await getAttachmentFolderPath(app, path, context);
+  const dummyAttachmentFolderPath = await getAttachmentFolderPath(app, join(dirname(path), `${DUMMY_PATH}.${MARKDOWN_FILE_EXTENSION}`), context);
+  return attachmentFolderPath !== dummyAttachmentFolderPath;
+}
+function normalizeSlashes(path) {
+  path = replaceAll(path, /(?:[\\/])+/g, "/");
+  path = replaceAll(path, /^\/+|\/+$/g, "");
+  return path || "/";
+}
+export {
+  AttachmentPathContext,
+  DUMMY_PATH,
+  getAttachmentFilePath,
+  getAttachmentFolderPath,
+  getAvailablePathForAttachments,
+  hasOwnAttachmentFolder
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/attachment-path.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Provides utility functions for working with attachment paths.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type {\n  App,\n  FileStats,\n  Vault\n} from 'obsidian';\n\nimport { parentFolderPath } from 'obsidian-typings/implementations';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  makeFileName\n} from '../path.ts';\nimport {\n  normalize,\n  replaceAll,\n  trimStart\n} from '../string.ts';\nimport {\n  getFileOrNull,\n  getFolder,\n  getFolderOrNull,\n  getPath,\n  MARKDOWN_FILE_EXTENSION\n} from './file-system.ts';\n\n/**\n * A context for an attachment path.\n */\nexport enum AttachmentPathContext {\n  /**\n   * A context for a delete note.\n   */\n  DeleteNote = 'DeleteNote',\n\n  /**\n   * A context for a rename note.\n   */\n  RenameNote = 'RenameNote',\n\n  /**\n   * An unknown context.\n   */\n  Unknown = 'Unknown'\n}\n\n/**\n * Options for the get available path for attachments extended function.\n */\nexport interface GetAvailablePathForAttachmentsExtendedFnParams {\n  /**\n   * A base name of the attachment.\n   */\n  readonly attachmentFileBaseName: string;\n\n  /**\n   * A content of the attachment file.\n   */\n  readonly attachmentFileContent?: ArrayBuffer | undefined;\n\n  /**\n   * An extension of the attachment.\n   */\n  readonly attachmentFileExtension: string;\n\n  /**\n   * A stats of the attachment file.\n   */\n  readonly attachmentFileStat?: FileStats | undefined;\n\n  /**\n   * A context.\n   */\n  readonly context: AttachmentPathContext;\n\n  /**\n   * A path or file of the note.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n\n  /**\n   * A path or file of the old attachment.\n   */\n  readonly oldAttachmentPathOrFile: PathOrFile;\n\n  /**\n   * A path or file of the old note.\n   */\n  readonly oldNotePathOrFile?: PathOrFile | undefined;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck?: boolean;\n\n  /**\n   * Should the generated attachment file name be skipped.\n   */\n  readonly shouldSkipGeneratedAttachmentFileName?: boolean;\n\n  /**\n   * Should missing attachment folder creation be skipped.\n   */\n  readonly shouldSkipMissingAttachmentFolderCreation: boolean | undefined;\n}\n\n/**\n * {@link Vault.getAvailablePathForAttachments} extended wrapper.\n */\nexport interface GetAvailablePathForAttachmentsFnExtended extends GetAvailablePathForAttachmentsFn {\n  /**\n   * Get available path for attachments with additional params.\n   *\n   * @param params - Parameters for the get available path for attachments.\n   * @returns A {@link Promise} that resolves to the available path for attachments.\n   */\n  extended(params: GetAvailablePathForAttachmentsExtendedFnParams): Promise<string>;\n}\n\ntype GetAvailablePathForAttachmentsFn = Vault['getAvailablePathForAttachments'];\n\n/**\n * Dummy path.\n */\nexport const DUMMY_PATH = '__DUMMY__';\n\n/**\n * Options for the getAttachmentFilePath function.\n */\nexport interface GetAttachmentFilePathParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * A context.\n   */\n  readonly context: AttachmentPathContext;\n\n  /**\n   * A path of the note.\n   */\n  readonly notePathOrFile: PathOrFile;\n\n  /**\n   * A path of the attachment.\n   */\n  readonly oldAttachmentPathOrFile: PathOrFile;\n\n  /**\n   * A path of the old note.\n   */\n  readonly oldNotePathOrFile?: PathOrFile | undefined;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck: boolean;\n}\n\n/**\n * Options for the getAvailablePathForAttachments function.\n */\nexport interface GetAvailablePathForAttachmentsParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n  /**\n   * A base name of the attachment.\n   */\n  readonly attachmentFileBaseName: string;\n  /**\n   * An extension of the attachment.\n   */\n  readonly attachmentFileExtension: string;\n  /**\n   * A file to attach to.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck?: boolean;\n  /**\n   * Should missing attachment folder creation be skipped.\n   */\n  readonly shouldSkipMissingAttachmentFolderCreation?: boolean;\n}\n\n/**\n * Retrieves the file path for an attachment within a note.\n *\n * @param params - Parameters for the get attachment file path function.\n * @returns A {@link Promise} that resolves to the file path of the attachment.\n */\nexport async function getAttachmentFilePath(params: GetAttachmentFilePathParams): Promise<string> {\n  const {\n    app,\n    notePathOrFile,\n    oldAttachmentPathOrFile,\n    shouldSkipDuplicateCheck\n  } = params;\n  const attachmentPath = getPath(app, oldAttachmentPathOrFile);\n  const attachmentFileExtension = extname(attachmentPath);\n  const attachmentFileBaseName = basename(attachmentPath, attachmentFileExtension);\n  const attachmentFile = getFileOrNull(app, attachmentPath);\n\n  const extendedFn = (app.vault.getAvailablePathForAttachments as Partial<GetAvailablePathForAttachmentsFnExtended>).extended;\n  if (extendedFn) {\n    return extendedFn({\n      attachmentFileBaseName,\n      attachmentFileContent: attachmentFile ? await app.vault.readBinary(attachmentFile) : undefined,\n      attachmentFileExtension: attachmentFileExtension.slice(1),\n      attachmentFileStat: attachmentFile?.stat,\n      context: params.context,\n      notePathOrFile,\n      oldAttachmentPathOrFile: params.oldAttachmentPathOrFile,\n      oldNotePathOrFile: params.oldNotePathOrFile,\n      shouldSkipDuplicateCheck,\n      shouldSkipMissingAttachmentFolderCreation: true\n    });\n  }\n\n  return await getAvailablePathForAttachments({\n    app,\n    attachmentFileBaseName,\n    attachmentFileExtension: attachmentFileExtension.slice(1),\n    notePathOrFile,\n    shouldSkipDuplicateCheck,\n    shouldSkipMissingAttachmentFolderCreation: true\n  });\n}\n\n/**\n * Retrieves the attachment folder path for a given note.\n *\n * @param app - The Obsidian application instance.\n * @param notePathOrFile - The path of the note.\n * @param context - The context.\n * @returns A {@link Promise} that resolves to the attachment folder path.\n */\nexport async function getAttachmentFolderPath(app: App, notePathOrFile: PathOrFile, context = AttachmentPathContext.Unknown): Promise<string> {\n  return parentFolderPath(\n    await getAttachmentFilePath({\n      app,\n      context,\n      notePathOrFile,\n      oldAttachmentPathOrFile: DUMMY_PATH,\n      shouldSkipDuplicateCheck: true\n    })\n  );\n}\n\n/**\n * Retrieves the available path for attachments.\n *\n * @param params - Parameters for the get available path for attachments function.\n * @returns A {@link Promise} that resolves to the available path for attachments.\n */\nexport async function getAvailablePathForAttachments(params: GetAvailablePathForAttachmentsParams): Promise<string> {\n  const {\n    app,\n    attachmentFileExtension,\n    notePathOrFile,\n    shouldSkipDuplicateCheck,\n    shouldSkipMissingAttachmentFolderCreation\n  } = params;\n  let attachmentFolderPath = app.vault.getConfig('attachmentFolderPath') as string;\n  const isCurrentFolder = attachmentFolderPath === '.' || attachmentFolderPath === './';\n  const relativePath = attachmentFolderPath.startsWith('./') ? trimStart(attachmentFolderPath, './') : null;\n\n  const noteFileOrNull = getFileOrNull(app, notePathOrFile);\n\n  if (isCurrentFolder) {\n    attachmentFolderPath = noteFileOrNull ? noteFileOrNull.parent?.path ?? '' : '';\n  } else if (relativePath) {\n    attachmentFolderPath = (noteFileOrNull ? noteFileOrNull.parent?.getParentPrefix() ?? '' : '') + relativePath;\n  }\n\n  attachmentFolderPath = normalize(normalizeSlashes(attachmentFolderPath));\n  const attachmentFileBaseName = normalize(normalizeSlashes(params.attachmentFileBaseName));\n\n  let folder = getFolderOrNull(app, attachmentFolderPath, true);\n\n  if (!folder && relativePath) {\n    folder = shouldSkipMissingAttachmentFolderCreation\n      ? getFolder(app, attachmentFolderPath, true)\n      : await app.vault.createFolder(attachmentFolderPath);\n  }\n\n  const prefix = folder?.getParentPrefix() ?? '';\n  return shouldSkipDuplicateCheck\n    ? makeFileName(prefix + attachmentFileBaseName, attachmentFileExtension)\n    : app.vault.getAvailablePath(prefix + attachmentFileBaseName, attachmentFileExtension);\n}\n\n/**\n * Checks if a note has its own attachment folder.\n *\n * @param app - The Obsidian application instance.\n * @param path - The path of the note.\n * @param context - The context.\n * @returns A {@link Promise} that resolves to a boolean indicating whether the note has its own attachment folder.\n */\nexport async function hasOwnAttachmentFolder(app: App, path: string, context = AttachmentPathContext.Unknown): Promise<boolean> {\n  const attachmentFolderPath = await getAttachmentFolderPath(app, path, context);\n  const dummyAttachmentFolderPath = await getAttachmentFolderPath(app, join(dirname(path), `${DUMMY_PATH}.${MARKDOWN_FILE_EXTENSION}`), context);\n  return attachmentFolderPath !== dummyAttachmentFolderPath;\n}\n\n/**\n * Normalizes a path by combining multiple slashes into a single slash and removing leading and trailing slashes.\n *\n * @param path - Path to normalize.\n * @returns The normalized path.\n */\nfunction normalizeSlashes(path: string): string {\n  path = replaceAll(path, /(?:[\\\\/])+/g, '/');\n  path = replaceAll(path, /^\\/+|\\/+$/g, '');\n  return path || '/';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["AttachmentPathContext"]
}


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

@@ -0,0 +1,61 @@
+/**
+ * @packageDocumentation
+ *
+ * Provides utility functions for working with backlinks.
+ */
+import type { DataviewInlineApi } from './dataview.mjs';
+import type { PathOrAbstractFile, PathOrFile } from './file-system.mjs';
+/**
+ * Options for {@link renderDelayedBacklinksForFolder}.
+ */
+export interface RenderDelayedBacklinksForFolderParams {
+    /**
+     * A {@link DataviewInlineApi} instance.
+     */
+    readonly dv: DataviewInlineApi;
+    /**
+     * A folder path. If not provided, the current file's folder will be used.
+     */
+    readonly folder?: string;
+    /**
+     * A title for the rendered backlinks. Defaults to "Folder Backlinks".
+     */
+    readonly title?: string;
+}
+/**
+ * Options for {@link renderDelayedBacklinks}.
+ */
+export interface RenderDelayedBacklinksParams {
+    /**
+     * A {@link DataviewInlineApi} instance.
+     */
+    readonly dv: DataviewInlineApi;
+    /**
+     * An array of PathOrFile.
+     */
+    readonly files: PathOrFile[];
+    /**
+     * A title for the rendered backlinks. Defaults to "Backlinks".
+     */
+    readonly title?: string;
+}
+/**
+ * Renders a backlinks table using the provided DataviewInlineApi and optional array of PathOrAbstractFile.
+ *
+ * @param dv - The DataviewInlineApi instance.
+ * @param pathOrFiles - An optional array of PathOrAbstractFile.
+ * @returns A {@link Promise} that resolves when the backlinks table has been rendered.
+ */
+export declare function renderBacklinksTable(dv: DataviewInlineApi, pathOrFiles?: PathOrAbstractFile[]): Promise<void>;
+/**
+ * Renders delayed backlinks.
+ *
+ * @param params - The parameters for rendering delayed backlinks.
+ */
+export declare function renderDelayedBacklinks(params: RenderDelayedBacklinksParams): void;
+/**
+ * Renders delayed backlinks for a specific folder.
+ *
+ * @param params - The parameters for rendering delayed backlinks.
+ */
+export declare function renderDelayedBacklinksForFolder(params: RenderDelayedBacklinksForFolderParams): void;