@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/folder-note.cjs

@@ -0,0 +1,261 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var folder_note_exports = {};
+__export(folder_note_exports, {
+  FOLDER_NOTES_PLUGIN_ID: () => FOLDER_NOTES_PLUGIN_ID,
+  FolderNoteLocation: () => FolderNoteLocation,
+  resolveFolderNote: () => resolveFolderNote,
+  resolveFolderNoteConfig: () => resolveFolderNoteConfig
+});
+module.exports = __toCommonJS(folder_note_exports);
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_string = require('@mnaoumov/typescript-lib/string');
+var import_obsidian = require('obsidian');
+var import_file_system = require('./file-system.cjs');
+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: [import_file_system.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((0, import_obsidian.normalizePath)((0, import_path.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 ?? [import_file_system.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 ? import_file_system.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 : import_file_system.MARKDOWN_FILE_EXTENSION,
+      ...Array.isArray(supportedFileTypes) ? supportedFileTypes.filter((type) => typeof type === "string") : [],
+      import_file_system.MARKDOWN_FILE_EXTENSION
+    ]),
+    isHidden: isHidden === true,
+    location,
+    resolveName: (folder) => (0, import_string.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;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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/cjs/folder-note.d.cts

@@ -0,0 +1,166 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @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' with { 'resolution-mode': 'import' };
+/**
+ * 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;