obsidian-dev-utils 50.0.0 → 51.1.6

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

@@ -0,0 +1,279 @@
+/**
+ * @packageDocumentation
+ *
+ * This module provides utility functions for working with {@link TAbstractFile}, {@link TFile}, and {@link TFolder} instances in Obsidian.
+ */
+import type { App } from 'obsidian';
+import { TAbstractFile, TFile, TFolder } from 'obsidian';
+/**
+ * A file extension for `base` files.
+ */
+export declare const BASE_FILE_EXTENSION = "base";
+/**
+ * A file extension for `canvas` files.
+ */
+export declare const CANVAS_FILE_EXTENSION = "canvas";
+/**
+ * A file extension for `markdown` files.
+ */
+export declare const MARKDOWN_FILE_EXTENSION = "md";
+/**
+ * A type of file system object.
+ */
+export declare enum FileSystemType {
+    /**
+     * A file.
+     */
+    File = "file",
+    /**
+     * A folder.
+     */
+    Folder = "folder"
+}
+/**
+ * A path or an abstract file.
+ */
+export type PathOrAbstractFile = string | TAbstractFile;
+/**
+ * A path or a file.
+ */
+export type PathOrFile = string | TFile;
+/**
+ * A path or a folder.
+ */
+export type PathOrFolder = string | TFolder;
+/**
+ * Converts an array of abstract files to an array of files.
+ *
+ * @param abstractFiles - The abstract files to convert.
+ * @returns The array of files.
+ * @throws Error if any of the abstract files are not files.
+ */
+export declare function asArrayOfFiles(abstractFiles: TAbstractFile[]): TFile[];
+/**
+ * Converts an array of abstract files to an array of folders.
+ *
+ * @param abstractFiles - The abstract files to convert.
+ * @returns The array of folders.
+ * @throws Error if any of the abstract files are not folders.
+ */
+export declare function asArrayOfFolders(abstractFiles: TAbstractFile[]): TFolder[];
+/**
+ * Converts an abstract file to a file.
+ *
+ * @param abstractFile - The abstract file to convert.
+ * @returns The file.
+ * @throws Error if the abstract file is not a file.
+ */
+export declare function asFile(abstractFile: null | TAbstractFile): TFile;
+/**
+ * Converts an abstract file to a file or `null`.
+ *
+ * @param abstractFile - The abstract file to convert.
+ * @returns The file or `null`.
+ * @throws Error if the abstract file is not a file.
+ */
+export declare function asFileOrNull(abstractFile: null | TAbstractFile): null | TFile;
+/**
+ * Converts an abstract file to a folder.
+ *
+ * @param abstractFile - The abstract file to convert.
+ * @returns The folder.
+ * @throws Error if the abstract file is not a folder.
+ */
+export declare function asFolder(abstractFile: null | TAbstractFile): TFolder;
+/**
+ * Converts an abstract file to a folder or `null`.
+ *
+ * @param abstractFile - The abstract file to convert.
+ * @returns The folder or `null`.
+ * @throws Error if the abstract file is not a folder.
+ */
+export declare function asFolderOrNull(abstractFile: null | TAbstractFile): null | TFolder;
+/**
+ * Checks if the given path or file has the specified extension.
+ *
+ * @param app - The Obsidian App instance.
+ * @param pathOrFile - The path or abstract file to check.
+ * @param extension - The extension to compare against.
+ * @returns Returns `true` if the path or file has the specified extension, `false` otherwise.
+ */
+export declare function checkExtension(app: App, pathOrFile: null | PathOrAbstractFile, extension: string): boolean;
+/**
+ * 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`.
+ * @returns `true` if the path exists, `false` otherwise.
+ */
+export declare function exists(app: App, path: string, type?: FileSystemType, isCaseInsensitive?: boolean): 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`.
+ * @returns The abstract file.
+ * @throws Error if the abstract file is not found.
+ */
+export declare function getAbstractFile(app: App, pathOrFile: PathOrAbstractFile, isCaseInsensitive?: boolean): 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`.
+ * @returns The abstract file if found, otherwise `null`.
+ */
+export declare function getAbstractFileOrNull(app: App, pathOrFile: null | PathOrAbstractFile, isCaseInsensitive?: boolean): 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`.
+ * @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;
+/**
+ * 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`.
+ * @returns The file if found, otherwise `null`.
+ */
+export declare function getFileOrNull(app: App, pathOrFile: null | PathOrFile, isCaseInsensitive?: boolean): null | TFile;
+/**
+ * Gets the type of a file system object.
+ *
+ * @param abstractFile - The abstract file to get the type of.
+ * @returns The type of the abstract file.
+ * @throws Error if the abstract file is not a file or a folder.
+ */
+export declare function getFileSystemType(abstractFile: TAbstractFile): FileSystemType;
+/**
+ * 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`.
+ * @returns The retrieved folder.
+ * @throws If the folder is not found.
+ */
+export declare function getFolder(app: App, pathOrFolder: PathOrFolder, shouldIncludeNonExisting?: boolean, isCaseInsensitive?: boolean): 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`.
+ * @returns The folder if found, otherwise `null`.
+ */
+export declare function getFolderOrNull(app: App, pathOrFolder: null | PathOrFolder, isCaseInsensitive?: boolean): 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`.
+ * @returns An array of files representing the markdown files.
+ */
+export declare function getMarkdownFiles(app: App, pathOrFolder: PathOrFolder, isRecursive?: boolean): TFile[];
+/**
+ * Retrieves the file for the given path or creates a new one if it does not exist.
+ *
+ * @param app - The Obsidian App instance.
+ * @param path - The path of the file to retrieve or create.
+ * @returns The file representing the file
+ */
+export declare function getOrCreateFile(app: App, path: string): Promise<TFile>;
+/**
+ * Retrieves the folder for the given path or creates a new one if it does not exist.
+ *
+ * @param app - The Obsidian App instance.
+ * @param path - The path of the folder to retrieve or create.
+ * @returns The folder representing the folder.
+ */
+export declare function getOrCreateFolder(app: App, path: string): Promise<TFolder>;
+/**
+ * Returns the path of the given `pathOrFile`.
+ *
+ * @param app - The Obsidian App instance.
+ * @param pathOrFile - The path or abstract file.
+ * @returns The path of the `pathOrFile`.
+ */
+export declare function getPath(app: App, pathOrFile: PathOrAbstractFile): string;
+/**
+ * Checks if the given file is an instance of abstract file.
+ *
+ * @param file - The file to check.
+ * @returns A boolean indicating whether the file is an instance of abstract file.
+ */
+export declare function isAbstractFile(file: unknown): file is TAbstractFile;
+/**
+ *   Checks if the given file is a base file.
+ *
+ * @param app - The Obsidian App instance.
+ * @param pathOrFile - The path or file to check.
+ * @returns A boolean indicating whether the file is a base file.
+ */
+export declare function isBaseFile(app: App, pathOrFile: null | PathOrAbstractFile): boolean;
+/**
+ * Checks if the given file is a canvas file.
+ *
+ * @param app - The Obsidian App instance.
+ * @param pathOrFile - The path or file to check.
+ * @returns A boolean indicating whether the file is a canvas file or not.
+ */
+export declare function isCanvasFile(app: App, pathOrFile: null | PathOrAbstractFile): boolean;
+/**
+ * Checks if the given file is an instance of file.
+ *
+ * @param file - The file to check.
+ * @returns A boolean indicating whether the file is an instance of file.
+ */
+export declare function isFile(file: unknown): file is TFile;
+/**
+ * Checks if the given file is a folder.
+ *
+ * @param file - The file to check.
+ * @returns `true` if the file is a folder, `false` otherwise.
+ */
+export declare function isFolder(file: unknown): file is TFolder;
+/**
+ * Checks if the given file is a Markdown file.
+ *
+ * @param app - The Obsidian App instance.
+ * @param pathOrFile - The path or file to check.
+ * @returns A boolean indicating whether the file is a Markdown file.
+ */
+export declare function isMarkdownFile(app: App, pathOrFile: null | PathOrAbstractFile): boolean;
+/**
+ * Checks if the given file is a note.
+ *
+ * @param app - The Obsidian App instance.
+ * @param pathOrFile - The path or file to check.
+ * @returns A boolean indicating whether the file is a note.
+ */
+export declare function isNote(app: App, pathOrFile: null | PathOrAbstractFile): boolean;
+/**
+ * Trims the markdown extension from the file path if the file is a markdown file.
+ * If the file is not a markdown file, the original file path is returned.
+ *
+ * @param app - The Obsidian App instance.
+ * @param file - The file to trim the markdown extension from.
+ * @returns The file path with the markdown extension trimmed.
+ */
+export declare function trimMarkdownExtension(app: App, file: TAbstractFile): string;

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

@@ -0,0 +1,284 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import {
+  normalizePath,
+  TAbstractFile,
+  TFile,
+  TFolder,
+  Vault
+} from "obsidian";
+import {
+  createTFileInstance,
+  createTFolderInstance,
+  getDataAdapterEx,
+  parentFolderPath
+} from "obsidian-typings/implementations";
+import {
+  extname,
+  resolve
+} from "../path.mjs";
+import { trimEnd } from "../string.mjs";
+import { ensureNonNullable } from "../type-guards.mjs";
+const BASE_FILE_EXTENSION = "base";
+const CANVAS_FILE_EXTENSION = "canvas";
+const MARKDOWN_FILE_EXTENSION = "md";
+var FileSystemType = /* @__PURE__ */ ((FileSystemType2) => {
+  FileSystemType2["File"] = "file";
+  FileSystemType2["Folder"] = "folder";
+  return FileSystemType2;
+})(FileSystemType || {});
+function asArrayOfFiles(abstractFiles) {
+  return abstractFiles.map((abstractFile) => asFile(abstractFile));
+}
+function asArrayOfFolders(abstractFiles) {
+  return abstractFiles.map((abstractFile) => asFolder(abstractFile));
+}
+function asFile(abstractFile) {
+  return ensureNonNullable(asFileOrNull(abstractFile), "Abstract file is not a file");
+}
+function asFileOrNull(abstractFile) {
+  if (abstractFile === null) {
+    return null;
+  }
+  if (abstractFile instanceof TFile) {
+    return abstractFile;
+  }
+  throw new Error("Abstract file is not a file");
+}
+function asFolder(abstractFile) {
+  return ensureNonNullable(asFolderOrNull(abstractFile), "Abstract file is not a folder");
+}
+function asFolderOrNull(abstractFile) {
+  if (abstractFile === null) {
+    return null;
+  }
+  if (abstractFile instanceof TFolder) {
+    return abstractFile;
+  }
+  throw new Error("Abstract file is not a folder");
+}
+function checkExtension(app, pathOrFile, extension) {
+  if (isFile(pathOrFile)) {
+    return pathOrFile.extension === extension;
+  }
+  if (typeof pathOrFile === "string") {
+    const file = getFileOrNull(app, pathOrFile);
+    if (file) {
+      return file.extension === extension;
+    }
+    return extname(pathOrFile).slice(1) === extension;
+  }
+  return false;
+}
+function exists(app, path, type, isCaseInsensitive) {
+  const abstractFile = getAbstractFileOrNull(app, path, isCaseInsensitive);
+  if (!abstractFile) {
+    return false;
+  }
+  if (type === void 0) {
+    return true;
+  }
+  return getFileSystemType(abstractFile) === type;
+}
+function getAbstractFile(app, pathOrFile, isCaseInsensitive) {
+  return ensureNonNullable(getAbstractFileOrNull(app, pathOrFile, isCaseInsensitive), `Abstract file not found: ${pathOrFile}`);
+}
+function getAbstractFileOrNull(app, pathOrFile, isCaseInsensitive) {
+  if (pathOrFile === null) {
+    return null;
+  }
+  if (isAbstractFile(pathOrFile)) {
+    if (isFile(pathOrFile)) {
+      return app.vault.getFileByPath(pathOrFile.path) ?? pathOrFile;
+    }
+    if (isFolder(pathOrFile)) {
+      return app.vault.getFolderByPath(pathOrFile.path) ?? pathOrFile;
+    }
+    return app.vault.getAbstractFileByPath(pathOrFile.path) ?? pathOrFile;
+  }
+  const file = getFileInternal(app, pathOrFile, isCaseInsensitive);
+  if (file) {
+    return file;
+  }
+  const resolvedPath = getResolvedPath(pathOrFile);
+  if (resolvedPath === pathOrFile) {
+    return null;
+  }
+  return getFileInternal(app, resolvedPath, isCaseInsensitive);
+}
+function getFile(app, pathOrFile, shouldIncludeNonExisting, isCaseInsensitive) {
+  let file = getFileOrNull(app, pathOrFile, isCaseInsensitive);
+  if (!file) {
+    if (shouldIncludeNonExisting) {
+      file = createTFileInstance(app, pathOrFile);
+    } else {
+      throw new Error(`File not found: ${pathOrFile}`);
+    }
+  }
+  return file;
+}
+function getFileOrNull(app, pathOrFile, isCaseInsensitive) {
+  const file = getAbstractFileOrNull(app, pathOrFile, isCaseInsensitive);
+  if (isFile(file)) {
+    return file;
+  }
+  return null;
+}
+function getFileSystemType(abstractFile) {
+  if (isFile(abstractFile)) {
+    return "file" /* File */;
+  }
+  if (isFolder(abstractFile)) {
+    return "folder" /* Folder */;
+  }
+  throw new Error("Abstract file is not a file or a folder");
+}
+function getFolder(app, pathOrFolder, shouldIncludeNonExisting, isCaseInsensitive) {
+  let folder = getFolderOrNull(app, pathOrFolder, isCaseInsensitive);
+  if (!folder) {
+    if (shouldIncludeNonExisting) {
+      folder = createTFolderInstance(app, pathOrFolder);
+    } else {
+      throw new Error(`Folder not found: ${pathOrFolder}`);
+    }
+  }
+  return folder;
+}
+function getFolderOrNull(app, pathOrFolder, isCaseInsensitive) {
+  const folder = getAbstractFileOrNull(app, pathOrFolder, isCaseInsensitive);
+  if (isFolder(folder)) {
+    return folder;
+  }
+  return null;
+}
+function getMarkdownFiles(app, pathOrFolder, isRecursive) {
+  const folder = getFolder(app, pathOrFolder);
+  let markdownFiles = [];
+  if (isRecursive) {
+    Vault.recurseChildren(folder, (abstractFile) => {
+      if (isMarkdownFile(app, abstractFile) && abstractFile instanceof TFile) {
+        markdownFiles.push(abstractFile);
+      }
+    });
+  } else {
+    markdownFiles = folder.children.filter((file) => isMarkdownFile(app, file));
+  }
+  markdownFiles = markdownFiles.sort((a, b) => a.path.localeCompare(b.path));
+  return markdownFiles;
+}
+async function getOrCreateFile(app, path) {
+  const file = getFileOrNull(app, path);
+  if (file) {
+    return file;
+  }
+  const folderPath = parentFolderPath(path);
+  await getOrCreateFolder(app, folderPath);
+  return await app.vault.create(path, "");
+}
+async function getOrCreateFolder(app, path) {
+  const folder = getFolderOrNull(app, path);
+  if (folder) {
+    return folder;
+  }
+  return await app.vault.createFolder(path);
+}
+function getPath(app, pathOrFile) {
+  if (isAbstractFile(pathOrFile)) {
+    return pathOrFile.path;
+  }
+  const file = getAbstractFileOrNull(app, pathOrFile);
+  if (file) {
+    return file.path;
+  }
+  return getResolvedPath(pathOrFile);
+}
+function isAbstractFile(file) {
+  return file instanceof TAbstractFile;
+}
+function isBaseFile(app, pathOrFile) {
+  return checkExtension(app, pathOrFile, BASE_FILE_EXTENSION);
+}
+function isCanvasFile(app, pathOrFile) {
+  return checkExtension(app, pathOrFile, CANVAS_FILE_EXTENSION);
+}
+function isFile(file) {
+  return file instanceof TFile;
+}
+function isFolder(file) {
+  return file instanceof TFolder;
+}
+function isMarkdownFile(app, pathOrFile) {
+  return checkExtension(app, pathOrFile, MARKDOWN_FILE_EXTENSION);
+}
+function isNote(app, pathOrFile) {
+  return isMarkdownFile(app, pathOrFile) || isCanvasFile(app, pathOrFile) || isBaseFile(app, pathOrFile);
+}
+function trimMarkdownExtension(app, file) {
+  if (!isMarkdownFile(app, file)) {
+    return file.path;
+  }
+  return trimEnd(file.path, `.${MARKDOWN_FILE_EXTENSION}`);
+}
+function getFileInternal(app, path, isCaseInsensitive) {
+  isCaseInsensitive ??= getDataAdapterEx(app).insensitive;
+  if (isCaseInsensitive) {
+    return app.vault.getAbstractFileByPathInsensitive(path);
+  }
+  return app.vault.getAbstractFileByPath(path);
+}
+function getResolvedPath(path) {
+  return normalizePath(resolve("/", path));
+}
+export {
+  BASE_FILE_EXTENSION,
+  CANVAS_FILE_EXTENSION,
+  FileSystemType,
+  MARKDOWN_FILE_EXTENSION,
+  asArrayOfFiles,
+  asArrayOfFolders,
+  asFile,
+  asFileOrNull,
+  asFolder,
+  asFolderOrNull,
+  checkExtension,
+  exists,
+  getAbstractFile,
+  getAbstractFileOrNull,
+  getFile,
+  getFileOrNull,
+  getFileSystemType,
+  getFolder,
+  getFolderOrNull,
+  getMarkdownFiles,
+  getOrCreateFile,
+  getOrCreateFolder,
+  getPath,
+  isAbstractFile,
+  isBaseFile,
+  isCanvasFile,
+  isFile,
+  isFolder,
+  isMarkdownFile,
+  isNote,
+  trimMarkdownExtension
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/file-system.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * This module provides utility functions for working with {@link TAbstractFile}, {@link TFile}, and {@link TFolder} instances in Obsidian.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  normalizePath,\n  TAbstractFile,\n  TFile,\n  TFolder,\n  Vault\n} from 'obsidian';\nimport {\n  createTFileInstance,\n  createTFolderInstance,\n  getDataAdapterEx,\n  parentFolderPath\n} from 'obsidian-typings/implementations';\n\nimport {\n  extname,\n  resolve\n} from '../path.ts';\nimport { trimEnd } from '../string.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\n\n/**\n * A file extension for `base` files.\n */\nexport const BASE_FILE_EXTENSION = 'base';\n\n/**\n * A file extension for `canvas` files.\n */\nexport const CANVAS_FILE_EXTENSION = 'canvas';\n\n/**\n * A file extension for `markdown` files.\n */\nexport const MARKDOWN_FILE_EXTENSION = 'md';\n\n/**\n * A type of file system object.\n */\nexport enum FileSystemType {\n  /**\n   * A file.\n   */\n  File = 'file',\n  /**\n   * A folder.\n   */\n  Folder = 'folder'\n}\n\n/**\n * A path or an abstract file.\n */\nexport type PathOrAbstractFile = string | TAbstractFile;\n\n/**\n * A path or a file.\n */\nexport type PathOrFile = string | TFile;\n\n/**\n * A path or a folder.\n */\nexport type PathOrFolder = string | TFolder;\n\n/**\n * Converts an array of abstract files to an array of files.\n *\n * @param abstractFiles - The abstract files to convert.\n * @returns The array of files.\n * @throws Error if any of the abstract files are not files.\n */\nexport function asArrayOfFiles(abstractFiles: TAbstractFile[]): TFile[] {\n  return abstractFiles.map((abstractFile) => asFile(abstractFile));\n}\n\n/**\n * Converts an array of abstract files to an array of folders.\n *\n * @param abstractFiles - The abstract files to convert.\n * @returns The array of folders.\n * @throws Error if any of the abstract files are not folders.\n */\nexport function asArrayOfFolders(abstractFiles: TAbstractFile[]): TFolder[] {\n  return abstractFiles.map((abstractFile) => asFolder(abstractFile));\n}\n\n/**\n * Converts an abstract file to a file.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The file.\n * @throws Error if the abstract file is not a file.\n */\nexport function asFile(abstractFile: null | TAbstractFile): TFile {\n  return ensureNonNullable(asFileOrNull(abstractFile), 'Abstract file is not a file');\n}\n\n/**\n * Converts an abstract file to a file or `null`.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The file or `null`.\n * @throws Error if the abstract file is not a file.\n */\nexport function asFileOrNull(abstractFile: null | TAbstractFile): null | TFile {\n  if (abstractFile === null) {\n    return null;\n  }\n  if (abstractFile instanceof TFile) {\n    return abstractFile;\n  }\n  throw new Error('Abstract file is not a file');\n}\n\n/**\n * Converts an abstract file to a folder.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The folder.\n * @throws Error if the abstract file is not a folder.\n */\nexport function asFolder(abstractFile: null | TAbstractFile): TFolder {\n  return ensureNonNullable(asFolderOrNull(abstractFile), 'Abstract file is not a folder');\n}\n\n/**\n * Converts an abstract file to a folder or `null`.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The folder or `null`.\n * @throws Error if the abstract file is not a folder.\n */\nexport function asFolderOrNull(abstractFile: null | TAbstractFile): null | TFolder {\n  if (abstractFile === null) {\n    return null;\n  }\n  if (abstractFile instanceof TFolder) {\n    return abstractFile;\n  }\n  throw new Error('Abstract file is not a folder');\n}\n\n/**\n * Checks if the given path or file has the specified extension.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or abstract file to check.\n * @param extension - The extension to compare against.\n * @returns Returns `true` if the path or file has the specified extension, `false` otherwise.\n */\nexport function checkExtension(app: App, pathOrFile: null | PathOrAbstractFile, extension: string): boolean {\n  if (isFile(pathOrFile)) {\n    return pathOrFile.extension === extension;\n  }\n\n  if (typeof pathOrFile === 'string') {\n    const file = getFileOrNull(app, pathOrFile);\n    if (file) {\n      return file.extension === extension;\n    }\n\n    return extname(pathOrFile).slice(1) === extension;\n  }\n\n  return false;\n}\n\n/**\n * Checks if the given path exists.\n *\n * @param app - The Obsidian App instance.\n * @param path - The path to check.\n * @param type - The type of the file system object to check. Default is `undefined`.\n * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `undefined`.\n * @returns `true` if the path exists, `false` otherwise.\n */\nexport function exists(app: App, path: string, type?: FileSystemType, isCaseInsensitive?: boolean): boolean {\n  const abstractFile = getAbstractFileOrNull(app, path, isCaseInsensitive);\n  if (!abstractFile) {\n    return false;\n  }\n\n  if (type === undefined) {\n    return true;\n  }\n\n  return getFileSystemType(abstractFile) === type;\n}\n\n/**\n * Retrieves the TAbstractFile object for the given path or abstract file.\n *\n * @param app - The App instance.\n * @param pathOrFile - The path or abstract file to retrieve the abstract file for.\n * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.\n * @returns The abstract file.\n * @throws Error if the abstract file is not found.\n */\nexport function getAbstractFile(app: App, pathOrFile: PathOrAbstractFile, isCaseInsensitive?: boolean): TAbstractFile {\n  return ensureNonNullable(getAbstractFileOrNull(app, pathOrFile, isCaseInsensitive), `Abstract file not found: ${pathOrFile as string}`);\n}\n\n/**\n * Retrieves an abstract file or `null` based on the provided path or abstract file.\n *\n * @param app - The application instance.\n * @param pathOrFile - The path or abstract file to retrieve.\n * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.\n * @returns The abstract file if found, otherwise `null`.\n */\nexport function getAbstractFileOrNull(app: App, pathOrFile: null | PathOrAbstractFile, isCaseInsensitive?: boolean): null | TAbstractFile {\n  if (pathOrFile === null) {\n    return null;\n  }\n\n  if (isAbstractFile(pathOrFile)) {\n    if (isFile(pathOrFile)) {\n      return app.vault.getFileByPath(pathOrFile.path) ?? pathOrFile;\n    }\n    /* v8 ignore start -- TAbstractFile is always TFile or TFolder in Obsidian; defensive fallback. */\n    if (isFolder(pathOrFile)) {\n      return app.vault.getFolderByPath(pathOrFile.path) ?? pathOrFile;\n    }\n    /* v8 ignore stop */\n    /* v8 ignore start -- TAbstractFile is always TFile or TFolder in Obsidian; defensive fallback. */\n    return app.vault.getAbstractFileByPath(pathOrFile.path) ?? pathOrFile;\n    /* v8 ignore stop */\n  }\n\n  const file = getFileInternal(app, pathOrFile, isCaseInsensitive);\n\n  if (file) {\n    return file;\n  }\n\n  const resolvedPath = getResolvedPath(pathOrFile);\n\n  if (resolvedPath === pathOrFile) {\n    return null;\n  }\n\n  return getFileInternal(app, resolvedPath, isCaseInsensitive);\n}\n\n/**\n * Retrieves a file based on the provided path or file.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or file to retrieve the file for.\n * @param shouldIncludeNonExisting - Whether to include a non-existing file.\n *  If `true`, a new file is created for the provided path.\n *  If `false`, an error is thrown if the file is not found.\n * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.\n * @returns The file corresponding to the provided path or file.\n * @throws Error if the file is not found.\n */\nexport function getFile(app: App, pathOrFile: PathOrFile, shouldIncludeNonExisting?: boolean, isCaseInsensitive?: boolean): TFile {\n  let file = getFileOrNull(app, pathOrFile, isCaseInsensitive);\n  if (!file) {\n    if (shouldIncludeNonExisting) {\n      file = createTFileInstance(app, pathOrFile as string);\n    } else {\n      throw new Error(`File not found: ${pathOrFile as string}`);\n    }\n  }\n\n  return file;\n}\n\n/**\n * Retrieves a file or `null` based on the provided path or file.\n * If the provided argument is already a file, it is returned as is.\n * Otherwise, the function uses the app's vault to retrieve the file by its path.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or file.\n * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.\n * @returns The file if found, otherwise `null`.\n */\nexport function getFileOrNull(app: App, pathOrFile: null | PathOrFile, isCaseInsensitive?: boolean): null | TFile {\n  const file = getAbstractFileOrNull(app, pathOrFile, isCaseInsensitive);\n  if (isFile(file)) {\n    return file;\n  }\n  return null;\n}\n\n/**\n * Gets the type of a file system object.\n *\n * @param abstractFile - The abstract file to get the type of.\n * @returns The type of the abstract file.\n * @throws Error if the abstract file is not a file or a folder.\n */\nexport function getFileSystemType(abstractFile: TAbstractFile): FileSystemType {\n  if (isFile(abstractFile)) {\n    return FileSystemType.File;\n  }\n  if (isFolder(abstractFile)) {\n    return FileSystemType.Folder;\n  }\n  throw new Error('Abstract file is not a file or a folder');\n}\n\n/**\n * Retrieves a folder based on the provided app and pathOrFolder.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFolder - The path or folder identifier.\n * @param shouldIncludeNonExisting - Whether to allow the folder to not exist.\n *  If `true`, a new folder is created for the provided path.\n *  If `false`, an error is thrown if the folder is not found.\n * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.\n * @returns The retrieved folder.\n * @throws If the folder is not found.\n */\nexport function getFolder(app: App, pathOrFolder: PathOrFolder, shouldIncludeNonExisting?: boolean, isCaseInsensitive?: boolean): TFolder {\n  let folder = getFolderOrNull(app, pathOrFolder, isCaseInsensitive);\n  if (!folder) {\n    if (shouldIncludeNonExisting) {\n      folder = createTFolderInstance(app, pathOrFolder as string);\n    } else {\n      throw new Error(`Folder not found: ${pathOrFolder as string}`);\n    }\n  }\n\n  return folder;\n}\n\n/**\n * Retrieves a folder or `null` based on the provided path or folder.\n *\n * @param app - The Obsidian application instance.\n * @param pathOrFolder - The path or folder to retrieve the folder from.\n * @param isCaseInsensitive - Specifies whether to perform a case-insensitive search. Default is `false`.\n * @returns The folder if found, otherwise `null`.\n */\nexport function getFolderOrNull(app: App, pathOrFolder: null | PathOrFolder, isCaseInsensitive?: boolean): null | TFolder {\n  const folder = getAbstractFileOrNull(app, pathOrFolder, isCaseInsensitive);\n  if (isFolder(folder)) {\n    return folder;\n  }\n  return null;\n}\n\n/**\n * Retrieves an array of files representing the markdown files within a specified folder or path.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFolder - The path or folder to retrieve the markdown files from.\n * @param isRecursive - Optional. Specifies whether to recursively search for markdown files within subfolders. Default is `false`.\n * @returns An array of files representing the markdown files.\n */\nexport function getMarkdownFiles(app: App, pathOrFolder: PathOrFolder, isRecursive?: boolean): TFile[] {\n  const folder = getFolder(app, pathOrFolder);\n\n  let markdownFiles: TFile[] = [];\n\n  if (isRecursive) {\n    Vault.recurseChildren(folder, (abstractFile) => {\n      if (isMarkdownFile(app, abstractFile) && abstractFile instanceof TFile) {\n        markdownFiles.push(abstractFile);\n      }\n    });\n  } else {\n    markdownFiles = folder.children.filter((file) => isMarkdownFile(app, file)) as TFile[];\n  }\n\n  markdownFiles = markdownFiles.sort((a, b) => a.path.localeCompare(b.path));\n  return markdownFiles;\n}\n\n/**\n * Retrieves the file for the given path or creates a new one if it does not exist.\n *\n * @param app - The Obsidian App instance.\n * @param path - The path of the file to retrieve or create.\n * @returns The file representing the file\n */\nexport async function getOrCreateFile(app: App, path: string): Promise<TFile> {\n  const file = getFileOrNull(app, path);\n  if (file) {\n    return file;\n  }\n\n  const folderPath = parentFolderPath(path);\n  await getOrCreateFolder(app, folderPath);\n\n  return await app.vault.create(path, '');\n}\n\n/**\n * Retrieves the folder for the given path or creates a new one if it does not exist.\n *\n * @param app - The Obsidian App instance.\n * @param path - The path of the folder to retrieve or create.\n * @returns The folder representing the folder.\n */\nexport async function getOrCreateFolder(app: App, path: string): Promise<TFolder> {\n  const folder = getFolderOrNull(app, path);\n  if (folder) {\n    return folder;\n  }\n\n  return await app.vault.createFolder(path);\n}\n\n/**\n * Returns the path of the given `pathOrFile`.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or abstract file.\n * @returns The path of the `pathOrFile`.\n */\nexport function getPath(app: App, pathOrFile: PathOrAbstractFile): string {\n  if (isAbstractFile(pathOrFile)) {\n    return pathOrFile.path;\n  }\n\n  const file = getAbstractFileOrNull(app, pathOrFile);\n  if (file) {\n    return file.path;\n  }\n\n  return getResolvedPath(pathOrFile);\n}\n\n/**\n * Checks if the given file is an instance of abstract file.\n *\n * @param file - The file to check.\n * @returns A boolean indicating whether the file is an instance of abstract file.\n */\nexport function isAbstractFile(file: unknown): file is TAbstractFile {\n  return file instanceof TAbstractFile;\n}\n\n/**\n *   Checks if the given file is a base file.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a base file.\n */\nexport function isBaseFile(app: App, pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(app, pathOrFile, BASE_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is a canvas file.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a canvas file or not.\n */\nexport function isCanvasFile(app: App, pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(app, pathOrFile, CANVAS_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is an instance of file.\n *\n * @param file - The file to check.\n * @returns A boolean indicating whether the file is an instance of file.\n */\nexport function isFile(file: unknown): file is TFile {\n  return file instanceof TFile;\n}\n\n/**\n * Checks if the given file is a folder.\n *\n * @param file - The file to check.\n * @returns `true` if the file is a folder, `false` otherwise.\n */\nexport function isFolder(file: unknown): file is TFolder {\n  return file instanceof TFolder;\n}\n\n/**\n * Checks if the given file is a Markdown file.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a Markdown file.\n */\nexport function isMarkdownFile(app: App, pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(app, pathOrFile, MARKDOWN_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is a note.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a note.\n */\nexport function isNote(app: App, pathOrFile: null | PathOrAbstractFile): boolean {\n  return isMarkdownFile(app, pathOrFile) || isCanvasFile(app, pathOrFile) || isBaseFile(app, pathOrFile);\n}\n\n/**\n * Trims the markdown extension from the file path if the file is a markdown file.\n * If the file is not a markdown file, the original file path is returned.\n *\n * @param app - The Obsidian App instance.\n * @param file - The file to trim the markdown extension from.\n * @returns The file path with the markdown extension trimmed.\n */\nexport function trimMarkdownExtension(app: App, file: TAbstractFile): string {\n  if (!isMarkdownFile(app, file)) {\n    return file.path;\n  }\n\n  return trimEnd(file.path, `.${MARKDOWN_FILE_EXTENSION}`);\n}\n\nfunction getFileInternal(app: App, path: string, isCaseInsensitive?: boolean): null | TAbstractFile {\n  isCaseInsensitive ??= getDataAdapterEx(app).insensitive;\n  if (isCaseInsensitive) {\n    return app.vault.getAbstractFileByPathInsensitive(path);\n  }\n\n  return app.vault.getAbstractFileByPath(path) as null | TFile;\n}\n\nfunction getResolvedPath(path: string): string {\n  return normalizePath(resolve('/', path));\n}\n"],
  "mappings": "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",
  "names": ["FileSystemType"]
}


package/dist/lib/esm/obsidian/frontmatter-link-cache-with-offsets.mjs

@@ -0,0 +1,44 @@
+/*
+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 { isFrontmatterLinkCache } from "obsidian-typings/implementations";
+function isFrontmatterLinkCacheWithOffsets(reference) {
+  if (!isFrontmatterLinkCache(reference)) {
+    return false;
+  }
+  const frontmatterLinkCacheWithOffsets = reference;
+  return frontmatterLinkCacheWithOffsets.startOffset !== void 0 && frontmatterLinkCacheWithOffsets.endOffset !== void 0;
+}
+function toFrontmatterLinkCacheWithOffsets(reference) {
+  if (isFrontmatterLinkCacheWithOffsets(reference)) {
+    return reference;
+  }
+  return {
+    ...reference,
+    endOffset: reference.original.length,
+    startOffset: 0
+  };
+}
+export {
+  isFrontmatterLinkCacheWithOffsets,
+  toFrontmatterLinkCacheWithOffsets
+};
+//# sourceMappingURL=data:application/json;base64,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