obsidian-dev-utils 80.0.2 → 81.0.0

package/dist/lib/esm/obsidian/file-manager.mjs

@@ -21,7 +21,10 @@ if you want to view the source, please visit the github repository of this plugi
   globalThis.process = browserProcess;
 })();
 
-import { deepEqual } from "../object-utils.mjs";
+import {
+  deepEqual,
+  normalizeOptionalProperties
+} from "../object-utils.mjs";
 import {
   getFile,
   getPath,
@@ -32,63 +35,92 @@ import {
   setFrontmatter
 } from "./frontmatter.mjs";
 import { process } from "./vault.mjs";
-async function addAlias(app, pathOrFile, alias) {
+async function addAlias(params) {
+  const {
+    alias,
+    app,
+    pathOrFile
+  } = params;
   if (!alias) {
     return;
   }
-  const file = getFile(app, pathOrFile);
+  const file = getFile({ app, pathOrFile });
   if (!isMarkdownFile(file)) {
     throw new Error(`File ${file.path} is not a markdown file.`);
   }
   if (alias === file.basename || alias === file.name) {
     return;
   }
-  await processFrontmatter(app, pathOrFile, (frontmatter) => {
-    frontmatter.aliases ??= [];
-    if (!frontmatter.aliases.includes(alias)) {
-      frontmatter.aliases.push(alias);
-    }
+  await processFrontmatter({
+    app,
+    frontmatterFn: (frontmatter) => {
+      frontmatter.aliases ??= [];
+      if (!frontmatter.aliases.includes(alias)) {
+        frontmatter.aliases.push(alias);
+      }
+    },
+    pathOrFile
   });
 }
-async function deleteAlias(app, pathOrFile, alias) {
+async function deleteAlias(params) {
+  const {
+    alias,
+    app,
+    pathOrFile
+  } = params;
   if (!alias) {
     return;
   }
   if (!isMarkdownFile(pathOrFile)) {
     throw new Error(`File ${getPath(app, pathOrFile)} is not a markdown file.`);
   }
-  await processFrontmatter(app, pathOrFile, (frontmatter) => {
-    if (!frontmatter.aliases) {
-      return;
-    }
-    frontmatter.aliases = frontmatter.aliases.filter((a) => a !== alias);
-    if (frontmatter.aliases.length === 0) {
-      delete frontmatter.aliases;
-    }
+  await processFrontmatter({
+    app,
+    frontmatterFn: (frontmatter) => {
+      if (!frontmatter.aliases) {
+        return;
+      }
+      frontmatter.aliases = frontmatter.aliases.filter((a) => a !== alias);
+      if (frontmatter.aliases.length === 0) {
+        delete frontmatter.aliases;
+      }
+    },
+    pathOrFile
   });
 }
-async function processFrontmatter(app, pathOrFile, frontmatterFn, options = {}) {
+async function processFrontmatter(params) {
+  const {
+    app,
+    frontmatterFn,
+    pathOrFile,
+    ...options
+  } = params;
   if (!isMarkdownFile(pathOrFile)) {
     throw new Error(`File ${getPath(app, pathOrFile)} is not a markdown file.`);
   }
-  await process(app, pathOrFile, async ({ abortSignal, content }) => {
-    abortSignal.throwIfAborted();
-    const oldFrontmatter = parseFrontmatter(content);
-    const newFrontmatter = parseFrontmatter(content);
-    const result = await frontmatterFn(newFrontmatter, abortSignal);
-    abortSignal.throwIfAborted();
-    if (result === null) {
-      return null;
-    }
-    if (deepEqual(oldFrontmatter, newFrontmatter)) {
-      return content;
-    }
-    return setFrontmatter(content, newFrontmatter);
-  }, options);
+  await process(normalizeOptionalProperties({
+    app,
+    async newContentProvider({ abortSignal, content }) {
+      abortSignal.throwIfAborted();
+      const oldFrontmatter = parseFrontmatter(content);
+      const newFrontmatter = parseFrontmatter(content);
+      const result = await frontmatterFn(newFrontmatter, abortSignal);
+      abortSignal.throwIfAborted();
+      if (result === null) {
+        return null;
+      }
+      if (deepEqual(oldFrontmatter, newFrontmatter)) {
+        return content;
+      }
+      return setFrontmatter(content, newFrontmatter);
+    },
+    pathOrFile,
+    ...options
+  }));
 }
 export {
   addAlias,
   deleteAlias,
   processFrontmatter
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/file-manager.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for managing files in Obsidian.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport type { MaybeReturn } from '../type.ts';\nimport type { PathOrFile } from './file-system.ts';\nimport type { CombinedFrontmatter } from './frontmatter.ts';\nimport type {\n  ProcessOptions,\n  ProcessParams\n} from './vault.ts';\n\nimport {\n  deepEqual,\n  normalizeOptionalProperties\n} from '../object-utils.ts';\nimport {\n  getFile,\n  getPath,\n  isMarkdownFile\n} from './file-system.ts';\nimport {\n  parseFrontmatter,\n  setFrontmatter\n} from './frontmatter.ts';\nimport { process } from './vault.ts';\n\n/**\n * Parameters for {@link addAlias}.\n */\nexport interface AddAliasParams {\n  /**\n   * The alias to add.\n   */\n  readonly alias?: string;\n\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path or TFile object representing the note.\n   */\n  readonly pathOrFile: PathOrFile;\n}\n\n/**\n * Parameters for {@link deleteAlias}.\n */\nexport interface DeleteAliasParams {\n  /**\n   * The alias to delete.\n   */\n  readonly alias?: string;\n\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path or TFile object representing the note.\n   */\n  readonly pathOrFile: PathOrFile;\n}\n\n/**\n * Options for {@link processFrontmatter}.\n */\nexport type ProcessFrontmatterOptions = ProcessOptions;\n\n/**\n * Parameters for {@link processFrontmatter}.\n *\n * @typeParam CustomFrontmatter - The type of custom front matter.\n */\nexport interface ProcessFrontmatterParams<CustomFrontmatter = unknown> extends ProcessFrontmatterOptions {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * A function that modifies the front matter.\n   *\n   * @param frontmatter - The front matter to modify.\n   * @param abortSignal - The abort signal to listen to.\n   * @returns A value that may be `null` to abort the process.\n   */\n  frontmatterFn(this: void, frontmatter: CombinedFrontmatter<CustomFrontmatter>, abortSignal: AbortSignal): Promisable<MaybeReturn<null>>;\n\n  /**\n   * The path or TFile object representing the note.\n   */\n  readonly pathOrFile: PathOrFile;\n}\n\n/**\n * Adds an alias to the front matter of a given file if it does not already exist.\n *\n * @param params - The parameters for adding the alias.\n * @returns A {@link Promise} that resolves when the alias has been added.\n */\nexport async function addAlias(params: AddAliasParams): Promise<void> {\n  const {\n    alias,\n    app,\n    pathOrFile\n  } = params;\n  if (!alias) {\n    return;\n  }\n\n  const file = getFile({ app, pathOrFile });\n\n  if (!isMarkdownFile(file)) {\n    throw new Error(`File ${file.path} is not a markdown file.`);\n  }\n\n  if (alias === file.basename || alias === file.name) {\n    return;\n  }\n\n  await processFrontmatter({\n    app,\n    frontmatterFn: (frontmatter) => {\n      frontmatter.aliases ??= [];\n\n      if (!frontmatter.aliases.includes(alias)) {\n        frontmatter.aliases.push(alias);\n      }\n    },\n    pathOrFile\n  });\n}\n\n/**\n * Deletes an alias from the front matter of a given file if it exists.\n *\n * @param params - The parameters for deleting the alias.\n * @returns A {@link Promise} that resolves when the alias has been deleted.\n */\nexport async function deleteAlias(params: DeleteAliasParams): Promise<void> {\n  const {\n    alias,\n    app,\n    pathOrFile\n  } = params;\n  if (!alias) {\n    return;\n  }\n\n  if (!isMarkdownFile(pathOrFile)) {\n    throw new Error(`File ${getPath(app, pathOrFile)} is not a markdown file.`);\n  }\n\n  await processFrontmatter({\n    app,\n    frontmatterFn: (frontmatter) => {\n      if (!frontmatter.aliases) {\n        return;\n      }\n\n      frontmatter.aliases = frontmatter.aliases.filter((a) => a !== alias);\n\n      if (frontmatter.aliases.length === 0) {\n        delete frontmatter.aliases;\n      }\n    },\n    pathOrFile\n  });\n}\n\n/**\n * Processes the front matter of a given file, allowing modifications via a provided function.\n *\n * @typeParam CustomFrontmatter - The type of custom front matter.\n * @param params - The parameters for processing the front matter.\n * @returns A {@link Promise} that resolves when the front matter has been processed and saved.\n */\nexport async function processFrontmatter<CustomFrontmatter = unknown>(params: ProcessFrontmatterParams<CustomFrontmatter>): Promise<void> {\n  const {\n    app,\n    frontmatterFn,\n    pathOrFile,\n    ...options\n  } = params;\n  if (!isMarkdownFile(pathOrFile)) {\n    throw new Error(`File ${getPath(app, pathOrFile)} is not a markdown file.`);\n  }\n\n  await process(normalizeOptionalProperties<ProcessParams>({\n    app,\n    async newContentProvider({ abortSignal, content }) {\n      abortSignal.throwIfAborted();\n\n      const oldFrontmatter = parseFrontmatter<CustomFrontmatter>(content);\n      const newFrontmatter = parseFrontmatter<CustomFrontmatter>(content);\n      const result = await frontmatterFn(newFrontmatter, abortSignal);\n      abortSignal.throwIfAborted();\n\n      if (result === null) {\n        return null;\n      }\n\n      if (deepEqual(oldFrontmatter, newFrontmatter)) {\n        return content;\n      }\n\n      return setFrontmatter(content, newFrontmatter);\n    },\n    pathOrFile,\n    ...options\n  }));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAiBA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,eAAe;AA+ExB,eAAsB,SAAS,QAAuC;AACpE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,MAAI,CAAC,OAAO;AACV;AAAA,EACF;AAEA,QAAM,OAAO,QAAQ,EAAE,KAAK,WAAW,CAAC;AAExC,MAAI,CAAC,eAAe,IAAI,GAAG;AACzB,UAAM,IAAI,MAAM,QAAQ,KAAK,IAAI,0BAA0B;AAAA,EAC7D;AAEA,MAAI,UAAU,KAAK,YAAY,UAAU,KAAK,MAAM;AAClD;AAAA,EACF;AAEA,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA,eAAe,CAAC,gBAAgB;AAC9B,kBAAY,YAAY,CAAC;AAEzB,UAAI,CAAC,YAAY,QAAQ,SAAS,KAAK,GAAG;AACxC,oBAAY,QAAQ,KAAK,KAAK;AAAA,MAChC;AAAA,IACF;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAQA,eAAsB,YAAY,QAA0C;AAC1E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,MAAI,CAAC,OAAO;AACV;AAAA,EACF;AAEA,MAAI,CAAC,eAAe,UAAU,GAAG;AAC/B,UAAM,IAAI,MAAM,QAAQ,QAAQ,KAAK,UAAU,CAAC,0BAA0B;AAAA,EAC5E;AAEA,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA,eAAe,CAAC,gBAAgB;AAC9B,UAAI,CAAC,YAAY,SAAS;AACxB;AAAA,MACF;AAEA,kBAAY,UAAU,YAAY,QAAQ,OAAO,CAAC,MAAM,MAAM,KAAK;AAEnE,UAAI,YAAY,QAAQ,WAAW,GAAG;AACpC,eAAO,YAAY;AAAA,MACrB;AAAA,IACF;AAAA,IACA;AAAA,EACF,CAAC;AACH;AASA,eAAsB,mBAAgD,QAAoE;AACxI,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL,IAAI;AACJ,MAAI,CAAC,eAAe,UAAU,GAAG;AAC/B,UAAM,IAAI,MAAM,QAAQ,QAAQ,KAAK,UAAU,CAAC,0BAA0B;AAAA,EAC5E;AAEA,QAAM,QAAQ,4BAA2C;AAAA,IACvD;AAAA,IACA,MAAM,mBAAmB,EAAE,aAAa,QAAQ,GAAG;AACjD,kBAAY,eAAe;AAE3B,YAAM,iBAAiB,iBAAoC,OAAO;AAClE,YAAM,iBAAiB,iBAAoC,OAAO;AAClE,YAAM,SAAS,MAAM,cAAc,gBAAgB,WAAW;AAC9D,kBAAY,eAAe;AAE3B,UAAI,WAAW,MAAM;AACnB,eAAO;AAAA,MACT;AAEA,UAAI,UAAU,gBAAgB,cAAc,GAAG;AAC7C,eAAO;AAAA,MACT;AAEA,aAAO,eAAe,SAAS,cAAc;AAAA,IAC/C;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL,CAAC,CAAC;AACJ;",
  "names": []
}


package/dist/lib/esm/obsidian/file-system.d.mts

@@ -31,6 +31,158 @@ export declare enum FileSystemType {
      */
     Folder = "folder"
 }
+/**
+ * Parameters for {@link exists}.
+ */
+export interface ExistsParams {
+    /**
+     * The Obsidian App instance.
+     */
+    readonly app: App;
+    /**
+     * Specifies whether to perform a case-insensitive search. Default is `undefined`.
+     */
+    readonly isCaseInsensitive?: boolean;
+    /**
+     * The path to check.
+     */
+    readonly path: string;
+    /**
+     * The type of the file system object to check. Default is `undefined`.
+     */
+    readonly type?: FileSystemType;
+}
+/**
+ * Parameters for {@link getAbstractFileOrNull}.
+ */
+export interface GetAbstractFileOrNullParams {
+    /**
+     * The Obsidian App instance.
+     */
+    readonly app: App;
+    /**
+     * Specifies whether to perform a case-insensitive search. Default is `false`.
+     */
+    readonly isCaseInsensitive?: boolean;
+    /**
+     * The path or abstract file to retrieve.
+     */
+    readonly pathOrFile: null | PathOrAbstractFile;
+}
+/**
+ * Parameters for {@link getAbstractFile}.
+ */
+export interface GetAbstractFileParams {
+    /**
+     * The Obsidian App instance.
+     */
+    readonly app: App;
+    /**
+     * Specifies whether to perform a case-insensitive search. Default is `false`.
+     */
+    readonly isCaseInsensitive?: boolean;
+    /**
+     * The path or abstract file to retrieve the abstract file for.
+     */
+    readonly pathOrFile: PathOrAbstractFile;
+}
+/**
+ * Parameters for {@link getFileOrNull}.
+ */
+export interface GetFileOrNullParams {
+    /**
+     * The Obsidian App instance.
+     */
+    readonly app: App;
+    /**
+     * Specifies whether to perform a case-insensitive search. Default is `false`.
+     */
+    readonly isCaseInsensitive?: boolean;
+    /**
+     * The path or file.
+     */
+    readonly pathOrFile: null | PathOrFile;
+}
+/**
+ * Parameters for {@link getFile}.
+ */
+export interface GetFileParams {
+    /**
+     * The Obsidian App instance.
+     */
+    readonly app: App;
+    /**
+     * Specifies whether to perform a case-insensitive search. Default is `false`.
+     */
+    readonly isCaseInsensitive?: boolean;
+    /**
+     * The path or file to retrieve the file for.
+     */
+    readonly pathOrFile: PathOrFile;
+    /**
+     * Whether to include a non-existing file.
+     *  If `true`, a new file is created for the provided path.
+     *  If `false`, an error is thrown if the file is not found.
+     */
+    readonly shouldIncludeNonExisting?: boolean;
+}
+/**
+ * Parameters for {@link getFolderOrNull}.
+ */
+export interface GetFolderOrNullParams {
+    /**
+     * The Obsidian App instance.
+     */
+    readonly app: App;
+    /**
+     * Specifies whether to perform a case-insensitive search. Default is `false`.
+     */
+    readonly isCaseInsensitive?: boolean;
+    /**
+     * The path or folder to retrieve the folder from.
+     */
+    readonly pathOrFolder: null | PathOrFolder;
+}
+/**
+ * Parameters for {@link getFolder}.
+ */
+export interface GetFolderParams {
+    /**
+     * The Obsidian App instance.
+     */
+    readonly app: App;
+    /**
+     * Specifies whether to perform a case-insensitive search. Default is `false`.
+     */
+    readonly isCaseInsensitive?: boolean;
+    /**
+     * The path or folder identifier.
+     */
+    readonly pathOrFolder: PathOrFolder;
+    /**
+     * Whether to allow the folder to not exist.
+     *  If `true`, a new folder is created for the provided path.
+     *  If `false`, an error is thrown if the folder is not found.
+     */
+    readonly shouldIncludeNonExisting?: boolean;
+}
+/**
+ * Parameters for {@link getMarkdownFiles}.
+ */
+export interface GetMarkdownFilesParams {
+    /**
+     * The Obsidian App instance.
+     */
+    readonly app: App;
+    /**
+     * Specifies whether to recursively search for markdown files within subfolders. Default is `false`.
+     */
+    readonly isRecursive?: boolean;
+    /**
+     * The path or folder to retrieve the markdown files from.
+     */
+    readonly pathOrFolder: PathOrFolder;
+}
 /**
  * A path or an abstract file.
  */
@@ -102,56 +254,42 @@ export declare function checkExtension(pathOrFile: null | PathOrAbstractFile, ex
 /**
  * Checks if the given path exists.
  *
- * @param app - The Obsidian App instance.
- * @param path - The path to check.
- * @param type - The type of the file system object to check. Default is `undefined`.
- * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `undefined`.
+ * @param params - The parameters for the check.
  * @returns `true` if the path exists, `false` otherwise.
  */
-export declare function exists(app: App, path: string, type?: FileSystemType, isCaseInsensitive?: boolean): boolean;
+export declare function exists(params: ExistsParams): boolean;
 /**
  * Retrieves the TAbstractFile object for the given path or abstract file.
  *
- * @param app - The App instance.
- * @param pathOrFile - The path or abstract file to retrieve the abstract file for.
- * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.
+ * @param params - The parameters for the retrieval.
  * @returns The abstract file.
  * @throws Error if the abstract file is not found.
  */
-export declare function getAbstractFile(app: App, pathOrFile: PathOrAbstractFile, isCaseInsensitive?: boolean): TAbstractFile;
+export declare function getAbstractFile(params: GetAbstractFileParams): TAbstractFile;
 /**
  * Retrieves an abstract file or `null` based on the provided path or abstract file.
  *
- * @param app - The application instance.
- * @param pathOrFile - The path or abstract file to retrieve.
- * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.
+ * @param params - The parameters for the retrieval.
  * @returns The abstract file if found, otherwise `null`.
  */
-export declare function getAbstractFileOrNull(app: App, pathOrFile: null | PathOrAbstractFile, isCaseInsensitive?: boolean): null | TAbstractFile;
+export declare function getAbstractFileOrNull(params: GetAbstractFileOrNullParams): null | TAbstractFile;
 /**
  * Retrieves a file based on the provided path or file.
  *
- * @param app - The Obsidian App instance.
- * @param pathOrFile - The path or file to retrieve the file for.
- * @param shouldIncludeNonExisting - Whether to include a non-existing file.
- *  If `true`, a new file is created for the provided path.
- *  If `false`, an error is thrown if the file is not found.
- * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.
+ * @param params - The parameters for the retrieval.
  * @returns The file corresponding to the provided path or file.
  * @throws Error if the file is not found.
  */
-export declare function getFile(app: App, pathOrFile: PathOrFile, shouldIncludeNonExisting?: boolean, isCaseInsensitive?: boolean): TFile;
+export declare function getFile(params: GetFileParams): TFile;
 /**
  * Retrieves a file or `null` based on the provided path or file.
  * If the provided argument is already a file, it is returned as is.
  * Otherwise, the function uses the app's vault to retrieve the file by its path.
  *
- * @param app - The Obsidian App instance.
- * @param pathOrFile - The path or file.
- * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.
+ * @param params - The parameters for the retrieval.
  * @returns The file if found, otherwise `null`.
  */
-export declare function getFileOrNull(app: App, pathOrFile: null | PathOrFile, isCaseInsensitive?: boolean): null | TFile;
+export declare function getFileOrNull(params: GetFileOrNullParams): null | TFile;
 /**
  * Gets the type of a file system object.
  *
@@ -163,34 +301,25 @@ export declare function getFileSystemType(abstractFile: TAbstractFile): FileSyst
 /**
  * Retrieves a folder based on the provided app and pathOrFolder.
  *
- * @param app - The Obsidian app instance.
- * @param pathOrFolder - The path or folder identifier.
- * @param shouldIncludeNonExisting - Whether to allow the folder to not exist.
- *  If `true`, a new folder is created for the provided path.
- *  If `false`, an error is thrown if the folder is not found.
- * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.
+ * @param params - The parameters for the retrieval.
  * @returns The retrieved folder.
  * @throws If the folder is not found.
  */
-export declare function getFolder(app: App, pathOrFolder: PathOrFolder, shouldIncludeNonExisting?: boolean, isCaseInsensitive?: boolean): TFolder;
+export declare function getFolder(params: GetFolderParams): TFolder;
 /**
  * Retrieves a folder or `null` based on the provided path or folder.
  *
- * @param app - The Obsidian application instance.
- * @param pathOrFolder - The path or folder to retrieve the folder from.
- * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.
+ * @param params - The parameters for the retrieval.
  * @returns The folder if found, otherwise `null`.
  */
-export declare function getFolderOrNull(app: App, pathOrFolder: null | PathOrFolder, isCaseInsensitive?: boolean): null | TFolder;
+export declare function getFolderOrNull(params: GetFolderOrNullParams): null | TFolder;
 /**
  * Retrieves an array of files representing the markdown files within a specified folder or path.
  *
- * @param app - The Obsidian App instance.
- * @param pathOrFolder - The path or folder to retrieve the markdown files from.
- * @param isRecursive - Optional. Specifies whether to recursively search for markdown files within subfolders. Default is `false`.
+ * @param params - The parameters for the retrieval.
  * @returns An array of files representing the markdown files.
  */
-export declare function getMarkdownFiles(app: App, pathOrFolder: PathOrFolder, isRecursive?: boolean): TFile[];
+export declare function getMarkdownFiles(params: GetMarkdownFilesParams): TFile[];
 /**
  * Retrieves the file for the given path or creates a new one if it does not exist.
  *