@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/folder-note.d.mts

@@ -0,0 +1,166 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * The folder-note concept: which note, if any, is the one whose properties describe a FOLDER itself.
+ *
+ * Obsidian has no such concept — it is a convention the community settled on, and the plugin that owns it
+ * for most vaults is [`folder-notes`](https://community.obsidian.md/plugins/folder-notes). So the answer to
+ * "which note belongs to this folder" is that plugin's to give whenever it is installed, and this module
+ * asks it rather than inventing a second answer: {@link FolderNoteLocation.Auto} — the default — reads its
+ * live configuration at every use.
+ *
+ * Reading it live rather than copying its values into a consumer's own settings is deliberate: a copy goes
+ * stale the moment that plugin is reconfigured, and it would need a settings migration to seed. Everything
+ * else is the caller's explicit choice, and then the other plugin is not consulted at all.
+ *
+ * Nothing here ever CREATES a note. A folder with no folder note answers `null`, which is what lets a
+ * caller layer folder-note behavior onto a click without risking a file appearing on the user's disk.
+ */
+import type { App, TFile, TFolder } from 'obsidian';
+/**
+ * Where a folder's folder note lives.
+ *
+ * The three concrete members are the shapes the folder-note ecosystem actually uses:
+ * `charlie/charlie.md` and `charlie/index.md` are both {@link FolderNoteLocation.InsideFolder} (they
+ * differ only in the NAME, which is why naming is a callback and not a fourth member), while
+ * `charlie.md` beside the folder is {@link FolderNoteLocation.ParentFolder} — whose whole point is that
+ * `[[alpha/bravo/charlie]]` links to a folder with no special syntax.
+ */
+export declare enum FolderNoteLocation {
+    /**
+     * Take the answer from the installed `folder-notes` plugin, falling back to a note named after its
+     * folder, inside it. The default, and resolved LIVE rather than copied.
+     */
+    Auto = "Auto",
+    /**
+     * `alpha/bravo/charlie/<name>.md`.
+     */
+    InsideFolder = "InsideFolder",
+    /**
+     * The vault has no folder notes at all, so every folder answers `null`. This is also how a caller opts
+     * out of folder-note behavior entirely.
+     */
+    None = "None",
+    /**
+     * `alpha/bravo/<name>.md`, beside the folder.
+     */
+    ParentFolder = "ParentFolder"
+}
+/**
+ * A folder-note setup with {@link FolderNoteLocation.Auto} already resolved to a concrete answer.
+ */
+export interface FolderNoteConfig {
+    /**
+     * The extensions a folder note may carry, WITHOUT the leading dot, in resolution order — the first one
+     * that names an existing file wins.
+     */
+    readonly extensions: readonly string[];
+    /**
+     * Whether the folder note is hidden in the file explorer.
+     *
+     * Read rather than acted upon here: it changes nothing about WHICH file is the folder note, but a caller
+     * that reveals the note has to know there is nothing to reveal and fall back to revealing the folder.
+     */
+    readonly isHidden: boolean;
+    /**
+     * Where the note sits relative to its folder.
+     */
+    readonly location: FolderNoteLocation.InsideFolder | FolderNoteLocation.None | FolderNoteLocation.ParentFolder;
+    /**
+     * Names the folder note of a folder, WITHOUT its extension.
+     *
+     * @param folder - The folder whose note is being named.
+     * @returns The note's name; an empty (or blank) name means the folder has no folder note.
+     */
+    resolveName: (folder: TFolder) => string;
+}
+/**
+ * Parameters for {@link resolveFolderNoteConfig}.
+ */
+export interface ResolveFolderNoteConfigParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The extensions a folder note may carry, with or without the leading dot, in resolution order. Ignored
+     * under {@link FolderNoteLocation.Auto}, which takes the installed plugin's answer whole.
+     *
+     * @default `['md']`
+     */
+    readonly extensions?: readonly string[];
+    /**
+     * Whether the folder note is hidden in the file explorer. Ignored under {@link FolderNoteLocation.Auto}.
+     *
+     * @default `false`
+     */
+    readonly isHidden?: boolean;
+    /**
+     * Where the note sits relative to its folder.
+     *
+     * @default {@link FolderNoteLocation.Auto}
+     */
+    readonly location?: FolderNoteLocation;
+    /**
+     * Names the folder note of a folder, WITHOUT its extension. Ignored under
+     * {@link FolderNoteLocation.Auto}, which names the note the way the installed plugin does.
+     *
+     * A callback rather than a name template, because a template needs a token vocabulary and this library
+     * has none to impose — a caller that has one (`{{folderName}}`, `{{folderPath}}`, …) renders it here.
+     *
+     * @param folder - The folder whose note is being named.
+     * @returns The note's name.
+     * @default `(folder) => folder.name`
+     */
+    readonly resolveName?: (folder: TFolder) => string;
+}
+/**
+ * Parameters for {@link resolveFolderNote}.
+ */
+export interface ResolveFolderNoteParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The already-resolved setup to use.
+     *
+     * Omitted means {@link FolderNoteLocation.Auto} — the setup is resolved on the spot, which is what makes
+     * `resolveFolderNote({ app, folder })` the one-liner every caller wants. Pass one when the same setup is
+     * used more than once, or when its {@link FolderNoteConfig.isHidden} is needed alongside the note.
+     *
+     * @default `resolveFolderNoteConfig({ app })`
+     */
+    readonly config?: FolderNoteConfig;
+    /**
+     * The folder whose folder note is wanted. Read AFTER any rename: the note is named from the folder's
+     * CURRENT name, and a `folder-notes` install with `syncFolderName` on will have renamed it already.
+     */
+    readonly folder: TFolder;
+}
+/**
+ * The `folder-notes` plugin's id, as its manifest declares it.
+ */
+export declare const FOLDER_NOTES_PLUGIN_ID = "folder-notes";
+/**
+ * Finds a folder's folder note — the one note whose properties describe the folder itself.
+ *
+ * **Never creates.** A folder that has no folder note answers `null`, and so does the vault root under
+ * {@link FolderNoteLocation.ParentFolder} (nothing can sit beside it).
+ *
+ * @param params - The folder, and optionally the setup to resolve it with.
+ * @returns The folder note, or `null` when there is none.
+ */
+export declare function resolveFolderNote(params: ResolveFolderNoteParams): null | TFile;
+/**
+ * Resolves {@link FolderNoteLocation.Auto} into a concrete folder-note setup.
+ *
+ * `folder-notes`' `vaultFolder` storage (every folder note pooled in one central folder) has no
+ * counterpart here and falls back rather than guessing: with the notes pooled, the note belonging to a
+ * folder is no longer derivable from that folder's path alone.
+ *
+ * @param params - The setup, and the app to read the installed plugin from.
+ * @returns The resolved setup.
+ */
+export declare function resolveFolderNoteConfig(params: ResolveFolderNoteConfigParams): FolderNoteConfig;

package/dist/lib/esm/folder-note.mjs

@@ -0,0 +1,169 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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 { join } from "@mnaoumov/typescript-lib/path";
+import { replaceAll } from "@mnaoumov/typescript-lib/string";
+import { normalizePath } from "obsidian";
+import { MARKDOWN_FILE_EXTENSION } from "./file-system.mjs";
+var FolderNoteLocation = /* @__PURE__ */ ((FolderNoteLocation2) => {
+  FolderNoteLocation2["Auto"] = "Auto";
+  FolderNoteLocation2["InsideFolder"] = "InsideFolder";
+  FolderNoteLocation2["None"] = "None";
+  FolderNoteLocation2["ParentFolder"] = "ParentFolder";
+  return FolderNoteLocation2;
+})(FolderNoteLocation || {});
+const FOLDER_NOTES_PLUGIN_ID = "folder-notes";
+const FOLDER_NOTES_FOLDER_NAME_TOKEN_REG_EXP = /\{\{folder_name\}\}/gi;
+const EXCALIDRAW_FILE_EXTENSION = "excalidraw";
+const FALLBACK_FOLDER_NOTE_CONFIG = {
+  extensions: [MARKDOWN_FILE_EXTENSION],
+  isHidden: false,
+  location: "InsideFolder" /* InsideFolder */,
+  resolveName: (folder) => folder.name
+};
+function resolveFolderNote(params) {
+  const { app, folder } = params;
+  const config = params.config ?? resolveFolderNoteConfig({ app });
+  if (config.location === "None" /* None */) {
+    return null;
+  }
+  const parentFolderPath = config.location === "ParentFolder" /* ParentFolder */ ? folder.parent?.path : folder.path;
+  if (parentFolderPath === void 0) {
+    return null;
+  }
+  const noteName = config.resolveName(folder).trim();
+  if (!noteName) {
+    return null;
+  }
+  for (const extension of config.extensions) {
+    const file = app.vault.getFileByPath(normalizePath(join(parentFolderPath, `${noteName}.${extension}`)));
+    if (file) {
+      return file;
+    }
+  }
+  return null;
+}
+function resolveFolderNoteConfig(params) {
+  const {
+    app,
+    extensions,
+    isHidden,
+    location,
+    resolveName
+  } = params;
+  return location !== void 0 && location !== "Auto" /* Auto */ ? {
+    extensions: normalizeExtensions(extensions ?? [MARKDOWN_FILE_EXTENSION]),
+    isHidden: isHidden ?? false,
+    location,
+    resolveName: resolveName ?? FALLBACK_FOLDER_NOTE_CONFIG.resolveName
+  } : readFolderNotesPluginConfig(app) ?? FALLBACK_FOLDER_NOTE_CONFIG;
+}
+function normalizeExtensions(extensions) {
+  const normalizedExtensions = extensions.map((extension) => extension.trim().toLowerCase().replace(/^\./, "")).map((extension) => extension === EXCALIDRAW_FILE_EXTENSION ? MARKDOWN_FILE_EXTENSION : extension).filter(Boolean);
+  return [...new Set(normalizedExtensions)];
+}
+function readFolderNotesPluginConfig(app) {
+  const folderNotesPlugin = app.plugins.getPlugin(FOLDER_NOTES_PLUGIN_ID);
+  if (!folderNotesPlugin || !("settings" in folderNotesPlugin)) {
+    return null;
+  }
+  const folderNotesSettings = folderNotesPlugin.settings;
+  if (typeof folderNotesSettings !== "object" || folderNotesSettings === null) {
+    return null;
+  }
+  const location = toFolderNoteLocation("storageLocation" in folderNotesSettings ? folderNotesSettings.storageLocation : null);
+  if (!location) {
+    return null;
+  }
+  const folderNoteName = "folderNoteName" in folderNotesSettings ? folderNotesSettings.folderNoteName : null;
+  if (typeof folderNoteName !== "string" || !folderNoteName) {
+    return null;
+  }
+  const folderNoteType = "folderNoteType" in folderNotesSettings ? folderNotesSettings.folderNoteType : null;
+  const supportedFileTypes = "supportedFileTypes" in folderNotesSettings ? folderNotesSettings.supportedFileTypes : null;
+  const isHidden = "hideFolderNote" in folderNotesSettings ? folderNotesSettings.hideFolderNote : null;
+  return {
+    // Its own resolver tries the primary type first and every other supported type after it, which is the
+    // order reproduced here. An unusable pair leaves Markdown, the extension it cannot be configured
+    // without.
+    extensions: normalizeExtensions([
+      typeof folderNoteType === "string" ? folderNoteType : MARKDOWN_FILE_EXTENSION,
+      ...Array.isArray(supportedFileTypes) ? supportedFileTypes.filter((type) => typeof type === "string") : [],
+      MARKDOWN_FILE_EXTENSION
+    ]),
+    isHidden: isHidden === true,
+    location,
+    resolveName: (folder) => replaceAll({
+      $string: folderNoteName,
+      // A function replacer, so a folder name containing `$&` is inserted literally.
+      replacer: () => folder.name,
+      searchValue: FOLDER_NOTES_FOLDER_NAME_TOKEN_REG_EXP
+    })
+  };
+}
+function toFolderNoteLocation(storageLocation) {
+  switch (storageLocation) {
+    case "insideFolder": {
+      return "InsideFolder" /* InsideFolder */;
+    }
+    case "parentFolder": {
+      return "ParentFolder" /* ParentFolder */;
+    }
+    default: {
+      return null;
+    }
+  }
+}
+export {
+  FOLDER_NOTES_PLUGIN_ID,
+  FolderNoteLocation,
+  resolveFolderNote,
+  resolveFolderNoteConfig
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/folder-note.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The folder-note concept: which note, if any, is the one whose properties describe a FOLDER itself.\n *\n * Obsidian has no such concept \u2014 it is a convention the community settled on, and the plugin that owns it\n * for most vaults is [`folder-notes`](https://community.obsidian.md/plugins/folder-notes). So the answer to\n * \"which note belongs to this folder\" is that plugin's to give whenever it is installed, and this module\n * asks it rather than inventing a second answer: {@link FolderNoteLocation.Auto} \u2014 the default \u2014 reads its\n * live configuration at every use.\n *\n * Reading it live rather than copying its values into a consumer's own settings is deliberate: a copy goes\n * stale the moment that plugin is reconfigured, and it would need a settings migration to seed. Everything\n * else is the caller's explicit choice, and then the other plugin is not consulted at all.\n *\n * Nothing here ever CREATES a note. A folder with no folder note answers `null`, which is what lets a\n * caller layer folder-note behavior onto a click without risking a file appearing on the user's disk.\n */\n\nimport type {\n  App,\n  TFile,\n  TFolder\n} from 'obsidian';\n\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { replaceAll } from '@mnaoumov/typescript-lib/string';\nimport { normalizePath } from 'obsidian';\n\nimport { MARKDOWN_FILE_EXTENSION } from './file-system.ts';\n\n/**\n * Where a folder's folder note lives.\n *\n * The three concrete members are the shapes the folder-note ecosystem actually uses:\n * `charlie/charlie.md` and `charlie/index.md` are both {@link FolderNoteLocation.InsideFolder} (they\n * differ only in the NAME, which is why naming is a callback and not a fourth member), while\n * `charlie.md` beside the folder is {@link FolderNoteLocation.ParentFolder} \u2014 whose whole point is that\n * `[[alpha/bravo/charlie]]` links to a folder with no special syntax.\n */\nexport enum FolderNoteLocation {\n  /**\n   * Take the answer from the installed `folder-notes` plugin, falling back to a note named after its\n   * folder, inside it. The default, and resolved LIVE rather than copied.\n   */\n  Auto = 'Auto',\n\n  /**\n   * `alpha/bravo/charlie/<name>.md`.\n   */\n  InsideFolder = 'InsideFolder',\n\n  /**\n   * The vault has no folder notes at all, so every folder answers `null`. This is also how a caller opts\n   * out of folder-note behavior entirely.\n   */\n  None = 'None',\n\n  /**\n   * `alpha/bravo/<name>.md`, beside the folder.\n   */\n  ParentFolder = 'ParentFolder'\n}\n\n/**\n * A folder-note setup with {@link FolderNoteLocation.Auto} already resolved to a concrete answer.\n */\nexport interface FolderNoteConfig {\n  /**\n   * The extensions a folder note may carry, WITHOUT the leading dot, in resolution order \u2014 the first one\n   * that names an existing file wins.\n   */\n  readonly extensions: readonly string[];\n\n  /**\n   * Whether the folder note is hidden in the file explorer.\n   *\n   * Read rather than acted upon here: it changes nothing about WHICH file is the folder note, but a caller\n   * that reveals the note has to know there is nothing to reveal and fall back to revealing the folder.\n   */\n  readonly isHidden: boolean;\n\n  /**\n   * Where the note sits relative to its folder.\n   */\n  readonly location: FolderNoteLocation.InsideFolder | FolderNoteLocation.None | FolderNoteLocation.ParentFolder;\n\n  /**\n   * Names the folder note of a folder, WITHOUT its extension.\n   *\n   * @param folder - The folder whose note is being named.\n   * @returns The note's name; an empty (or blank) name means the folder has no folder note.\n   */\n  // A function property rather than a method, because it is a standalone callback, never a method of the\n  // config \u2014 which is also what lets it be destructured and handed on without tripping `unbound-method`.\n  resolveName: (folder: TFolder) => string;\n}\n\n/**\n * Parameters for {@link resolveFolderNoteConfig}.\n */\nexport interface ResolveFolderNoteConfigParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The extensions a folder note may carry, with or without the leading dot, in resolution order. Ignored\n   * under {@link FolderNoteLocation.Auto}, which takes the installed plugin's answer whole.\n   *\n   * @default `['md']`\n   */\n  readonly extensions?: readonly string[];\n\n  /**\n   * Whether the folder note is hidden in the file explorer. Ignored under {@link FolderNoteLocation.Auto}.\n   *\n   * @default `false`\n   */\n  readonly isHidden?: boolean;\n\n  /**\n   * Where the note sits relative to its folder.\n   *\n   * @default {@link FolderNoteLocation.Auto}\n   */\n  readonly location?: FolderNoteLocation;\n\n  /**\n   * Names the folder note of a folder, WITHOUT its extension. Ignored under\n   * {@link FolderNoteLocation.Auto}, which names the note the way the installed plugin does.\n   *\n   * A callback rather than a name template, because a template needs a token vocabulary and this library\n   * has none to impose \u2014 a caller that has one (`{{folderName}}`, `{{folderPath}}`, \u2026) renders it here.\n   *\n   * @param folder - The folder whose note is being named.\n   * @returns The note's name.\n   * @default `(folder) => folder.name`\n   */\n  // See {@link FolderNoteConfig.resolveName} for why this is a function property.\n  readonly resolveName?: (folder: TFolder) => string;\n}\n\n/**\n * Parameters for {@link resolveFolderNote}.\n */\nexport interface ResolveFolderNoteParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The already-resolved setup to use.\n   *\n   * Omitted means {@link FolderNoteLocation.Auto} \u2014 the setup is resolved on the spot, which is what makes\n   * `resolveFolderNote({ app, folder })` the one-liner every caller wants. Pass one when the same setup is\n   * used more than once, or when its {@link FolderNoteConfig.isHidden} is needed alongside the note.\n   *\n   * @default `resolveFolderNoteConfig({ app })`\n   */\n  readonly config?: FolderNoteConfig;\n\n  /**\n   * The folder whose folder note is wanted. Read AFTER any rename: the note is named from the folder's\n   * CURRENT name, and a `folder-notes` install with `syncFolderName` on will have renamed it already.\n   */\n  readonly folder: TFolder;\n}\n\n/**\n * The `folder-notes` plugin's id, as its manifest declares it.\n */\nexport const FOLDER_NOTES_PLUGIN_ID = 'folder-notes';\n\n/**\n * The one token `folder-notes`' own name template understands. Every other character in that template is\n * a literal, so translating this token is the whole of the translation.\n */\nconst FOLDER_NOTES_FOLDER_NAME_TOKEN_REG_EXP = /\\{\\{folder_name\\}\\}/gi;\n\n/**\n * `folder-notes` offers Excalidraw folder notes, which are Markdown files with an Excalidraw payload \u2014 its\n * own resolver normalizes the type the same way before looking the file up.\n */\nconst EXCALIDRAW_FILE_EXTENSION = 'excalidraw';\n\n/**\n * What {@link FolderNoteLocation.Auto} falls back to: the layout every folder-note plugin supports, and\n * the one `folder-notes` itself ships as its default. Nothing hides a note when no plugin is there to hide\n * it, so {@link FolderNoteConfig.isHidden} is `false`.\n */\nconst FALLBACK_FOLDER_NOTE_CONFIG: FolderNoteConfig = {\n  extensions: [MARKDOWN_FILE_EXTENSION],\n  isHidden: false,\n  location: FolderNoteLocation.InsideFolder,\n  resolveName: (folder: TFolder): string => folder.name\n};\n\n/**\n * Finds a folder's folder note \u2014 the one note whose properties describe the folder itself.\n *\n * **Never creates.** A folder that has no folder note answers `null`, and so does the vault root under\n * {@link FolderNoteLocation.ParentFolder} (nothing can sit beside it).\n *\n * @param params - The folder, and optionally the setup to resolve it with.\n * @returns The folder note, or `null` when there is none.\n */\nexport function resolveFolderNote(params: ResolveFolderNoteParams): null | TFile {\n  const { app, folder } = params;\n  const config = params.config ?? resolveFolderNoteConfig({ app });\n  if (config.location === FolderNoteLocation.None) {\n    return null;\n  }\n\n  const parentFolderPath = config.location === FolderNoteLocation.ParentFolder ? folder.parent?.path : folder.path;\n  if (parentFolderPath === undefined) {\n    return null;\n  }\n\n  const noteName = config.resolveName(folder).trim();\n  if (!noteName) {\n    return null;\n  }\n\n  for (const extension of config.extensions) {\n    const file = app.vault.getFileByPath(normalizePath(join(parentFolderPath, `${noteName}.${extension}`)));\n    if (file) {\n      return file;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Resolves {@link FolderNoteLocation.Auto} into a concrete folder-note setup.\n *\n * `folder-notes`' `vaultFolder` storage (every folder note pooled in one central folder) has no\n * counterpart here and falls back rather than guessing: with the notes pooled, the note belonging to a\n * folder is no longer derivable from that folder's path alone.\n *\n * @param params - The setup, and the app to read the installed plugin from.\n * @returns The resolved setup.\n */\nexport function resolveFolderNoteConfig(params: ResolveFolderNoteConfigParams): FolderNoteConfig {\n  const {\n    app,\n    extensions,\n    isHidden,\n    location,\n    resolveName\n  } = params;\n\n  return location !== undefined && location !== FolderNoteLocation.Auto\n    ? {\n      extensions: normalizeExtensions(extensions ?? [MARKDOWN_FILE_EXTENSION]),\n      isHidden: isHidden ?? false,\n      location,\n      resolveName: resolveName ?? FALLBACK_FOLDER_NOTE_CONFIG.resolveName\n    }\n    : readFolderNotesPluginConfig(app) ?? FALLBACK_FOLDER_NOTE_CONFIG;\n}\n\n/**\n * Normalizes extensions the way `folder-notes` does before it looks a file up: no leading dot, lower-case,\n * Excalidraw treated as Markdown, blanks dropped, duplicates collapsed while keeping the first occurrence's\n * position.\n *\n * @param extensions - The extensions as configured.\n * @returns The normalized extensions, in resolution order.\n */\nfunction normalizeExtensions(extensions: readonly string[]): readonly string[] {\n  const normalizedExtensions = extensions\n    .map((extension) => extension.trim().toLowerCase().replace(/^\\./, ''))\n    .map((extension) => extension === EXCALIDRAW_FILE_EXTENSION ? MARKDOWN_FILE_EXTENSION : extension)\n    .filter(Boolean);\n  return [...new Set(normalizedExtensions)];\n}\n\n/**\n * Reads the installed `folder-notes` plugin's own configuration, if it is installed and configured the way\n * it documents.\n *\n * Every value is read as `unknown` and checked, rather than asserted into a shape: this is another\n * plugin's private settings object, so a version that renames or drops a key must degrade to the fallback\n * instead of throwing inside a click handler.\n *\n * @param app - The Obsidian application instance.\n * @returns The configuration, or `null` when the plugin is absent, not configured, or set to a storage\n * location with no counterpart here.\n */\nfunction readFolderNotesPluginConfig(app: App): FolderNoteConfig | null {\n  const folderNotesPlugin = app.plugins.getPlugin(FOLDER_NOTES_PLUGIN_ID);\n  // Narrowed with `in` rather than asserted into a shape: that keeps every value below typed `unknown`,\n  // which is exactly what a foreign plugin's private settings are.\n  if (!folderNotesPlugin || !('settings' in folderNotesPlugin)) {\n    return null;\n  }\n\n  const folderNotesSettings: unknown = folderNotesPlugin.settings;\n  if (typeof folderNotesSettings !== 'object' || folderNotesSettings === null) {\n    return null;\n  }\n\n  const location = toFolderNoteLocation('storageLocation' in folderNotesSettings ? folderNotesSettings.storageLocation : null);\n  if (!location) {\n    return null;\n  }\n\n  const folderNoteName = 'folderNoteName' in folderNotesSettings ? folderNotesSettings.folderNoteName : null;\n  if (typeof folderNoteName !== 'string' || !folderNoteName) {\n    return null;\n  }\n\n  const folderNoteType = 'folderNoteType' in folderNotesSettings ? folderNotesSettings.folderNoteType : null;\n  const supportedFileTypes = 'supportedFileTypes' in folderNotesSettings ? folderNotesSettings.supportedFileTypes : null;\n  const isHidden = 'hideFolderNote' in folderNotesSettings ? folderNotesSettings.hideFolderNote : null;\n\n  return {\n    // Its own resolver tries the primary type first and every other supported type after it, which is the\n    // order reproduced here. An unusable pair leaves Markdown, the extension it cannot be configured\n    // without.\n    extensions: normalizeExtensions([\n      typeof folderNoteType === 'string' ? folderNoteType : MARKDOWN_FILE_EXTENSION,\n      ...(Array.isArray(supportedFileTypes) ? supportedFileTypes.filter((type: unknown) => typeof type === 'string') : []),\n      MARKDOWN_FILE_EXTENSION\n    ]),\n    isHidden: isHidden === true,\n    location,\n    resolveName: (folder: TFolder): string =>\n      replaceAll({\n        $string: folderNoteName,\n        // A function replacer, so a folder name containing `$&` is inserted literally.\n        replacer: () => folder.name,\n        searchValue: FOLDER_NOTES_FOLDER_NAME_TOKEN_REG_EXP\n      })\n  };\n}\n\n/**\n * Maps `folder-notes`' `storageLocation` onto this library's own location.\n *\n * @param storageLocation - The value read out of that plugin's settings.\n * @returns The location, or `null` for `vaultFolder` and for anything that is not one of its values.\n */\nfunction toFolderNoteLocation(storageLocation: unknown): FolderNoteConfig['location'] | null {\n  switch (storageLocation) {\n    case 'insideFolder': {\n      return FolderNoteLocation.InsideFolder;\n    }\n    case 'parentFolder': {\n      return FolderNoteLocation.ParentFolder;\n    }\n    default: {\n      return null;\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": ["FolderNoteLocation"]
}


package/dist/lib/esm/frontmatter-formatting.d.mts

@@ -0,0 +1,44 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Rewrites a note's YAML front matter by splicing its concrete syntax tree, so every region a change does not reach
+ * keeps the exact bytes its author wrote — comments and the whitespace inside them, quoting style, blank lines,
+ * indentation width, flow versus block collections, and folded and literal scalars.
+ *
+ * Obsidian's own `processFrontMatter()` parses the block to a plain object and re-stringifies the whole of it, so a
+ * callback that changes one key rewrites every other. Re-emitting the parsed document instead of the raw text does not
+ * fix that: five of the losses survive every emit option the `yaml` package offers. Splicing the CST does fix it,
+ * because an untouched token is never re-emitted at all — {@link https://github.com/eemeli/yaml | the library} keeps
+ * each token's original source text and {@link https://eemeli.org/yaml/#cst-parser | `CST.stringify`} concatenates it.
+ *
+ * This module is DELIBERATELY not on the default path. It needs the `yaml` package's CST API, which Obsidian does not
+ * hand to plugins through its module map — that map is `obsidian`, `@codemirror/*` and `@lezer/*` and nothing else —
+ * so the package cannot be marked external and lands in the consuming plugin's `main.js`, about 100 KB of it. A plugin
+ * opts in by calling {@link enableFrontmatterFormattingPreservation} once, and only it pays.
+ */
+/**
+ * Registers this module's engine as the front matter formatting preserver for every write this library performs.
+ *
+ * Call it once, from a plugin's `onloadImpl()`. It takes effect for `processFrontmatter()`, `applyFileChanges()` and
+ * every other path that reaches `setFrontmatter()`, including the ones the calling plugin does not invoke itself.
+ *
+ * There is one preserver per realm, so two plugins that both call this simply agree.
+ */
+export declare function enableFrontmatterFormattingPreservation(): void;
+/**
+ * Rewrites the front matter of a note, keeping the original bytes of everything the change does not reach.
+ *
+ * It is the engine {@link enableFrontmatterFormattingPreservation} registers, and can be called directly as well.
+ *
+ * `null` means "this one is not mine": the block does not exist, the new front matter is empty (both are the
+ * parse-and-stringify path's business, unchanged), or the splice could not be proved faithful. The proof is not
+ * hand-waved — the spliced block is re-parsed and compared against the value the parse-and-stringify path would have
+ * produced for the same input, and any difference returns `null`. That is what makes this strictly better than that
+ * path or identical to it, and never worse.
+ *
+ * @param content - The note to rewrite the front matter of.
+ * @param newFrontmatter - The front matter to write.
+ * @returns The new note, or `null` when the caller should parse the block and write the whole of it out again instead.
+ */
+export declare function preserveFrontmatterFormatting(content: string, newFrontmatter: object): null | string;