obsidian-dev-utils 88.3.0 → 88.4.0

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

@@ -36,6 +36,7 @@ import {
 } from "obsidian";
 import { normalizeOptionalProperties } from "../object-utils.mjs";
 import {
+  basename,
   extname,
   resolve
 } from "../path.mjs";
@@ -322,6 +323,20 @@ function isMarkdownFile(pathOrFile) {
 function isNote(pathOrFile) {
   return isMarkdownFile(pathOrFile) || isCanvasFile(pathOrFile) || isBaseFile(pathOrFile);
 }
+function isTreatedAsAttachment(params) {
+  const {
+    attachmentExtensions,
+    pathOrFile
+  } = params;
+  if (pathOrFile === null || isFolder(pathOrFile)) {
+    return false;
+  }
+  const lowerCaseName = getName(pathOrFile).toLowerCase();
+  return attachmentExtensions.some((extension) => {
+    const normalizedExtension = extension.trim().replace(/^\.+/, "").toLowerCase();
+    return normalizedExtension !== "" && lowerCaseName.endsWith(`.${normalizedExtension}`);
+  });
+}
 function trimMarkdownExtension(file) {
   if (!isMarkdownFile(file)) {
     return file.path;
@@ -347,6 +362,9 @@ function getFileInternal(params) {
   }
   return app.vault.getAbstractFileByPath(path);
 }
+function getName(pathOrFile) {
+  return isAbstractFile(pathOrFile) ? pathOrFile.name : basename(pathOrFile);
+}
 function getResolvedPath(path) {
   return normalizePath(resolve("/", path));
 }
@@ -381,6 +399,7 @@ export {
   isFolder,
   isMarkdownFile,
   isNote,
+  isTreatedAsAttachment,
   trimMarkdownExtension
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/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 {\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 { normalizeOptionalProperties } from '../object-utils.ts';\nimport {\n  extname,\n  resolve\n} from '../path.ts';\nimport { trimEnd } from '../string.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\nimport { getCaseInsensitiveFileIndex } from './case-insensitive-file-index.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 * Parameters for {@link exists}.\n */\nexport interface ExistsParams {\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 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 * 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 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  if (isFile(pathOrFile)) {\n    return pathOrFile.extension === extension;\n  }\n\n  if (typeof pathOrFile === 'string') {\n    // 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 extname(pathOrFile).slice(1).toLowerCase() === extension;\n  }\n\n  return false;\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 exists(params: ExistsParams): 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  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 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    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(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  if (resolvedPath === pathOrFile) {\n    return null;\n  }\n\n  return getFileInternal(normalizeOptionalProperties<GetFileInternalParams>({\n    app,\n    isCaseInsensitive,\n    path: resolvedPath\n  }));\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  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 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  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 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  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({\n    app,\n    pathOrFile\n  });\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 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 * 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  if (!isMarkdownFile(file)) {\n    return file.path;\n  }\n\n  return trimEnd({\n    str: file.path,\n    suffix: `.${MARKDOWN_FILE_EXTENSION}`\n  });\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    if (caseInsensitiveFileIndex) {\n      return caseInsensitiveFileIndex.get(path);\n    }\n    return app.vault.getAbstractFileByPathInsensitive(path);\n  }\n\n  return app.vault.getAbstractFileByPath(path);\n}\n\nfunction getResolvedPath(path: string): string {\n  return normalizePath(resolve('/', path));\n}\n"],
  "mappings": "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",
  "names": ["FileSystemType"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/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 {\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 { normalizeOptionalProperties } from '../object-utils.ts';\nimport {\n  basename,\n  extname,\n  resolve\n} from '../path.ts';\nimport { trimEnd } from '../string.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\nimport { getCaseInsensitiveFileIndex } from './case-insensitive-file-index.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 * Parameters for {@link exists}.\n */\nexport interface ExistsParams {\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 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 extensions that mark a file as an attachment, e.g. `['.excalidraw.md']`. Each entry is normalized before matching: surrounding whitespace is trimmed,\n   * a single leading dot is enforced, and the comparison is case-insensitive. Empty entries are ignored.\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 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  if (isFile(pathOrFile)) {\n    return pathOrFile.extension === extension;\n  }\n\n  if (typeof pathOrFile === 'string') {\n    // 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 extname(pathOrFile).slice(1).toLowerCase() === extension;\n  }\n\n  return false;\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 exists(params: ExistsParams): 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  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 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    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(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  if (resolvedPath === pathOrFile) {\n    return null;\n  }\n\n  return getFileInternal(normalizeOptionalProperties<GetFileInternalParams>({\n    app,\n    isCaseInsensitive,\n    path: resolvedPath\n  }));\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  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 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  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 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  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({\n    app,\n    pathOrFile\n  });\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 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 * @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    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    // 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  if (!isMarkdownFile(file)) {\n    return file.path;\n  }\n\n  return trimEnd({\n    str: file.path,\n    suffix: `.${MARKDOWN_FILE_EXTENSION}`\n  });\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    if (caseInsensitiveFileIndex) {\n      return caseInsensitiveFileIndex.get(path);\n    }\n    return 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"]
}


package/dist/lib/esm/obsidian/i18n/locales/en.d.mts

@@ -36,6 +36,9 @@ export declare const en: {
             readonly closeAriaLabel: "Close";
             readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
         };
+        readonly pathSettings: {
+            readonly invalidRegularExpression: "Invalid regular expression: {{regExp}}";
+        };
         readonly queue: {
             readonly flushQueue: "Flush queue";
         };

package/dist/lib/esm/obsidian/i18n/locales/en.mjs

@@ -50,6 +50,9 @@ const en = {
       closeAriaLabel: "Close",
       unhandledError: "An unhandled error occurred. Please check the console for more information."
     },
+    pathSettings: {
+      invalidRegularExpression: "Invalid regular expression: {{regExp}}"
+    },
     queue: {
       flushQueue: "Flush queue"
     },
@@ -74,4 +77,4 @@ const en = {
 export {
   en
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/i18n/locales/translations-map.d.mts

@@ -39,6 +39,9 @@ declare const translationsMapImpl: {
                 readonly closeAriaLabel: "Close";
                 readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
             };
+            readonly pathSettings: {
+                readonly invalidRegularExpression: "Invalid regular expression: {{regExp}}";
+            };
             readonly queue: {
                 readonly flushQueue: "Flush queue";
             };

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

@@ -55,6 +55,7 @@ export * as 'path-settings' from './path-settings.mjs';
 export * as 'pdf' from './pdf.mjs';
 export * as 'plugin' from './plugin/index.mjs';
 export * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.mjs';
+export * as 'popovers' from './popovers/index.mjs';
 export * as 'queue' from './queue.mjs';
 export * as 'react' from './react/index.mjs';
 export * as 'reference' from './reference.mjs';

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

@@ -77,6 +77,7 @@ import * as path_settings from "./path-settings.mjs";
 import * as pdf from "./pdf.mjs";
 import * as plugin from "./plugin/index.mjs";
 import * as plugin_cli_handler_registrar from "./plugin-cli-handler-registrar.mjs";
+import * as popovers from "./popovers/index.mjs";
 import * as queue from "./queue.mjs";
 import * as react from "./react/index.mjs";
 import * as reference from "./reference.mjs";
@@ -150,6 +151,7 @@ export {
   pdf,
   plugin,
   plugin_cli_handler_registrar as "plugin-cli-handler-registrar",
+  popovers,
   queue,
   react,
   reference,
@@ -167,4 +169,4 @@ export {
   view_registrar as "view-registrar",
   workspace
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'canvas' from './canvas.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'code-block-reg-exp' from './code-block-reg-exp.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'demo-vault-helper' from './demo-vault-helper.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'events' from './events.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'link-update-progress' from './link-update-progress.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAY,aAAe;AAC3B,YAAY,YAAc;AAC1B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,wBAA0B;AACtC,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,uBAAyB;AACrC,YAAYC,+BAAiC;AAC7C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAYC,0BAA4B;AACxC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,oBAAsB;AAClC,YAAY,YAAc;AAC1B,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,+BAAiC;AAC7C,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "bases-view-registrar", "case-insensitive-file-index", "code-block-markdown-information", "code-block-reg-exp", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "dataview-link", "demo-vault-helper", "desktop-demo-vault-opener", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-manager", "file-system", "frontmatter-link-cache-with-offsets", "hover-link-source-registrar", "html-element", "is-in-obsidian", "link-update-progress", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "obsidian-protocol-handler-registrar", "obsidian-settings", "parse-link", "path-settings", "plugin-cli-handler-registrar", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "status-bar-item-registrar", "vault-delete", "vault-transaction", "view-registrar"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'canvas' from './canvas.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'code-block-reg-exp' from './code-block-reg-exp.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'demo-vault-helper' from './demo-vault-helper.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'events' from './events.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'link-update-progress' from './link-update-progress.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'popovers' from './popovers/index.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAY,aAAe;AAC3B,YAAY,YAAc;AAC1B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,wBAA0B;AACtC,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,uBAAyB;AACrC,YAAYC,+BAAiC;AAC7C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAYC,0BAA4B;AACxC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,oBAAsB;AAClC,YAAY,YAAc;AAC1B,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,cAAgB;AAC5B,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,+BAAiC;AAC7C,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "bases-view-registrar", "case-insensitive-file-index", "code-block-markdown-information", "code-block-reg-exp", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "dataview-link", "demo-vault-helper", "desktop-demo-vault-opener", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-manager", "file-system", "frontmatter-link-cache-with-offsets", "hover-link-source-registrar", "html-element", "is-in-obsidian", "link-update-progress", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "obsidian-protocol-handler-registrar", "obsidian-settings", "parse-link", "path-settings", "plugin-cli-handler-registrar", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "status-bar-item-registrar", "vault-delete", "vault-transaction", "view-registrar"]
}


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

@@ -2,8 +2,9 @@
 /**
  * @file
  *
- * This module provides classes for managing include/exclude path settings.
+ * This module provides classes and validators for managing include/exclude path settings.
  */
+import type { MaybeReturn } from '../type.mjs';
 /**
  * A class for managing include/exclude path settings.
  */
@@ -42,3 +43,14 @@ export declare class PathSettings {
      */
     isPathIgnored(path: string): boolean;
 }
+/**
+ * Validates include/exclude path entries, reporting the first entry that is not a parseable regular expression.
+ *
+ * An entry that starts and ends with `/` is a regular expression literal; every other entry is a plain path and is
+ * always valid. An invalid entry does not throw when assigned to {@link PathSettings} — the whole list falls back to
+ * its default pattern instead — so this validator is what surfaces the problem to the user.
+ *
+ * @param paths - The path entries to validate.
+ * @returns A message naming the first invalid entry, or nothing when every entry is valid.
+ */
+export declare function pathsValidator(paths: string[]): MaybeReturn<string>;

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

@@ -24,10 +24,12 @@ if you want to view the source, please visit the github repository of this plugi
 import {
   ALWAYS_MATCH_REG_EXP,
   escapeRegExp,
+  isValidRegExp,
   NEVER_MATCH_REG_EXP
 } from "../reg-exp.mjs";
 import { trimEnd } from "../string.mjs";
 import { assertNever } from "../type-guards.mjs";
+import { t } from "./i18n/i18n.mjs";
 class PathSetting {
   constructor(type) {
     this.type = type;
@@ -40,7 +42,7 @@ class PathSetting {
   }
   set array(value) {
     this._array = value.filter(Boolean);
-    this.regExp = makeRegExp(this._array, this.defaultRegExp);
+    this.regExp = makeRegExp(this._array, this.defaultRegExp) ?? this.defaultRegExp;
   }
   _array = [];
   defaultRegExp;
@@ -102,6 +104,13 @@ class PathSettings {
     return this._includePaths.isPathIgnored(path) || this._excludePaths.isPathIgnored(path);
   }
 }
+function pathsValidator(paths) {
+  for (const path of paths) {
+    if (path.startsWith("/") && path.endsWith("/") && !isValidRegExp(path.slice(1, -1))) {
+      return t(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { regExp: path });
+    }
+  }
+}
 function getDefaultRegExp(type) {
   switch (type) {
     /* v8 ignore stop */
@@ -130,9 +139,14 @@ function makeRegExp(paths, defaultRegExp) {
     });
     return `^${escapeRegExp(path)}(/|$)`;
   }).map((regExpStr) => `(${regExpStr})`).join("|");
-  return new RegExp(regExpStrCombined);
+  try {
+    return new RegExp(regExpStrCombined);
+  } catch {
+    return null;
+  }
 }
 export {
-  PathSettings
+  PathSettings,
+  pathsValidator
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/path-settings.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides classes and validators for managing include/exclude path settings.\n */\n\nimport type { MaybeReturn } from '../type.ts';\n\nimport {\n  ALWAYS_MATCH_REG_EXP,\n  escapeRegExp,\n  isValidRegExp,\n  NEVER_MATCH_REG_EXP\n} from '../reg-exp.ts';\nimport { trimEnd } from '../string.ts';\nimport { assertNever } from '../type-guards.ts';\nimport { t } from './i18n/i18n.ts';\n\nenum PathSettingType {\n  Exclude = 'Exclude',\n  Include = 'Include'\n}\n\nclass PathSetting {\n  public get array(): string[] {\n    return this._array;\n  }\n\n  public set array(value: string[]) {\n    this._array = value.filter(Boolean);\n    this.regExp = makeRegExp(this._array, this.defaultRegExp) ?? this.defaultRegExp;\n  }\n\n  private _array: string[] = [];\n  private readonly defaultRegExp: RegExp;\n  private regExp: RegExp;\n\n  public constructor(private readonly type: PathSettingType) {\n    this.defaultRegExp = getDefaultRegExp(type);\n    this.regExp = this.defaultRegExp;\n  }\n\n  public isPathIgnored(path: string): boolean {\n    /* v8 ignore start -- All branches covered but v8 reports switch as partial. */\n    switch (this.type) {\n      /* v8 ignore stop */\n      case PathSettingType.Exclude:\n        return this.regExp.test(path);\n      case PathSettingType.Include:\n        return !this.regExp.test(path);\n      default:\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.type);\n        /* v8 ignore stop */\n    }\n  }\n}\n\n/**\n * A class for managing include/exclude path settings.\n */\nexport class PathSettings {\n  /**\n   * Gets the exclude paths.\n   *\n   * @returns The exclude paths.\n   */\n  public get excludePaths(): string[] {\n    return this._excludePaths.array;\n  }\n\n  /**\n   * Sets the exclude paths.\n   *\n   * @param value - The exclude paths.\n   */\n  public set excludePaths(value: string[]) {\n    this._excludePaths.array = value;\n  }\n\n  /**\n   * Gets the include paths.\n   *\n   * @returns The include paths.\n   */\n  public get includePaths(): string[] {\n    return this._includePaths.array;\n  }\n\n  /**\n   * Sets the include paths.\n   *\n   * @param value - The include paths.\n   */\n  public set includePaths(value: string[]) {\n    this._includePaths.array = value;\n  }\n\n  private readonly _excludePaths = new PathSetting(PathSettingType.Exclude);\n  private readonly _includePaths = new PathSetting(PathSettingType.Include);\n\n  /**\n   * Checks if a path is ignored by the include/exclude path settings.\n   *\n   * @param path - The path to check.\n   * @returns `true` if the path is ignored, `false` otherwise.\n   */\n  public isPathIgnored(path: string): boolean {\n    return this._includePaths.isPathIgnored(path) || this._excludePaths.isPathIgnored(path);\n  }\n}\n\n/**\n * Validates include/exclude path entries, reporting the first entry that is not a parseable regular expression.\n *\n * An entry that starts and ends with `/` is a regular expression literal; every other entry is a plain path and is\n * always valid. An invalid entry does not throw when assigned to {@link PathSettings} \u2014 the whole list falls back to\n * its default pattern instead \u2014 so this validator is what surfaces the problem to the user.\n *\n * @param paths - The path entries to validate.\n * @returns A message naming the first invalid entry, or nothing when every entry is valid.\n */\nexport function pathsValidator(paths: string[]): MaybeReturn<string> {\n  for (const path of paths) {\n    if (path.startsWith('/') && path.endsWith('/') && !isValidRegExp(path.slice(1, -1))) {\n      return t(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { regExp: path });\n    }\n  }\n}\n\nfunction getDefaultRegExp(type: PathSettingType): RegExp {\n  /* v8 ignore start -- All branches covered but v8 reports switch as partial. */\n  switch (type) {\n    /* v8 ignore stop */\n    case PathSettingType.Exclude:\n      return NEVER_MATCH_REG_EXP;\n    case PathSettingType.Include:\n      return ALWAYS_MATCH_REG_EXP;\n    default:\n      /* v8 ignore start -- Exhaustive switch guard. */\n      assertNever(type);\n      /* v8 ignore stop */\n  }\n}\n\nfunction makeRegExp(paths: string[], defaultRegExp: RegExp): null | RegExp {\n  if (paths.length === 0) {\n    return defaultRegExp;\n  }\n\n  const regExpStrCombined = paths.map((path) => {\n    if (path === '/') {\n      return defaultRegExp.source;\n    }\n\n    if (path.startsWith('/') && path.endsWith('/')) {\n      return path.slice(1, -1);\n    }\n\n    path = trimEnd({\n      str: path,\n      suffix: '/'\n    });\n    return `^${escapeRegExp(path)}(/|$)`;\n  })\n    .map((regExpStr) => `(${regExpStr})`)\n    .join('|');\n\n  try {\n    return new RegExp(regExpStrCombined);\n  } catch {\n    // A partially typed regex literal (`/^Inbox\\/`) is not parseable.\n    // Report it instead of throwing from a settings setter, which would break both the settings UI and the save path.\n    return null;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/popovers/field-popover.d.mts

@@ -0,0 +1,75 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * Utility for editing a handful of named text fields in a popover anchored at a point.
+ *
+ * This is to {@link showPopover} what `modals/prompt.ts` is to `modals/modal.ts`: the common case
+ * spelled declaratively, so a caller that only needs a few text fields never writes any DOM wiring.
+ * Anything richer — a dropdown, a toggle, rendered markdown — goes through {@link showPopover}
+ * directly.
+ */
+import type { PopoverAnchor } from './popover-anchor.mjs';
+/**
+ * Parameters for {@link editFieldsInPopover}.
+ *
+ * @typeParam Key - The union of the field keys, inferred from {@link EditFieldsInPopoverParams.fields}.
+ */
+export interface EditFieldsInPopoverParams<Key extends string> {
+    /**
+     * Where to place the popover.
+     */
+    readonly anchor: PopoverAnchor;
+    /**
+     * A text for the "Cancel" button.
+     */
+    readonly cancelButtonText?: string;
+    /**
+     * Additional CSS classes to apply to the popover.
+     */
+    readonly cssClasses?: string[];
+    /**
+     * The fields to edit, rendered top to bottom in the given order.
+     */
+    readonly fields: readonly PopoverField<Key>[];
+    /**
+     * A text for the "OK" button.
+     */
+    readonly okButtonText?: string;
+}
+/**
+ * A single text field of a {@link editFieldsInPopover} popover.
+ *
+ * @typeParam Key - The key the field's value is returned under.
+ */
+export interface PopoverField<Key extends string> {
+    /**
+     * A value to pre-fill the field with.
+     *
+     * @default `''`
+     */
+    readonly defaultValue?: string;
+    /**
+     * The key the field's value is returned under.
+     */
+    readonly key: Key;
+    /**
+     * The label shown next to the field.
+     */
+    readonly name: string;
+    /**
+     * A placeholder text for the field.
+     *
+     * @default `''`
+     */
+    readonly placeholder?: string;
+}
+/**
+ * Displays a popover with a text field per entry in `fields` and resolves with their values keyed by
+ * {@link PopoverField.key}, or `null` if it was dismissed without confirming.
+ *
+ * @typeParam Key - The union of the field keys, inferred from the `fields` array.
+ * @param params - The parameters for the popover.
+ * @returns A {@link Promise} that resolves with the edited values, or `null` if dismissed.
+ */
+export declare function editFieldsInPopover<Key extends string>(params: EditFieldsInPopoverParams<Key>): Promise<null | Record<Key, string>>;

package/dist/lib/esm/obsidian/popovers/field-popover.mjs

@@ -0,0 +1,70 @@
+/*
+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() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import {
+  Setting,
+  TextComponent
+} from "obsidian";
+import { normalizeOptionalProperties } from "../../object-utils.mjs";
+import { CssClass } from "../css-class.mjs";
+import { showPopover } from "./popover.mjs";
+async function editFieldsInPopover(params) {
+  const {
+    anchor,
+    cancelButtonText,
+    cssClasses,
+    fields,
+    okButtonText
+  } = params;
+  return await showPopover(normalizeOptionalProperties({
+    anchor,
+    build({ contentEl }) {
+      const editors = fields.map((field) => ({
+        key: field.key,
+        textComponent: addField(contentEl, field)
+      }));
+      return () => {
+        const values = {};
+        for (const editor of editors) {
+          values[editor.key] = editor.textComponent.getValue();
+        }
+        return values;
+      };
+    },
+    cancelButtonText,
+    cssClasses,
+    okButtonText
+  }));
+}
+function addField(containerEl, field) {
+  const setting = new Setting(containerEl).setName(field.name);
+  const textComponent = new TextComponent(setting.controlEl);
+  textComponent.setValue(field.defaultValue ?? "");
+  textComponent.setPlaceholder(field.placeholder ?? "");
+  textComponent.inputEl.addClass(CssClass.TextBox);
+  return textComponent;
+}
+export {
+  editFieldsInPopover
+};
+//# sourceMappingURL=data:application/json;base64,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