@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

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

@@ -0,0 +1,458 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { normalizeOptionalProperties } from "@mnaoumov/typescript-lib/object-utils";
+import {
+  basename,
+  extname,
+  resolve
+} from "@mnaoumov/typescript-lib/path";
+import { trimEnd } from "@mnaoumov/typescript-lib/string";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  createTFileInstance,
+  createTFolderInstance,
+  getDataAdapterEx,
+  parentFolderPath
+} from "@obsidian-typings/obsidian-public-latest/implementations";
+import {
+  normalizePath,
+  TAbstractFile,
+  TFile,
+  TFolder,
+  Vault
+} from "obsidian";
+import { getCaseInsensitiveFileIndex } from "./case-insensitive-file-index.mjs";
+import {
+  checkPropertyEntryMatches,
+  isPropertyEntry
+} from "./property-entry.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 || {});
+var MissingPathTreatment = /* @__PURE__ */ ((MissingPathTreatment2) => {
+  MissingPathTreatment2["File"] = "file";
+  MissingPathTreatment2["Folder"] = "folder";
+  MissingPathTreatment2["Throw"] = "throw";
+  return MissingPathTreatment2;
+})(MissingPathTreatment || {});
+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(pathOrFile, extension) {
+  return isFile(pathOrFile) ? pathOrFile.extension === extension : typeof pathOrFile === "string" && extname(pathOrFile).slice(1).toLowerCase() === extension;
+}
+function doesExist(params) {
+  const {
+    app,
+    isCaseInsensitive,
+    path,
+    type
+  } = params;
+  const abstractFile = getAbstractFileOrNull(normalizeOptionalProperties({
+    app,
+    isCaseInsensitive,
+    pathOrFile: path
+  }));
+  return abstractFile !== null && (type === void 0 || getFileSystemType(abstractFile) === type);
+}
+function getAbstractFile(params) {
+  const {
+    app,
+    isCaseInsensitive,
+    pathOrFile
+  } = params;
+  return ensureNonNullable(
+    getAbstractFileOrNull(normalizeOptionalProperties({
+      app,
+      isCaseInsensitive,
+      pathOrFile
+    })),
+    `Abstract file not found: ${pathOrFile}`
+  );
+}
+function getAbstractFileOrNull(params) {
+  const {
+    app,
+    isCaseInsensitive,
+    pathOrFile
+  } = params;
+  if (pathOrFile === null) {
+    return null;
+  }
+  if (isAbstractFile(pathOrFile)) {
+    if (isFile(pathOrFile)) {
+      return app.vault.getFileByPath(pathOrFile.path) ?? pathOrFile;
+    }
+    return isFolder(pathOrFile) ? app.vault.getFolderByPath(pathOrFile.path) ?? pathOrFile : app.vault.getAbstractFileByPath(pathOrFile.path) ?? pathOrFile;
+  }
+  const file = getFileInternal(normalizeOptionalProperties({
+    app,
+    isCaseInsensitive,
+    path: pathOrFile
+  }));
+  if (file) {
+    return file;
+  }
+  const resolvedPath = getResolvedPath(pathOrFile);
+  return resolvedPath === pathOrFile ? null : getFileInternal(normalizeOptionalProperties({
+    app,
+    isCaseInsensitive,
+    path: resolvedPath
+  }));
+}
+function getBasename(params) {
+  const {
+    app,
+    pathOrFile,
+    whenMissingTreatAs
+  } = params;
+  const abstractFile = getAbstractFileOrNull({
+    app,
+    pathOrFile
+  });
+  if (isFile(abstractFile)) {
+    return abstractFile.basename;
+  }
+  if (isFolder(abstractFile)) {
+    return abstractFile.name;
+  }
+  const path = getPath(app, pathOrFile);
+  const treatment = whenMissingTreatAs ?? "throw" /* Throw */;
+  if (treatment === "throw" /* Throw */) {
+    throw new Error(`Abstract file not found: ${path}`);
+  }
+  return treatment === "folder" /* Folder */ ? basename(path) : basename(path, extname(path));
+}
+function getExtension(params) {
+  const {
+    app,
+    pathOrFile,
+    whenMissingTreatAs
+  } = params;
+  const abstractFile = getAbstractFileOrNull({
+    app,
+    pathOrFile
+  });
+  if (isFile(abstractFile)) {
+    return abstractFile.extension;
+  }
+  if (isFolder(abstractFile)) {
+    return "";
+  }
+  const path = getPath(app, pathOrFile);
+  const treatment = whenMissingTreatAs ?? "throw" /* Throw */;
+  if (treatment === "throw" /* Throw */) {
+    throw new Error(`Abstract file not found: ${path}`);
+  }
+  return treatment === "folder" /* Folder */ ? "" : extname(path).slice(1).toLowerCase();
+}
+function getFile(params) {
+  const {
+    app,
+    isCaseInsensitive,
+    pathOrFile,
+    shouldIncludeNonExisting
+  } = params;
+  let file = getFileOrNull(normalizeOptionalProperties({
+    app,
+    isCaseInsensitive,
+    pathOrFile
+  }));
+  if (!file) {
+    if (shouldIncludeNonExisting) {
+      file = createTFileInstance(app, pathOrFile);
+    } else {
+      throw new Error(`File not found: ${pathOrFile}`);
+    }
+  }
+  return file;
+}
+function getFileOrNull(params) {
+  const {
+    app,
+    isCaseInsensitive,
+    pathOrFile
+  } = params;
+  const file = getAbstractFileOrNull(normalizeOptionalProperties({
+    app,
+    isCaseInsensitive,
+    pathOrFile
+  }));
+  return isFile(file) ? file : 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(params) {
+  const {
+    app,
+    isCaseInsensitive,
+    pathOrFolder,
+    shouldIncludeNonExisting
+  } = params;
+  let folder = getFolderOrNull(normalizeOptionalProperties({
+    app,
+    isCaseInsensitive,
+    pathOrFolder
+  }));
+  if (!folder) {
+    if (shouldIncludeNonExisting) {
+      folder = createTFolderInstance(app, pathOrFolder);
+    } else {
+      throw new Error(`Folder not found: ${pathOrFolder}`);
+    }
+  }
+  return folder;
+}
+function getFolderOrNull(params) {
+  const {
+    app,
+    isCaseInsensitive,
+    pathOrFolder
+  } = params;
+  const folder = getAbstractFileOrNull(normalizeOptionalProperties({
+    app,
+    isCaseInsensitive,
+    pathOrFile: pathOrFolder
+  }));
+  return isFolder(folder) ? folder : null;
+}
+function getMarkdownFiles(params) {
+  const {
+    app,
+    isRecursive,
+    pathOrFolder
+  } = params;
+  const folder = getFolder({
+    app,
+    pathOrFolder
+  });
+  let markdownFiles = [];
+  if (isRecursive) {
+    Vault.recurseChildren(folder, (abstractFile) => {
+      if (isMarkdownFile(abstractFile) && abstractFile instanceof TFile) {
+        markdownFiles.push(abstractFile);
+      }
+    });
+  } else {
+    markdownFiles = folder.children.filter((file) => isMarkdownFile(file));
+  }
+  markdownFiles = markdownFiles.sort((a, b) => a.path.localeCompare(b.path));
+  return markdownFiles;
+}
+async function getOrCreateFile(app, path) {
+  const file = getFileOrNull({
+    app,
+    pathOrFile: 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,
+    pathOrFolder: path
+  });
+  return folder ?? await app.vault.createFolder(path);
+}
+function getPath(app, pathOrFile) {
+  if (isAbstractFile(pathOrFile)) {
+    return pathOrFile.path;
+  }
+  const file = getAbstractFileOrNull({
+    app,
+    pathOrFile
+  });
+  return file ? file.path : getResolvedPath(pathOrFile);
+}
+function isAbstractFile(file) {
+  return file instanceof TAbstractFile;
+}
+function isBaseFile(pathOrFile) {
+  return checkExtension(pathOrFile, BASE_FILE_EXTENSION);
+}
+function isCanvasFile(pathOrFile) {
+  return checkExtension(pathOrFile, CANVAS_FILE_EXTENSION);
+}
+function isFile(file) {
+  return file instanceof TFile;
+}
+function isFolder(file) {
+  return file instanceof TFolder;
+}
+function isMarkdownFile(pathOrFile) {
+  return checkExtension(pathOrFile, MARKDOWN_FILE_EXTENSION);
+}
+function isNote(pathOrFile) {
+  return isMarkdownFile(pathOrFile) || isCanvasFile(pathOrFile) || isBaseFile(pathOrFile);
+}
+function isTreatedAsAttachment(params) {
+  const {
+    app,
+    attachmentExtensions,
+    pathOrFile
+  } = params;
+  if (pathOrFile === null || isFolder(pathOrFile)) {
+    return false;
+  }
+  const lowerCaseName = getName(pathOrFile).toLowerCase();
+  return attachmentExtensions.some((extension) => {
+    const trimmedEntry = extension.trim();
+    if (isPropertyEntry(trimmedEntry)) {
+      return !!app && isMarkdownFile(pathOrFile) && checkPropertyEntryMatches({
+        entry: trimmedEntry,
+        frontmatter: getCachedFrontmatter({ app, pathOrFile })
+      });
+    }
+    const normalizedExtension = extension.trim().replace(/^\.+/, "").toLowerCase();
+    return normalizedExtension !== "" && lowerCaseName.endsWith(`.${normalizedExtension}`);
+  });
+}
+function trimMarkdownExtension(file) {
+  return isMarkdownFile(file) ? trimEnd({
+    $string: file.path,
+    suffix: `.${MARKDOWN_FILE_EXTENSION}`
+  }) : file.path;
+}
+function getCachedFrontmatter(params) {
+  const file = getAbstractFileOrNull(params);
+  return isFile(file) ? params.app.metadataCache.getFileCache(file)?.frontmatter ?? null : null;
+}
+function getFileInternal(params) {
+  const {
+    app,
+    path
+  } = params;
+  let { isCaseInsensitive } = params;
+  isCaseInsensitive ??= getDataAdapterEx(app).insensitive;
+  if (isCaseInsensitive) {
+    const caseInsensitiveFileIndex = getCaseInsensitiveFileIndex(app);
+    return caseInsensitiveFileIndex ? caseInsensitiveFileIndex.get(path) : app.vault.getAbstractFileByPathInsensitive(path);
+  }
+  return app.vault.getAbstractFileByPath(path);
+}
+function getName(pathOrFile) {
+  return isAbstractFile(pathOrFile) ? pathOrFile.name : basename(pathOrFile);
+}
+function getResolvedPath(path) {
+  return normalizePath(resolve("/", path));
+}
+export {
+  BASE_FILE_EXTENSION,
+  CANVAS_FILE_EXTENSION,
+  FileSystemType,
+  MARKDOWN_FILE_EXTENSION,
+  MissingPathTreatment,
+  asArrayOfFiles,
+  asArrayOfFolders,
+  asFile,
+  asFileOrNull,
+  asFolder,
+  asFolderOrNull,
+  checkExtension,
+  doesExist,
+  getAbstractFile,
+  getAbstractFileOrNull,
+  getBasename,
+  getExtension,
+  getFile,
+  getFileOrNull,
+  getFileSystemType,
+  getFolder,
+  getFolderOrNull,
+  getMarkdownFiles,
+  getOrCreateFile,
+  getOrCreateFolder,
+  getPath,
+  isAbstractFile,
+  isBaseFile,
+  isCanvasFile,
+  isFile,
+  isFolder,
+  isMarkdownFile,
+  isNote,
+  isTreatedAsAttachment,
+  trimMarkdownExtension
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/file-system.ts"],
  "sourcesContent": ["/**\n * @file\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 { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  basename,\n  extname,\n  resolve\n} from '@mnaoumov/typescript-lib/path';\nimport { trimEnd } from '@mnaoumov/typescript-lib/string';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport {\n  createTFileInstance,\n  createTFolderInstance,\n  getDataAdapterEx,\n  parentFolderPath\n} from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  normalizePath,\n  TAbstractFile,\n  TFile,\n  TFolder,\n  Vault\n} from 'obsidian';\n\nimport { getCaseInsensitiveFileIndex } from './case-insensitive-file-index.ts';\nimport {\n  checkPropertyEntryMatches,\n  isPropertyEntry\n} from './property-entry.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 * How {@link getBasename} and {@link getExtension} should answer for a path that resolves to nothing in the vault.\n *\n * Nothing in the vault says whether an unresolved `alpha.bravo` names a dotted folder or a `.bravo` file, so the caller decides.\n */\nexport enum MissingPathTreatment {\n  /**\n   * Read the path as a file path: `alpha.bravo` is basename `alpha` plus extension `bravo`.\n   */\n  File = 'file',\n  /**\n   * Read the path as a folder path: `alpha.bravo` is basename `alpha.bravo` with no extension.\n   */\n  Folder = 'folder',\n  /**\n   * Throw instead of guessing. This is the default.\n   */\n  Throw = 'throw'\n}\n\n/**\n * Parameters for {@link doesExist}.\n */\nexport interface DoesExistParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path to check.\n   */\n  readonly path: string;\n\n  /**\n   * The type of the file system object to check. Default is `undefined`.\n   */\n  readonly type?: FileSystemType;\n}\n\n/**\n * Parameters for {@link getAbstractFileOrNull}.\n */\nexport interface GetAbstractFileOrNullParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or abstract file to retrieve.\n   */\n  readonly pathOrFile: null | PathOrAbstractFile;\n}\n\n/**\n * Parameters for {@link getAbstractFile}.\n */\nexport interface GetAbstractFileParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or abstract file to retrieve the abstract file for.\n   */\n  readonly pathOrFile: PathOrAbstractFile;\n}\n\n/**\n * Parameters for {@link getBasename}.\n */\nexport interface GetBasenameParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path or abstract file to get the base name of.\n   */\n  readonly pathOrFile: PathOrAbstractFile;\n\n  /**\n   * How to answer when the path resolves to nothing in the vault.\n   *\n   * @default `MissingPathTreatment.Throw`\n   */\n  readonly whenMissingTreatAs?: MissingPathTreatment;\n}\n\n/**\n * Parameters for {@link getExtension}.\n */\nexport interface GetExtensionParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path or abstract file to get the extension of.\n   */\n  readonly pathOrFile: PathOrAbstractFile;\n\n  /**\n   * How to answer when the path resolves to nothing in the vault.\n   *\n   * @default `MissingPathTreatment.Throw`\n   */\n  readonly whenMissingTreatAs?: MissingPathTreatment;\n}\n\n/**\n * Parameters for {@link getFileOrNull}.\n */\nexport interface GetFileOrNullParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or file.\n   */\n  readonly pathOrFile: null | PathOrFile;\n}\n\n/**\n * Parameters for {@link getFile}.\n */\nexport interface GetFileParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or file to retrieve the file for.\n   */\n  readonly pathOrFile: PathOrFile;\n\n  /**\n   * 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   *\n   * @default `false`\n   */\n  readonly shouldIncludeNonExisting?: boolean;\n}\n\n/**\n * Parameters for {@link getFolderOrNull}.\n */\nexport interface GetFolderOrNullParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or folder to retrieve the folder from.\n   */\n  readonly pathOrFolder: null | PathOrFolder;\n}\n\n/**\n * Parameters for {@link getFolder}.\n */\nexport interface GetFolderParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or folder identifier.\n   */\n  readonly pathOrFolder: PathOrFolder;\n\n  /**\n   * 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   *\n   * @default `false`\n   */\n  readonly shouldIncludeNonExisting?: boolean;\n}\n\n/**\n * Parameters for {@link getMarkdownFiles}.\n */\nexport interface GetMarkdownFilesParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to recursively search for markdown files within subfolders. Default is `false`.\n   *\n   * @default `false`\n   */\n  readonly isRecursive?: boolean;\n\n  /**\n   * The path or folder to retrieve the markdown files from.\n   */\n  readonly pathOrFolder: PathOrFolder;\n}\n\n/**\n * Parameters for {@link isTreatedAsAttachment}.\n */\nexport interface IsTreatedAsAttachmentParams {\n  /**\n   * The Obsidian app instance, which lets a `property:` entry of {@link attachmentExtensions} read the file's frontmatter from the metadata cache.\n   * Without it, `property:` entries match nothing and only the extension entries are evaluated.\n   */\n  readonly app?: App;\n\n  /**\n   * The entries that mark a file as an attachment, e.g. `['.excalidraw.md', 'property:excalidraw-plugin']`.\n   *\n   * An extension entry is normalized before matching: surrounding whitespace is trimmed, a single leading dot is enforced, and the comparison is\n   * case-insensitive. Empty entries are ignored.\n   *\n   * A `property:name` entry matches a markdown file whose frontmatter has `name`, and `property:name=value` one whose `name` renders as `value` \u2014 the\n   * same syntax note priorities use. It is evaluated only when {@link app} is given.\n   */\n  readonly attachmentExtensions: readonly string[];\n\n  /**\n   * The path or file to classify.\n   */\n  readonly pathOrFile: null | PathOrAbstractFile;\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 * Parameters for {@link getCachedFrontmatter}.\n */\ninterface GetCachedFrontmatterParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path or file whose frontmatter to read.\n   */\n  readonly pathOrFile: PathOrAbstractFile;\n}\n\n/**\n * Parameters for {@link getFileInternal}.\n */\ninterface GetFileInternalParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path to retrieve the abstract file for.\n   */\n  readonly path: string;\n}\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 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(pathOrFile: null | PathOrAbstractFile, extension: string): boolean {\n  // For a string path, compare the path's own extension instead of resolving the file.\n  // Resolving a string path is O(vault) on a miss on a case-insensitive filesystem.\n  // That miss is the hot path during deletion cascades.\n  // Obsidian lowercases a file's canonical extension, so compare case-insensitively.\n  return isFile(pathOrFile) ? pathOrFile.extension === extension : typeof pathOrFile === 'string' && extname(pathOrFile).slice(1).toLowerCase() === extension;\n}\n\n/**\n * Checks if the given path exists.\n *\n * @param params - The parameters for the check.\n * @returns `true` if the path exists, `false` otherwise.\n */\nexport function doesExist(params: DoesExistParams): boolean {\n  const {\n    app,\n    isCaseInsensitive,\n    path,\n    type\n  } = params;\n  const abstractFile = getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile: path\n  }));\n  return abstractFile !== null && (type === undefined || getFileSystemType(abstractFile) === type);\n}\n\n/**\n * Retrieves the TAbstractFile object for the given path or abstract file.\n *\n * @param params - The parameters for the retrieval.\n * @returns The abstract file.\n * @throws Error if the abstract file is not found.\n */\nexport function getAbstractFile(params: GetAbstractFileParams): TAbstractFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  } = params;\n  return ensureNonNullable(\n    getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n      app,\n      isCaseInsensitive,\n      pathOrFile\n    })),\n    `Abstract file not found: ${pathOrFile as string}`\n  );\n}\n\n/**\n * Retrieves an abstract file or `null` based on the provided path or abstract file.\n *\n * @param params - The parameters for the retrieval.\n * @returns The abstract file if found, otherwise `null`.\n */\nexport function getAbstractFileOrNull(params: GetAbstractFileOrNullParams): null | TAbstractFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  } = params;\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    return isFolder(pathOrFile) ? (app.vault.getFolderByPath(pathOrFile.path) ?? pathOrFile) : (app.vault.getAbstractFileByPath(pathOrFile.path) ?? pathOrFile);\n    /* v8 ignore stop */\n  }\n\n  const file = getFileInternal(normalizeOptionalProperties<GetFileInternalParams>({\n    app,\n    isCaseInsensitive,\n    path: pathOrFile\n  }));\n\n  if (file) {\n    return file;\n  }\n\n  const resolvedPath = getResolvedPath(pathOrFile);\n\n  return resolvedPath === pathOrFile\n    ? null\n    : getFileInternal(normalizeOptionalProperties<GetFileInternalParams>({\n      app,\n      isCaseInsensitive,\n      path: resolvedPath\n    }));\n}\n\n/**\n * Returns the base name of the given `pathOrFile`: a file's name without its extension, a folder's full name.\n *\n * Unlike `basename` from `path.ts`, which is a pure string function, this resolves the argument against the vault first. That is what lets a folder whose name\n * contains a dot answer with its whole name instead of a bogus extension split, and it is why a caller handling both kinds no longer has to branch on\n * {@link isFile} itself \u2014 a folder has no `basename` of its own.\n *\n * A path that resolves to nothing has no answer to look up, so {@link GetBasenameParams.whenMissingTreatAs} decides what happens. It defaults to\n * {@link MissingPathTreatment.Throw} rather than to a guess: `alpha.bravo` may name a dotted folder or a `.bravo` file, and nothing in the vault says\n * which, so a silently wrong answer is worse than an error. Pass {@link MissingPathTreatment.File} for the `checkExtension` reading of a bare string, or\n * {@link MissingPathTreatment.Folder} for the other one.\n *\n * @param params - The parameters for the retrieval.\n * @returns The base name of the `pathOrFile`.\n * @throws Error if the path resolves to nothing and `whenMissingTreatAs` is {@link MissingPathTreatment.Throw} (the default).\n */\nexport function getBasename(params: GetBasenameParams): string {\n  const {\n    app,\n    pathOrFile,\n    whenMissingTreatAs\n  } = params;\n\n  const abstractFile = getAbstractFileOrNull({\n    app,\n    pathOrFile\n  });\n\n  if (isFile(abstractFile)) {\n    return abstractFile.basename;\n  }\n\n  if (isFolder(abstractFile)) {\n    return abstractFile.name;\n  }\n\n  const path = getPath(app, pathOrFile);\n\n  const treatment = whenMissingTreatAs ?? MissingPathTreatment.Throw;\n\n  if (treatment === MissingPathTreatment.Throw) {\n    throw new Error(`Abstract file not found: ${path}`);\n  }\n\n  return treatment === MissingPathTreatment.Folder ? basename(path) : basename(path, extname(path));\n}\n\n/**\n * Returns the extension of the given `pathOrFile`: a file's extension without the leading dot, and an empty string for a folder.\n *\n * Unlike `extname` from `path.ts`, which is a pure string function, this resolves the argument against the vault first, so a folder whose name contains a dot\n * answers with an empty string rather than a bogus extension. A folder has no `extension` of its own, which is why a caller handling both kinds would\n * otherwise branch on {@link isFile} itself.\n *\n * A path that resolves to nothing has no answer to look up, so {@link GetExtensionParams.whenMissingTreatAs} decides what happens. It defaults to\n * {@link MissingPathTreatment.Throw} rather than to a guess: `alpha.bravo` may name a dotted folder or a `.bravo` file, and nothing in the vault says\n * which, so a silently wrong answer is worse than an error. Pass {@link MissingPathTreatment.File} for the `checkExtension` reading of a bare string, or\n * {@link MissingPathTreatment.Folder} for the other one.\n *\n * @param params - The parameters for the retrieval.\n * @returns The extension of the `pathOrFile`, or an empty string if it has none.\n * @throws Error if the path resolves to nothing and `whenMissingTreatAs` is {@link MissingPathTreatment.Throw} (the default).\n */\nexport function getExtension(params: GetExtensionParams): string {\n  const {\n    app,\n    pathOrFile,\n    whenMissingTreatAs\n  } = params;\n\n  const abstractFile = getAbstractFileOrNull({\n    app,\n    pathOrFile\n  });\n\n  if (isFile(abstractFile)) {\n    return abstractFile.extension;\n  }\n\n  if (isFolder(abstractFile)) {\n    return '';\n  }\n\n  const path = getPath(app, pathOrFile);\n\n  const treatment = whenMissingTreatAs ?? MissingPathTreatment.Throw;\n\n  if (treatment === MissingPathTreatment.Throw) {\n    throw new Error(`Abstract file not found: ${path}`);\n  }\n\n  // Obsidian lowercases a file's canonical extension, so a path read as a file has to answer in the same case.\n  return treatment === MissingPathTreatment.Folder ? '' : extname(path).slice(1).toLowerCase();\n}\n\n/**\n * Retrieves a file based on the provided path or file.\n *\n * @param params - The parameters for the retrieval.\n * @returns The file corresponding to the provided path or file.\n * @throws Error if the file is not found.\n */\nexport function getFile(params: GetFileParams): TFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile,\n    shouldIncludeNonExisting\n  } = params;\n  let file = getFileOrNull(normalizeOptionalProperties<GetFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  }));\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 params - The parameters for the retrieval.\n * @returns The file if found, otherwise `null`.\n */\nexport function getFileOrNull(params: GetFileOrNullParams): null | TFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  } = params;\n  const file = getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  }));\n  return isFile(file) ? file : 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 params - The parameters for the retrieval.\n * @returns The retrieved folder.\n * @throws If the folder is not found.\n */\nexport function getFolder(params: GetFolderParams): TFolder {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFolder,\n    shouldIncludeNonExisting\n  } = params;\n  let folder = getFolderOrNull(normalizeOptionalProperties<GetFolderOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFolder\n  }));\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 params - The parameters for the retrieval.\n * @returns The folder if found, otherwise `null`.\n */\nexport function getFolderOrNull(params: GetFolderOrNullParams): null | TFolder {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFolder\n  } = params;\n  const folder = getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile: pathOrFolder\n  }));\n  return isFolder(folder) ? folder : null;\n}\n\n/**\n * Retrieves an array of files representing the markdown files within a specified folder or path.\n *\n * @param params - The parameters for the retrieval.\n * @returns An array of files representing the markdown files.\n */\nexport function getMarkdownFiles(params: GetMarkdownFilesParams): TFile[] {\n  const {\n    app,\n    isRecursive,\n    pathOrFolder\n  } = params;\n  const folder = getFolder({\n    app,\n    pathOrFolder\n  });\n\n  let markdownFiles: TFile[] = [];\n\n  if (isRecursive) {\n    Vault.recurseChildren(folder, (abstractFile) => {\n      if (isMarkdownFile(abstractFile) && abstractFile instanceof TFile) {\n        markdownFiles.push(abstractFile);\n      }\n    });\n  } else {\n    markdownFiles = folder.children.filter((file) => isMarkdownFile(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({\n    app,\n    pathOrFile: path\n  });\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({\n    app,\n    pathOrFolder: path\n  });\n  return folder ?? (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({\n    app,\n    pathOrFile\n  });\n  return file ? file.path : 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 pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a base file.\n */\nexport function isBaseFile(pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(pathOrFile, BASE_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is a canvas file.\n *\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(pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(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 pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a Markdown file.\n */\nexport function isMarkdownFile(pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(pathOrFile, MARKDOWN_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is a note.\n *\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a note.\n */\nexport function isNote(pathOrFile: null | PathOrAbstractFile): boolean {\n  return isMarkdownFile(pathOrFile) || isCanvasFile(pathOrFile) || isBaseFile(pathOrFile);\n}\n\n/**\n * Checks if the given file should be treated as an attachment because of its extension.\n *\n * Some plugins store their data in files that are markdown on disk but are not prose \u2014 Excalidraw, for example, saves each drawing as `sketch.excalidraw.md`.\n * Obsidian reports such a file's extension as `md`, so a caller that wants to tell a drawing apart from a note has to match the full multi-part extension\n * (`.excalidraw.md`) against the file name. Which extensions count is the caller's configuration, not this library's \u2014 only the matching rule is shared.\n *\n * A drawing can also be recognized by its frontmatter, the way Excalidraw itself recognizes one (`excalidraw-plugin: parsed`), through a\n * `property:name[=value]` entry. That answer comes from the metadata cache, which can be cold at startup or right after the file is created, so an\n * uncached file answers \"no match\" and is treated as a note. That is the conservative side for every current caller: a note is not moved as an\n * attachment, and it spares its folder from a delete sweep.\n *\n * @param params - The path or file to classify and the configured attachment extensions.\n * @returns A boolean indicating whether the file should be treated as an attachment.\n */\nexport function isTreatedAsAttachment(params: IsTreatedAsAttachmentParams): boolean {\n  const {\n    app,\n    attachmentExtensions,\n    pathOrFile\n  } = params;\n  if (pathOrFile === null || isFolder(pathOrFile)) {\n    return false;\n  }\n\n  const lowerCaseName = getName(pathOrFile).toLowerCase();\n  return attachmentExtensions.some((extension) => {\n    const trimmedEntry = extension.trim();\n    if (isPropertyEntry(trimmedEntry)) {\n      return !!app && isMarkdownFile(pathOrFile) && checkPropertyEntryMatches({\n        entry: trimmedEntry,\n        frontmatter: getCachedFrontmatter({ app, pathOrFile })\n      });\n    }\n\n    // Enforcing a single leading dot is what keeps the match on an extension boundary.\n    // A bare `raw.md` would otherwise match `sketch.excalidraw.md`, which is never what a caller means.\n    const normalizedExtension = extension.trim().replace(/^\\.+/, '').toLowerCase();\n    return normalizedExtension !== '' && lowerCaseName.endsWith(`.${normalizedExtension}`);\n  });\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 file - The file to trim the markdown extension from.\n * @returns The file path with the markdown extension trimmed.\n */\nexport function trimMarkdownExtension(file: TAbstractFile): string {\n  return isMarkdownFile(file)\n    ? trimEnd({\n      $string: file.path,\n      suffix: `.${MARKDOWN_FILE_EXTENSION}`\n    })\n    : file.path;\n}\n\nfunction getCachedFrontmatter(params: GetCachedFrontmatterParams): null | Readonly<Record<string, unknown>> {\n  const file = getAbstractFileOrNull(params);\n  return isFile(file) ? params.app.metadataCache.getFileCache(file)?.frontmatter ?? null : null;\n}\n\nfunction getFileInternal(params: GetFileInternalParams): null | TAbstractFile {\n  const {\n    app,\n    path\n  } = params;\n  let { isCaseInsensitive } = params;\n  isCaseInsensitive ??= getDataAdapterEx(app).insensitive;\n  if (isCaseInsensitive) {\n    const caseInsensitiveFileIndex = getCaseInsensitiveFileIndex(app);\n    return caseInsensitiveFileIndex ? caseInsensitiveFileIndex.get(path) : app.vault.getAbstractFileByPathInsensitive(path);\n  }\n\n  return app.vault.getAbstractFileByPath(path);\n}\n\nfunction getName(pathOrFile: PathOrAbstractFile): string {\n  return isAbstractFile(pathOrFile) ? pathOrFile.name : basename(pathOrFile);\n}\n\nfunction getResolvedPath(path: string): string {\n  return normalizePath(resolve('/', path));\n}\n"],
  "mappings": "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",
  "names": ["FileSystemType", "MissingPathTreatment"]
}
