obsidian-dev-utils 91.0.1 → 92.1.0

package/dist/lib/esm/script-utils/demo-vault-coverage.d.mts

@@ -10,13 +10,36 @@
  * The runtime behavior of the plugin is covered by its other integration tests, not by the demo vault; the
  * vault is a learning resource, and these checks only guard that it stays truthful.
  *
+ * They also enforce the demo-vault AUTHORING convention — every note opens with an `# H1` and a plain
+ * prose paragraph, every note is reachable from the start note, and no note uses a `[[wikilink]]` or a
+ * `[Docs](…)` line. These checks are unconditional: the demo vault is the published documentation, read
+ * in Obsidian AND on GitHub (where a wikilink does not render), so a note that breaks the convention is
+ * broken for real readers. `authoring` only tunes them (which note is the start, which notes sit outside
+ * the learning path); it cannot switch them off.
+ *
  * Two layers are exposed:
  * - {@link DemoVaultCoverageChecker} — a framework-agnostic core that reads the corpus, parses interface /
  *   class / enum members and exported functions, and returns diagnostic arrays (what is undemonstrated / stale
- *   / unlinked).
+ *   / unlinked / off-convention).
  * - {@link registerDemoVaultCoverageSuite} — a thin wrapper that registers a `vitest` suite over the core, so
  *   a plugin's `demo-vault.no-app.integration.test.ts` is a single declarative call.
  */
+/**
+ * Tunes the always-on authoring checks. It cannot disable them — see the file overview.
+ */
+export interface DemoVaultAuthoringSpec {
+    /**
+     * The notes (paths relative to the demo vault) that sit outside the learning path and are therefore
+     * exempt from every authoring check. Defaults to the vault's own `README.md`, which addresses someone
+     * browsing the repo on GitHub rather than a reader working through the vault.
+     */
+    readonly excludedNotes?: string[];
+    /**
+     * The note (path relative to the demo vault) every other note must be reachable from. Defaults to
+     * `00 Start.md`.
+     */
+    readonly startNote?: string;
+}
 /**
  * Reflects a config interface whose options are demonstrated by their bare name.
  */
@@ -35,6 +58,11 @@ export interface DemoVaultConfigInterfaceCoverageSpec {
  * The parameters for the {@link DemoVaultCoverageChecker} constructor.
  */
 export interface DemoVaultCoverageCheckerConstructorParams {
+    /**
+     * The notes (paths relative to the demo vault) exempt from the authoring checks. Defaults to the
+     * vault's own `README.md`.
+     */
+    readonly excludedNotes?: string[];
     /**
      * The absolute path of the plugin repo root — the folder containing `demo-vault/` and the source being
      * reflected. Callers typically pass `getRootFolder() ?? process.cwd()`.
@@ -81,6 +109,15 @@ export interface DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams {
      */
     readonly nonFeatureDocs: string[];
 }
+/**
+ * The parameters for {@link DemoVaultCoverageChecker.findUnreachableNotes}.
+ */
+export interface DemoVaultCoverageCheckerFindUnreachableNotesParams {
+    /**
+     * The note (path relative to the demo vault) the walk starts from, e.g. `00 Start.md`.
+     */
+    readonly startNote: string;
+}
 /**
  * The parameters for {@link DemoVaultCoverageChecker.getExportedFunctionNames}.
  */
@@ -174,6 +211,19 @@ export interface DemoVaultNonTrivialGuardSpec {
      */
     readonly sourcePath: string;
 }
+/**
+ * A single demo note, as read from the demo vault.
+ */
+export interface DemoVaultNote {
+    /**
+     * The note's raw Markdown content.
+     */
+    readonly content: string;
+    /**
+     * The note's path relative to the demo vault folder, e.g. `00 Start.md`.
+     */
+    readonly relativePath: string;
+}
 /**
  * The parsed members of a source interface, class, or enum.
  */
@@ -195,6 +245,10 @@ export interface InterfaceMembers {
  * The parameters for {@link registerDemoVaultCoverageSuite}.
  */
 export interface RegisterDemoVaultCoverageSuiteParams {
+    /**
+     * Tunes the always-on authoring checks, or `undefined` to take their defaults. It cannot disable them.
+     */
+    readonly authoring?: DemoVaultAuthoringSpec;
     /**
      * The config interfaces whose options must each be demonstrated by their bare name.
      */
@@ -229,7 +283,9 @@ export interface RegisterDemoVaultCoverageSuiteParams {
  */
 export declare class DemoVaultCoverageChecker {
     private cachedCorpus;
+    private cachedNotes;
     private readonly demoVaultFolder;
+    private readonly excludedNotes;
     private readonly rootFolder;
     /**
      * Creates a checker rooted at a plugin repo.
@@ -243,6 +299,41 @@ export declare class DemoVaultCoverageChecker {
      * @returns The relative paths of every `*.md` note in the demo vault.
      */
     collectDemoNoteRelativePaths(): string[];
+    /**
+     * Reads and caches every demo note individually — the per-note view the authoring checks work on, as
+     * opposed to the concatenated {@link DemoVaultCoverageChecker.readCorpus}.
+     *
+     * @returns Every `*.md` note in the demo vault, excluded ones included.
+     */
+    collectNotes(): DemoVaultNote[];
+    /**
+     * Finds notes carrying a `[Docs](…)` link line. The note IS the documentation, so a line pointing
+     * elsewhere for the real explanation is the shape this convention exists to remove.
+     *
+     * @returns The relative paths of the offending notes.
+     */
+    findNotesWithDocsLinks(): string[];
+    /**
+     * Finds notes that do not open with an `# H1` (frontmatter aside).
+     *
+     * @returns The relative paths of the offending notes.
+     */
+    findNotesWithoutH1(): string[];
+    /**
+     * Finds notes with no prose paragraph before their first code fence — the 1-3 sentences saying what the
+     * feature does and why a reader would want it, without which the note is a button with no lesson.
+     *
+     * @returns The relative paths of the offending notes.
+     */
+    findNotesWithoutIntroProse(): string[];
+    /**
+     * Finds notes using an Obsidian `[[wikilink]]` outside a code fence. The demo vault is also read on
+     * GitHub, where a wikilink renders as literal brackets and leads nowhere. A wikilink shown INSIDE a
+     * fence is sample text, not navigation, so fenced blocks are skipped.
+     *
+     * @returns The relative paths of the offending notes.
+     */
+    findNotesWithWikilinks(): string[];
     /**
      * Finds members that the demo notes reference on a receiver but that no longer exist on it (rename drift).
      *
@@ -264,6 +355,19 @@ export declare class DemoVaultCoverageChecker {
      * @returns The feature-doc basenames (without `.md`) not linked from any demo note.
      */
     findUnlinkedFeatureDocs(params: DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams): string[];
+    /**
+     * Finds notes that cannot be reached from the start note by following Markdown links between notes.
+     *
+     * The walk starts at {@link DemoVaultCoverageCheckerFindUnreachableNotesParams.startNote} and follows
+     * every `[Text](<./NN Name.md>)` link outside a code fence, transitively. A note nothing links to is
+     * one a reader can only find by browsing the file list — which is exactly what the grouped index in the
+     * start note is meant to replace. When the start note itself is missing, EVERY note is unreachable,
+     * because there is nowhere to start from.
+     *
+     * @param params - The parameters for the walk.
+     * @returns The relative paths of the unreachable notes.
+     */
+    findUnreachableNotes(params: DemoVaultCoverageCheckerFindUnreachableNotesParams): string[];
     /**
      * Parses the names of the `export function`s (including `async` and generator declarations) in a source file.
      *
@@ -285,6 +389,7 @@ export declare class DemoVaultCoverageChecker {
      * @returns The concatenated demo-note contents.
      */
     readCorpus(): string;
+    private collectCheckableNotes;
     private collectMarkdownFiles;
 }
 /**

package/dist/lib/esm/script-utils/demo-vault-coverage.mjs

@@ -30,15 +30,20 @@ import {
   expect,
   it
 } from "vitest";
+import { normalizeOptionalProperties } from "../object-utils.mjs";
 import { ObsidianPluginRepoPaths } from "../obsidian/plugin/obsidian-plugin-repo-paths.mjs";
 import {
+  dirname,
   join,
   relative
 } from "../path.mjs";
 import { getMandatoryNamedGroup } from "../reg-exp.mjs";
+import { ensureNonNullable } from "../type-guards.mjs";
 class DemoVaultCoverageChecker {
   cachedCorpus = null;
+  cachedNotes = null;
   demoVaultFolder;
+  excludedNotes;
   rootFolder;
   /**
    * Creates a checker rooted at a plugin repo.
@@ -48,6 +53,7 @@ class DemoVaultCoverageChecker {
   constructor(params) {
     this.rootFolder = params.rootFolder;
     this.demoVaultFolder = join(this.rootFolder, ObsidianPluginRepoPaths.DemoVault);
+    this.excludedNotes = new Set(params.excludedNotes ?? DEFAULT_EXCLUDED_NOTES);
   }
   /**
    * Collects the demo notes as paths relative to the demo vault folder (for a non-trivial-surface guard).
@@ -55,7 +61,56 @@ class DemoVaultCoverageChecker {
    * @returns The relative paths of every `*.md` note in the demo vault.
    */
   collectDemoNoteRelativePaths() {
-    return this.collectMarkdownFiles(this.demoVaultFolder).map((file) => relative(this.demoVaultFolder, file));
+    return this.collectNotes().map((note) => note.relativePath);
+  }
+  /**
+   * Reads and caches every demo note individually — the per-note view the authoring checks work on, as
+   * opposed to the concatenated {@link DemoVaultCoverageChecker.readCorpus}.
+   *
+   * @returns Every `*.md` note in the demo vault, excluded ones included.
+   */
+  collectNotes() {
+    this.cachedNotes ??= this.collectMarkdownFiles(this.demoVaultFolder).map((file) => ({
+      content: readFileSync(file, "utf-8"),
+      relativePath: relative(this.demoVaultFolder, file)
+    }));
+    return this.cachedNotes;
+  }
+  /**
+   * Finds notes carrying a `[Docs](…)` link line. The note IS the documentation, so a line pointing
+   * elsewhere for the real explanation is the shape this convention exists to remove.
+   *
+   * @returns The relative paths of the offending notes.
+   */
+  findNotesWithDocsLinks() {
+    return this.collectCheckableNotes().filter((note) => getLinesOutsideFences(note.content).some((line) => DOCS_LINK_REG_EXP.test(line))).map((note) => note.relativePath);
+  }
+  /**
+   * Finds notes that do not open with an `# H1` (frontmatter aside).
+   *
+   * @returns The relative paths of the offending notes.
+   */
+  findNotesWithoutH1() {
+    return this.collectCheckableNotes().filter((note) => !hasH1(note.content)).map((note) => note.relativePath);
+  }
+  /**
+   * Finds notes with no prose paragraph before their first code fence — the 1-3 sentences saying what the
+   * feature does and why a reader would want it, without which the note is a button with no lesson.
+   *
+   * @returns The relative paths of the offending notes.
+   */
+  findNotesWithoutIntroProse() {
+    return this.collectCheckableNotes().filter((note) => !hasIntroProse(note.content)).map((note) => note.relativePath);
+  }
+  /**
+   * Finds notes using an Obsidian `[[wikilink]]` outside a code fence. The demo vault is also read on
+   * GitHub, where a wikilink renders as literal brackets and leads nowhere. A wikilink shown INSIDE a
+   * fence is sample text, not navigation, so fenced blocks are skipped.
+   *
+   * @returns The relative paths of the offending notes.
+   */
+  findNotesWithWikilinks() {
+    return this.collectCheckableNotes().filter((note) => getLinesOutsideFences(note.content).some((line) => WIKILINK_REG_EXP.test(stripInlineCode(line)))).map((note) => note.relativePath);
   }
   /**
    * Finds members that the demo notes reference on a receiver but that no longer exist on it (rename drift).
@@ -95,6 +150,33 @@ class DemoVaultCoverageChecker {
     );
     return featureDocs.filter((doc) => !linkedDocs.has(doc));
   }
+  /**
+   * Finds notes that cannot be reached from the start note by following Markdown links between notes.
+   *
+   * The walk starts at {@link DemoVaultCoverageCheckerFindUnreachableNotesParams.startNote} and follows
+   * every `[Text](<./NN Name.md>)` link outside a code fence, transitively. A note nothing links to is
+   * one a reader can only find by browsing the file list — which is exactly what the grouped index in the
+   * start note is meant to replace. When the start note itself is missing, EVERY note is unreachable,
+   * because there is nowhere to start from.
+   *
+   * @param params - The parameters for the walk.
+   * @returns The relative paths of the unreachable notes.
+   */
+  findUnreachableNotes(params) {
+    const notesByRelativePath = new Map(this.collectNotes().map((note) => [note.relativePath, note]));
+    const reachedNotes = /* @__PURE__ */ new Set();
+    const pendingNotes = [params.startNote];
+    while (pendingNotes.length > 0) {
+      const notePath = ensureNonNullable(pendingNotes.pop());
+      const note = notesByRelativePath.get(notePath);
+      if (!note || reachedNotes.has(notePath)) {
+        continue;
+      }
+      reachedNotes.add(notePath);
+      pendingNotes.push(...collectNoteLinkTargets(note));
+    }
+    return this.collectCheckableNotes().map((note) => note.relativePath).filter((notePath) => !reachedNotes.has(notePath));
+  }
   /**
    * Parses the names of the `export function`s (including `async` and generator declarations) in a source file.
    *
@@ -126,9 +208,14 @@ class DemoVaultCoverageChecker {
    * @returns The concatenated demo-note contents.
    */
   readCorpus() {
-    this.cachedCorpus ??= this.collectMarkdownFiles(this.demoVaultFolder).map((file) => readFileSync(file, "utf-8")).join("\n");
+    this.cachedCorpus ??= this.collectNotes().map((note) => note.content).join("\n");
     return this.cachedCorpus;
   }
+  // The notes the authoring checks apply to: every note except the ones declared outside the learning
+  // Path (the vault's own `README.md` by default).
+  collectCheckableNotes() {
+    return this.collectNotes().filter((note) => !this.excludedNotes.has(note.relativePath));
+  }
   collectMarkdownFiles(folder) {
     const result = [];
     for (const entry of readdirSync(folder, { withFileTypes: true })) {
@@ -145,7 +232,11 @@ class DemoVaultCoverageChecker {
   }
 }
 function registerDemoVaultCoverageSuite(params) {
-  const checker = new DemoVaultCoverageChecker({ rootFolder: params.rootFolder });
+  const checker = new DemoVaultCoverageChecker(normalizeOptionalProperties({
+    excludedNotes: params.authoring?.excludedNotes,
+    rootFolder: params.rootFolder
+  }));
+  const startNote = params.authoring?.startNote ?? DEFAULT_START_NOTE;
   describe("demo-vault coverage", () => {
     for (const spec of params.interfaces) {
       it(`demonstrates every ${spec.interfaceName} ${spec.kind}`, () => {
@@ -179,6 +270,21 @@ function registerDemoVaultCoverageSuite(params) {
         expect(checker.findUnlinkedFeatureDocs({ docsFolder: docs.folder, nonFeatureDocs: docs.nonFeatureDocs })).toEqual([]);
       });
     }
+    it("opens every note with an H1", () => {
+      expect(checker.findNotesWithoutH1()).toEqual([]);
+    });
+    it("opens every note with a prose paragraph before its first code block", () => {
+      expect(checker.findNotesWithoutIntroProse()).toEqual([]);
+    });
+    it(`reaches every note from ${startNote}`, () => {
+      expect(checker.findUnreachableNotes({ startNote })).toEqual([]);
+    });
+    it("uses no wikilinks, which do not render on GitHub", () => {
+      expect(checker.findNotesWithWikilinks()).toEqual([]);
+    });
+    it("carries no Docs link line, because the note is the docs", () => {
+      expect(checker.findNotesWithDocsLinks()).toEqual([]);
+    });
     it("keeps the reflected surface non-trivial", () => {
       const guard = params.nonTrivialGuard;
       const members = checker.getInterfaceMembers(guard);
@@ -188,6 +294,18 @@ function registerDemoVaultCoverageSuite(params) {
   });
 }
 const CLASS_MEMBER_MODIFIERS = String.raw`(?:(?:public|private|protected|readonly|static|abstract|override)\s+)*`;
+const ABSOLUTE_URL_REG_EXP = /^[a-z][\w+.-]*:/i;
+const ANGLE_BRACKETS_REG_EXP = /^<|>$/g;
+const CODE_FENCE_REG_EXP = /^\s*(?:```|~~~)/;
+const DEFAULT_EXCLUDED_NOTES = ["README.md"];
+const DEFAULT_START_NOTE = "00 Start.md";
+const DOCS_LINK_REG_EXP = /^\s*\[Docs]\(/;
+const FRONTMATTER_REG_EXP = /^---\r?\n[\s\S]*?\r?\n---[^\S\n]*\r?\n?/;
+const H1_REG_EXP = /^# \S/;
+const HEADING_REG_EXP = /^#{1,6} /;
+const INLINE_CODE_REG_EXP = /`[^`\n]*`/g;
+const MARKDOWN_LINK_REG_EXP = /\[[^\]]*]\((?<target>[^)]+)\)/g;
+const WIKILINK_REG_EXP = /\[\[[^\]]+]]/;
 function buildMembers(methods, properties) {
   return {
     all: [...methods, ...properties],
@@ -195,6 +313,20 @@ function buildMembers(methods, properties) {
     properties
   };
 }
+function collectNoteLinkTargets(note) {
+  const targets = [];
+  for (const line of getLinesOutsideFences(note.content)) {
+    for (const match of stripInlineCode(line).matchAll(MARKDOWN_LINK_REG_EXP)) {
+      const target = getMandatoryNamedGroup(match, "target").replaceAll(ANGLE_BRACKETS_REG_EXP, "");
+      const [notePath = ""] = target.split("#", 1);
+      if (ABSOLUTE_URL_REG_EXP.test(notePath) || !notePath.toLowerCase().endsWith(".md")) {
+        continue;
+      }
+      targets.push(join(dirname(note.relativePath), tryDecodeUriComponent(notePath)));
+    }
+  }
+  return targets;
+}
 function extractClassMethodNames(classBody) {
   return [...classBody.matchAll(new RegExp(String.raw`^ {2}(?<modifiers>${CLASS_MEMBER_MODIFIERS})(?<name>\w+)(?:<[^>]*>)?\(`, "gm"))].filter((match) => !isNonPublicMember(getMandatoryNamedGroup(match, "modifiers"))).map((match) => getMandatoryNamedGroup(match, "name"));
 }
@@ -210,6 +342,43 @@ function extractMethodNames(interfaceBody) {
 function extractPropertyNames(interfaceBody) {
   return [...interfaceBody.matchAll(/^ {2}(?<name>\w+)\??:/gm)].map((match) => getMandatoryNamedGroup(match, "name"));
 }
+function getLinesOutsideFences(content) {
+  const lines = [];
+  let isInsideFence = false;
+  for (const line of content.split("\n")) {
+    if (CODE_FENCE_REG_EXP.test(line)) {
+      isInsideFence = !isInsideFence;
+      continue;
+    }
+    if (!isInsideFence) {
+      lines.push(line);
+    }
+  }
+  return lines;
+}
+function hasH1(content) {
+  for (const line of stripFrontmatter(content).split("\n")) {
+    const trimmedLine = line.trim();
+    if (trimmedLine === "") {
+      continue;
+    }
+    return H1_REG_EXP.test(trimmedLine);
+  }
+  return false;
+}
+function hasIntroProse(content) {
+  for (const line of stripFrontmatter(content).split("\n")) {
+    if (CODE_FENCE_REG_EXP.test(line)) {
+      return false;
+    }
+    const trimmedLine = line.trim();
+    if (trimmedLine === "" || HEADING_REG_EXP.test(trimmedLine)) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
 function isNonPublicMember(modifiers) {
   return /\b(?:private|protected)\b/.test(modifiers);
 }
@@ -226,8 +395,21 @@ function parseMembers(keyword, body) {
     }
   }
 }
+function stripFrontmatter(content) {
+  return content.replace(FRONTMATTER_REG_EXP, "");
+}
+function stripInlineCode(line) {
+  return line.replaceAll(INLINE_CODE_REG_EXP, "");
+}
+function tryDecodeUriComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
 export {
   DemoVaultCoverageChecker,
   registerDemoVaultCoverageSuite
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/demo-vault-coverage.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Static coverage/freshness checks that keep a plugin's in-repo `demo-vault/` in sync with its public surface.\n *\n * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. These helpers reflect the real\n * public API/config/docs straight from source and assert \u2014 WITHOUT launching Obsidian \u2014 that every feature is\n * demonstrated in the notes and that the notes reference no API member that no longer exists (rename drift).\n * The runtime behavior of the plugin is covered by its other integration tests, not by the demo vault; the\n * vault is a learning resource, and these checks only guard that it stays truthful.\n *\n * Two layers are exposed:\n * - {@link DemoVaultCoverageChecker} \u2014 a framework-agnostic core that reads the corpus, parses interface /\n *   class / enum members and exported functions, and returns diagnostic arrays (what is undemonstrated / stale\n *   / unlinked).\n * - {@link registerDemoVaultCoverageSuite} \u2014 a thin wrapper that registers a `vitest` suite over the core, so\n *   a plugin's `demo-vault.no-app.integration.test.ts` is a single declarative call.\n */\n\nimport {\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport {\n  describe,\n  expect,\n  it\n} from 'vitest';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport {\n  join,\n  relative\n} from '../path.ts';\nimport { getMandatoryNamedGroup } from '../reg-exp.ts';\n\n/**\n * Reflects a config interface whose options are demonstrated by their bare name.\n */\nexport interface DemoVaultConfigInterfaceCoverageSpec {\n  /**\n   * The name of the `export interface`, `export class`, or `export enum` whose properties are the config\n   * options.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface, class, or enum.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * The parameters for the {@link DemoVaultCoverageChecker} constructor.\n */\nexport interface DemoVaultCoverageCheckerConstructorParams {\n  /**\n   * The absolute path of the plugin repo root \u2014 the folder containing `demo-vault/` and the source being\n   * reflected. Callers typically pass `getRootFolder() ?? process.cwd()`.\n   */\n  readonly rootFolder: string;\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findStaleReferences}.\n */\nexport interface DemoVaultCoverageCheckerFindStaleReferencesParams {\n  /**\n   * The receiver whose `` `${receiver}.<member>` `` references are scanned for in the demo corpus.\n   */\n  readonly receiver: string;\n\n  /**\n   * The members that currently exist on the receiver; any referenced member not in this set is stale.\n   */\n  readonly validMembers: string[];\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findUndemonstratedMembers}.\n */\nexport interface DemoVaultCoverageCheckerFindUndemonstratedMembersParams {\n  /**\n   * The member names that must each appear in the demo corpus.\n   */\n  readonly members: string[];\n\n  /**\n   * When set, a member is demonstrated only if `` `${receiver}.${member}` `` appears (e.g. a context object's\n   * methods); when absent, the bare member name is looked up (e.g. a config option).\n   */\n  readonly receiver?: string;\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findUnlinkedFeatureDocs}.\n */\nexport interface DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams {\n  /**\n   * The docs folder (relative to the repo root) whose top-level `*.md` files are the feature docs.\n   */\n  readonly docsFolder: string;\n\n  /**\n   * The doc basenames (without `.md`) that are NOT per-feature pages and so need no linking demo note.\n   */\n  readonly nonFeatureDocs: string[];\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.getExportedFunctionNames}.\n */\nexport interface DemoVaultCoverageCheckerGetExportedFunctionNamesParams {\n  /**\n   * The source file path (relative to the repo root) whose `export function`s are parsed.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.getInterfaceMembers}.\n */\nexport interface DemoVaultCoverageCheckerGetInterfaceMembersParams {\n  /**\n   * The name of the `export interface`, `export class`, or `export enum` to parse.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface, class, or enum.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Configures the feature-doc linking check.\n */\nexport interface DemoVaultDocsCoverageSpec {\n  /**\n   * The docs folder (relative to the repo root) whose top-level `*.md` files are the feature docs.\n   */\n  readonly folder: string;\n\n  /**\n   * The doc basenames (without `.md`) that are NOT per-feature pages and so need no linking demo note.\n   */\n  readonly nonFeatureDocs: string[];\n}\n\n/**\n * Reflects a module's exported functions, each demonstrated by its bare name in the demo corpus.\n */\nexport interface DemoVaultFunctionsCoverageSpec {\n  /**\n   * The source file path (relative to the repo root) whose `export function`s must each be demonstrated.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Reflects a single interface's members and demonstrates them via `` `${receiver}.<member>` `` references.\n */\nexport interface DemoVaultInterfaceCoverageSpec {\n  /**\n   * The name of the `export interface`, `export class`, or `export enum` to reflect.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * Whether the demonstrated members are the reflected type's methods or its properties (enum members count as\n   * properties).\n   */\n  readonly kind: DemoVaultInterfaceMemberKind;\n\n  /**\n   * The identifier the notes call the members on (e.g. `codeButtonContext`).\n   */\n  readonly receiver: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface, class, or enum.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Whether an interface's demonstrated members are its methods or its properties.\n */\nexport type DemoVaultInterfaceMemberKind = 'methods' | 'properties';\n\n/**\n * Configures the guard that the reflected surface is non-trivial (protects against a parsing regression\n * silently emptying every other check).\n */\nexport interface DemoVaultNonTrivialGuardSpec {\n  /**\n   * A demo note (path relative to the demo vault) that must be present.\n   */\n  readonly expectDemoNote: string;\n\n  /**\n   * A member that must be reflected from {@link DemoVaultNonTrivialGuardSpec.interfaceName}.\n   */\n  readonly expectMember: string;\n\n  /**\n   * The name of the `export interface`, `export class`, or `export enum` whose members are re-parsed for the\n   * guard.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface, class, or enum.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * The parsed members of a source interface, class, or enum.\n */\nexport interface InterfaceMembers {\n  /**\n   * Every member \u2014 {@link InterfaceMembers.methods} followed by {@link InterfaceMembers.properties}.\n   */\n  readonly all: string[];\n\n  /**\n   * The method members (declared as `name(...)`).\n   */\n  readonly methods: string[];\n\n  /**\n   * The property members (declared as `name?: ...`).\n   */\n  readonly properties: string[];\n}\n\n/**\n * The parameters for {@link registerDemoVaultCoverageSuite}.\n */\nexport interface RegisterDemoVaultCoverageSuiteParams {\n  /**\n   * The config interfaces whose options must each be demonstrated by their bare name.\n   */\n  readonly configInterfaces: DemoVaultConfigInterfaceCoverageSpec[];\n\n  /**\n   * The feature-doc linking check, or `undefined` when the plugin ships no `docs/` folder.\n   */\n  readonly docs?: DemoVaultDocsCoverageSpec;\n\n  /**\n   * The modules whose `export function`s must each be demonstrated by their bare name, or `undefined` when the\n   * plugin exposes no such module to check.\n   */\n  readonly functionModules?: DemoVaultFunctionsCoverageSpec[];\n\n  /**\n   * The interfaces whose members must each be demonstrated (and referenced without drift).\n   */\n  readonly interfaces: DemoVaultInterfaceCoverageSpec[];\n\n  /**\n   * The guard that keeps the reflected surface non-trivial.\n   */\n  readonly nonTrivialGuard: DemoVaultNonTrivialGuardSpec;\n\n  /**\n   * The absolute path of the plugin repo root. Callers typically pass `getRootFolder() ?? process.cwd()`.\n   */\n  readonly rootFolder: string;\n}\n\n/**\n * Reflects a plugin's public surface from source and checks its in-repo `demo-vault/` stays in sync with it.\n *\n * Every method is a pure query over files under the repo root (the demo corpus is read once and cached), so\n * the checker is trivially unit-testable against a fixture repo and carries no test-framework dependency.\n */\nexport class DemoVaultCoverageChecker {\n  private cachedCorpus: null | string = null;\n  private readonly demoVaultFolder: string;\n  private readonly rootFolder: string;\n\n  /**\n   * Creates a checker rooted at a plugin repo.\n   *\n   * @param params - The parameters for the constructor.\n   */\n  public constructor(params: DemoVaultCoverageCheckerConstructorParams) {\n    this.rootFolder = params.rootFolder;\n    this.demoVaultFolder = join(this.rootFolder, ObsidianPluginRepoPaths.DemoVault);\n  }\n\n  /**\n   * Collects the demo notes as paths relative to the demo vault folder (for a non-trivial-surface guard).\n   *\n   * @returns The relative paths of every `*.md` note in the demo vault.\n   */\n  public collectDemoNoteRelativePaths(): string[] {\n    return this.collectMarkdownFiles(this.demoVaultFolder).map((file) => relative(this.demoVaultFolder, file));\n  }\n\n  /**\n   * Finds members that the demo notes reference on a receiver but that no longer exist on it (rename drift).\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The distinct stale member names referenced in the demo corpus.\n   */\n  public findStaleReferences(params: DemoVaultCoverageCheckerFindStaleReferencesParams): string[] {\n    const validMembers = new Set(params.validMembers);\n    const referenced = [...this.readCorpus().matchAll(new RegExp(String.raw`${params.receiver}\\.(?<member>\\w+)`, 'g'))]\n      .map((match) => getMandatoryNamedGroup(match, 'member'));\n    return [...new Set(referenced)].filter((member) => !validMembers.has(member));\n  }\n\n  /**\n   * Finds members that are not demonstrated anywhere in the demo corpus.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The member names with no demonstration.\n   */\n  public findUndemonstratedMembers(params: DemoVaultCoverageCheckerFindUndemonstratedMembersParams): string[] {\n    const corpus = this.readCorpus();\n    return params.members.filter((member) => {\n      const needle = params.receiver === undefined ? member : `${params.receiver}.${member}`;\n      return !corpus.includes(needle);\n    });\n  }\n\n  /**\n   * Finds feature docs that no demo note links to.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The feature-doc basenames (without `.md`) not linked from any demo note.\n   */\n  public findUnlinkedFeatureDocs(params: DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams): string[] {\n    const nonFeatureDocs = new Set(params.nonFeatureDocs);\n    const featureDocs = readdirSync(join(this.rootFolder, params.docsFolder))\n      .filter((file) => file.endsWith('.md'))\n      .map((file) => file.replace(/\\.md$/, ''))\n      .filter((name) => !nonFeatureDocs.has(name));\n    const linkedDocs = new Set(\n      [...this.readCorpus().matchAll(/docs\\/(?<doc>[\\w-]+)\\.md/g)].map((match) => getMandatoryNamedGroup(match, 'doc'))\n    );\n    return featureDocs.filter((doc) => !linkedDocs.has(doc));\n  }\n\n  /**\n   * Parses the names of the `export function`s (including `async` and generator declarations) in a source file.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The exported function names in source order.\n   */\n  public getExportedFunctionNames(params: DemoVaultCoverageCheckerGetExportedFunctionNamesParams): string[] {\n    const source = readFileSync(join(this.rootFolder, params.sourcePath), 'utf-8');\n    return [...source.matchAll(/^export (?:async )?function\\*? (?<name>\\w+)/gm)]\n      .map((match) => getMandatoryNamedGroup(match, 'name'));\n  }\n\n  /**\n   * Parses the members of an `export interface`, `export class`, or `export enum` declared in a source file.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The parsed {@link InterfaceMembers}.\n   * @throws When the interface, class, or enum cannot be found in the source file.\n   */\n  public getInterfaceMembers(params: DemoVaultCoverageCheckerGetInterfaceMembersParams): InterfaceMembers {\n    const source = readFileSync(join(this.rootFolder, params.sourcePath), 'utf-8');\n    const match = new RegExp(String.raw`export (?<keyword>interface|class|enum) ${params.interfaceName}\\b[^{]*\\{(?<body>[\\s\\S]*?)\\n\\}`).exec(source);\n    if (!match) {\n      throw new Error(`Could not find interface ${params.interfaceName}`);\n    }\n    return parseMembers(getMandatoryNamedGroup(match, 'keyword'), getMandatoryNamedGroup(match, 'body'));\n  }\n\n  /**\n   * Reads and caches the demo corpus \u2014 every `*.md` note in the demo vault joined into one string.\n   *\n   * @returns The concatenated demo-note contents.\n   */\n  public readCorpus(): string {\n    this.cachedCorpus ??= this.collectMarkdownFiles(this.demoVaultFolder)\n      .map((file) => readFileSync(file, 'utf-8'))\n      .join('\\n');\n    return this.cachedCorpus;\n  }\n\n  private collectMarkdownFiles(folder: string): string[] {\n    const result: string[] = [];\n    for (const entry of readdirSync(folder, { withFileTypes: true })) {\n      if (entry.isDirectory()) {\n        if (entry.name === ObsidianPluginRepoPaths.NodeModules as string) {\n          continue;\n        }\n        result.push(...this.collectMarkdownFiles(join(folder, entry.name)));\n      } else if (entry.name.endsWith('.md')) {\n        result.push(join(folder, entry.name));\n      }\n    }\n    return result;\n  }\n}\n\n/**\n * Registers a `vitest` suite that keeps a plugin's in-repo `demo-vault/` in sync with its public surface.\n *\n * Call it once from a plugin's `demo-vault.no-app.integration.test.ts`; it registers one test per check,\n * delegating to {@link DemoVaultCoverageChecker}.\n *\n * @param params - The declarative coverage specification.\n */\nexport function registerDemoVaultCoverageSuite(params: RegisterDemoVaultCoverageSuiteParams): void {\n  const checker = new DemoVaultCoverageChecker({ rootFolder: params.rootFolder });\n\n  describe('demo-vault coverage', () => {\n    for (const spec of params.interfaces) {\n      it(`demonstrates every ${spec.interfaceName} ${spec.kind}`, () => {\n        const members = checker.getInterfaceMembers(spec);\n        const demonstrated = members[spec.kind];\n        expect(demonstrated.length).toBeGreaterThan(0);\n        expect(checker.findUndemonstratedMembers({ members: demonstrated, receiver: spec.receiver })).toEqual([]);\n      });\n\n      it(`references no ${spec.interfaceName} member that no longer exists`, () => {\n        const members = checker.getInterfaceMembers(spec);\n        expect(checker.findStaleReferences({ receiver: spec.receiver, validMembers: members.all })).toEqual([]);\n      });\n    }\n\n    for (const spec of params.configInterfaces) {\n      it(`demonstrates every ${spec.interfaceName} option`, () => {\n        const members = checker.getInterfaceMembers(spec);\n        expect(members.properties.length).toBeGreaterThan(0);\n        expect(checker.findUndemonstratedMembers({ members: members.properties })).toEqual([]);\n      });\n    }\n\n    for (const spec of params.functionModules ?? []) {\n      it(`demonstrates every exported function in ${spec.sourcePath}`, () => {\n        const functionNames = checker.getExportedFunctionNames(spec);\n        expect(functionNames.length).toBeGreaterThan(0);\n        expect(checker.findUndemonstratedMembers({ members: functionNames })).toEqual([]);\n      });\n    }\n\n    const docs = params.docs;\n    if (docs) {\n      it('links a demo note for every feature doc', () => {\n        expect(checker.findUnlinkedFeatureDocs({ docsFolder: docs.folder, nonFeatureDocs: docs.nonFeatureDocs }))\n          .toEqual([]);\n      });\n    }\n\n    it('keeps the reflected surface non-trivial', () => {\n      const guard = params.nonTrivialGuard;\n      const members = checker.getInterfaceMembers(guard);\n      expect(members.all).toContain(guard.expectMember);\n      expect(checker.collectDemoNoteRelativePaths()).toContain(guard.expectDemoNote);\n    });\n  });\n}\n\nconst CLASS_MEMBER_MODIFIERS = String.raw`(?:(?:public|private|protected|readonly|static|abstract|override)\\s+)*`;\n\nfunction buildMembers(methods: string[], properties: string[]): InterfaceMembers {\n  return {\n    all: [...methods, ...properties],\n    methods,\n    properties\n  };\n}\n\nfunction extractClassMethodNames(classBody: string): string[] {\n  return [...classBody.matchAll(new RegExp(String.raw`^ {2}(?<modifiers>${CLASS_MEMBER_MODIFIERS})(?<name>\\w+)(?:<[^>]*>)?\\(`, 'gm'))]\n    .filter((match) => !isNonPublicMember(getMandatoryNamedGroup(match, 'modifiers')))\n    .map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction extractClassPropertyNames(classBody: string): string[] {\n  return [...classBody.matchAll(new RegExp(String.raw`^ {2}(?<modifiers>${CLASS_MEMBER_MODIFIERS})(?<name>\\w+)\\s*\\??\\s*[:=]`, 'gm'))]\n    .filter((match) => !isNonPublicMember(getMandatoryNamedGroup(match, 'modifiers')))\n    .map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction extractEnumMemberNames(enumBody: string): string[] {\n  return [...enumBody.matchAll(/^ {2}(?<name>\\w+)/gm)].map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction extractMethodNames(interfaceBody: string): string[] {\n  return [...interfaceBody.matchAll(/^ {2}(?<name>\\w+)(?:<[^>]*>)?\\(/gm)].map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction extractPropertyNames(interfaceBody: string): string[] {\n  return [...interfaceBody.matchAll(/^ {2}(?<name>\\w+)\\??:/gm)].map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction isNonPublicMember(modifiers: string): boolean {\n  return /\\b(?:private|protected)\\b/.test(modifiers);\n}\n\nfunction parseMembers(keyword: string, body: string): InterfaceMembers {\n  switch (keyword) {\n    case 'class': {\n      return buildMembers(extractClassMethodNames(body), extractClassPropertyNames(body));\n    }\n    case 'enum': {\n      return buildMembers([], extractEnumMemberNames(body));\n    }\n    default: {\n      return buildMembers(extractMethodNames(body), extractPropertyNames(body));\n    }\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAmBA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,+BAA+B;AACxC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,8BAA8B;AAqPhC,MAAM,yBAAyB;AAAA,EAC5B,eAA8B;AAAA,EACrB;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAAmD;AACpE,SAAK,aAAa,OAAO;AACzB,SAAK,kBAAkB,KAAK,KAAK,YAAY,wBAAwB,SAAS;AAAA,EAChF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,+BAAyC;AAC9C,WAAO,KAAK,qBAAqB,KAAK,eAAe,EAAE,IAAI,CAAC,SAAS,SAAS,KAAK,iBAAiB,IAAI,CAAC;AAAA,EAC3G;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,oBAAoB,QAAqE;AAC9F,UAAM,eAAe,IAAI,IAAI,OAAO,YAAY;AAChD,UAAM,aAAa,CAAC,GAAG,KAAK,WAAW,EAAE,SAAS,IAAI,OAAO,OAAO,MAAM,OAAO,QAAQ,oBAAoB,GAAG,CAAC,CAAC,EAC/G,IAAI,CAAC,UAAU,uBAAuB,OAAO,QAAQ,CAAC;AACzD,WAAO,CAAC,GAAG,IAAI,IAAI,UAAU,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,aAAa,IAAI,MAAM,CAAC;AAAA,EAC9E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,0BAA0B,QAA2E;AAC1G,UAAM,SAAS,KAAK,WAAW;AAC/B,WAAO,OAAO,QAAQ,OAAO,CAAC,WAAW;AACvC,YAAM,SAAS,OAAO,aAAa,SAAY,SAAS,GAAG,OAAO,QAAQ,IAAI,MAAM;AACpF,aAAO,CAAC,OAAO,SAAS,MAAM;AAAA,IAChC,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,wBAAwB,QAAyE;AACtG,UAAM,iBAAiB,IAAI,IAAI,OAAO,cAAc;AACpD,UAAM,cAAc,YAAY,KAAK,KAAK,YAAY,OAAO,UAAU,CAAC,EACrE,OAAO,CAAC,SAAS,KAAK,SAAS,KAAK,CAAC,EACrC,IAAI,CAAC,SAAS,KAAK,QAAQ,SAAS,EAAE,CAAC,EACvC,OAAO,CAAC,SAAS,CAAC,eAAe,IAAI,IAAI,CAAC;AAC7C,UAAM,aAAa,IAAI;AAAA,MACrB,CAAC,GAAG,KAAK,WAAW,EAAE,SAAS,2BAA2B,CAAC,EAAE,IAAI,CAAC,UAAU,uBAAuB,OAAO,KAAK,CAAC;AAAA,IAClH;AACA,WAAO,YAAY,OAAO,CAAC,QAAQ,CAAC,WAAW,IAAI,GAAG,CAAC;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,yBAAyB,QAA0E;AACxG,UAAM,SAAS,aAAa,KAAK,KAAK,YAAY,OAAO,UAAU,GAAG,OAAO;AAC7E,WAAO,CAAC,GAAG,OAAO,SAAS,+CAA+C,CAAC,EACxE,IAAI,CAAC,UAAU,uBAAuB,OAAO,MAAM,CAAC;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,oBAAoB,QAA6E;AACtG,UAAM,SAAS,aAAa,KAAK,KAAK,YAAY,OAAO,UAAU,GAAG,OAAO;AAC7E,UAAM,QAAQ,IAAI,OAAO,OAAO,8CAA8C,OAAO,aAAa,gCAAgC,EAAE,KAAK,MAAM;AAC/I,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,4BAA4B,OAAO,aAAa,EAAE;AAAA,IACpE;AACA,WAAO,aAAa,uBAAuB,OAAO,SAAS,GAAG,uBAAuB,OAAO,MAAM,CAAC;AAAA,EACrG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,aAAqB;AAC1B,SAAK,iBAAiB,KAAK,qBAAqB,KAAK,eAAe,EACjE,IAAI,CAAC,SAAS,aAAa,MAAM,OAAO,CAAC,EACzC,KAAK,IAAI;AACZ,WAAO,KAAK;AAAA,EACd;AAAA,EAEQ,qBAAqB,QAA0B;AACrD,UAAM,SAAmB,CAAC;AAC1B,eAAW,SAAS,YAAY,QAAQ,EAAE,eAAe,KAAK,CAAC,GAAG;AAChE,UAAI,MAAM,YAAY,GAAG;AACvB,YAAI,MAAM,SAAS,wBAAwB,aAAuB;AAChE;AAAA,QACF;AACA,eAAO,KAAK,GAAG,KAAK,qBAAqB,KAAK,QAAQ,MAAM,IAAI,CAAC,CAAC;AAAA,MACpE,WAAW,MAAM,KAAK,SAAS,KAAK,GAAG;AACrC,eAAO,KAAK,KAAK,QAAQ,MAAM,IAAI,CAAC;AAAA,MACtC;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;AAUO,SAAS,+BAA+B,QAAoD;AACjG,QAAM,UAAU,IAAI,yBAAyB,EAAE,YAAY,OAAO,WAAW,CAAC;AAE9E,WAAS,uBAAuB,MAAM;AACpC,eAAW,QAAQ,OAAO,YAAY;AACpC,SAAG,sBAAsB,KAAK,aAAa,IAAI,KAAK,IAAI,IAAI,MAAM;AAChE,cAAM,UAAU,QAAQ,oBAAoB,IAAI;AAChD,cAAM,eAAe,QAAQ,KAAK,IAAI;AACtC,eAAO,aAAa,MAAM,EAAE,gBAAgB,CAAC;AAC7C,eAAO,QAAQ,0BAA0B,EAAE,SAAS,cAAc,UAAU,KAAK,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;AAAA,MAC1G,CAAC;AAED,SAAG,iBAAiB,KAAK,aAAa,iCAAiC,MAAM;AAC3E,cAAM,UAAU,QAAQ,oBAAoB,IAAI;AAChD,eAAO,QAAQ,oBAAoB,EAAE,UAAU,KAAK,UAAU,cAAc,QAAQ,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;AAAA,MACxG,CAAC;AAAA,IACH;AAEA,eAAW,QAAQ,OAAO,kBAAkB;AAC1C,SAAG,sBAAsB,KAAK,aAAa,WAAW,MAAM;AAC1D,cAAM,UAAU,QAAQ,oBAAoB,IAAI;AAChD,eAAO,QAAQ,WAAW,MAAM,EAAE,gBAAgB,CAAC;AACnD,eAAO,QAAQ,0BAA0B,EAAE,SAAS,QAAQ,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;AAAA,MACvF,CAAC;AAAA,IACH;AAEA,eAAW,QAAQ,OAAO,mBAAmB,CAAC,GAAG;AAC/C,SAAG,2CAA2C,KAAK,UAAU,IAAI,MAAM;AACrE,cAAM,gBAAgB,QAAQ,yBAAyB,IAAI;AAC3D,eAAO,cAAc,MAAM,EAAE,gBAAgB,CAAC;AAC9C,eAAO,QAAQ,0BAA0B,EAAE,SAAS,cAAc,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;AAAA,MAClF,CAAC;AAAA,IACH;AAEA,UAAM,OAAO,OAAO;AACpB,QAAI,MAAM;AACR,SAAG,2CAA2C,MAAM;AAClD,eAAO,QAAQ,wBAAwB,EAAE,YAAY,KAAK,QAAQ,gBAAgB,KAAK,eAAe,CAAC,CAAC,EACrG,QAAQ,CAAC,CAAC;AAAA,MACf,CAAC;AAAA,IACH;AAEA,OAAG,2CAA2C,MAAM;AAClD,YAAM,QAAQ,OAAO;AACrB,YAAM,UAAU,QAAQ,oBAAoB,KAAK;AACjD,aAAO,QAAQ,GAAG,EAAE,UAAU,MAAM,YAAY;AAChD,aAAO,QAAQ,6BAA6B,CAAC,EAAE,UAAU,MAAM,cAAc;AAAA,IAC/E,CAAC;AAAA,EACH,CAAC;AACH;AAEA,MAAM,yBAAyB,OAAO;AAEtC,SAAS,aAAa,SAAmB,YAAwC;AAC/E,SAAO;AAAA,IACL,KAAK,CAAC,GAAG,SAAS,GAAG,UAAU;AAAA,IAC/B;AAAA,IACA;AAAA,EACF;AACF;AAEA,SAAS,wBAAwB,WAA6B;AAC5D,SAAO,CAAC,GAAG,UAAU,SAAS,IAAI,OAAO,OAAO,wBAAwB,sBAAsB,+BAA+B,IAAI,CAAC,CAAC,EAChI,OAAO,CAAC,UAAU,CAAC,kBAAkB,uBAAuB,OAAO,WAAW,CAAC,CAAC,EAChF,IAAI,CAAC,UAAU,uBAAuB,OAAO,MAAM,CAAC;AACzD;AAEA,SAAS,0BAA0B,WAA6B;AAC9D,SAAO,CAAC,GAAG,UAAU,SAAS,IAAI,OAAO,OAAO,wBAAwB,sBAAsB,8BAA8B,IAAI,CAAC,CAAC,EAC/H,OAAO,CAAC,UAAU,CAAC,kBAAkB,uBAAuB,OAAO,WAAW,CAAC,CAAC,EAChF,IAAI,CAAC,UAAU,uBAAuB,OAAO,MAAM,CAAC;AACzD;AAEA,SAAS,uBAAuB,UAA4B;AAC1D,SAAO,CAAC,GAAG,SAAS,SAAS,qBAAqB,CAAC,EAAE,IAAI,CAAC,UAAU,uBAAuB,OAAO,MAAM,CAAC;AAC3G;AAEA,SAAS,mBAAmB,eAAiC;AAC3D,SAAO,CAAC,GAAG,cAAc,SAAS,mCAAmC,CAAC,EAAE,IAAI,CAAC,UAAU,uBAAuB,OAAO,MAAM,CAAC;AAC9H;AAEA,SAAS,qBAAqB,eAAiC;AAC7D,SAAO,CAAC,GAAG,cAAc,SAAS,yBAAyB,CAAC,EAAE,IAAI,CAAC,UAAU,uBAAuB,OAAO,MAAM,CAAC;AACpH;AAEA,SAAS,kBAAkB,WAA4B;AACrD,SAAO,4BAA4B,KAAK,SAAS;AACnD;AAEA,SAAS,aAAa,SAAiB,MAAgC;AACrE,UAAQ,SAAS;AAAA,IACf,KAAK,SAAS;AACZ,aAAO,aAAa,wBAAwB,IAAI,GAAG,0BAA0B,IAAI,CAAC;AAAA,IACpF;AAAA,IACA,KAAK,QAAQ;AACX,aAAO,aAAa,CAAC,GAAG,uBAAuB,IAAI,CAAC;AAAA,IACtD;AAAA,IACA,SAAS;AACP,aAAO,aAAa,mBAAmB,IAAI,GAAG,qBAAqB,IAAI,CAAC;AAAA,IAC1E;AAAA,EACF;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/demo-vault-coverage.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Static coverage/freshness checks that keep a plugin's in-repo `demo-vault/` in sync with its public surface.\n *\n * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. These helpers reflect the real\n * public API/config/docs straight from source and assert \u2014 WITHOUT launching Obsidian \u2014 that every feature is\n * demonstrated in the notes and that the notes reference no API member that no longer exists (rename drift).\n * The runtime behavior of the plugin is covered by its other integration tests, not by the demo vault; the\n * vault is a learning resource, and these checks only guard that it stays truthful.\n *\n * They also enforce the demo-vault AUTHORING convention \u2014 every note opens with an `# H1` and a plain\n * prose paragraph, every note is reachable from the start note, and no note uses a `[[wikilink]]` or a\n * `[Docs](\u2026)` line. These checks are unconditional: the demo vault is the published documentation, read\n * in Obsidian AND on GitHub (where a wikilink does not render), so a note that breaks the convention is\n * broken for real readers. `authoring` only tunes them (which note is the start, which notes sit outside\n * the learning path); it cannot switch them off.\n *\n * Two layers are exposed:\n * - {@link DemoVaultCoverageChecker} \u2014 a framework-agnostic core that reads the corpus, parses interface /\n *   class / enum members and exported functions, and returns diagnostic arrays (what is undemonstrated / stale\n *   / unlinked / off-convention).\n * - {@link registerDemoVaultCoverageSuite} \u2014 a thin wrapper that registers a `vitest` suite over the core, so\n *   a plugin's `demo-vault.no-app.integration.test.ts` is a single declarative call.\n */\n\nimport {\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport {\n  describe,\n  expect,\n  it\n} from 'vitest';\n\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport { ObsidianPluginRepoPaths } from '../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport {\n  dirname,\n  join,\n  relative\n} from '../path.ts';\nimport { getMandatoryNamedGroup } from '../reg-exp.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\n\n/**\n * Tunes the always-on authoring checks. It cannot disable them \u2014 see the file overview.\n */\nexport interface DemoVaultAuthoringSpec {\n  /**\n   * The notes (paths relative to the demo vault) that sit outside the learning path and are therefore\n   * exempt from every authoring check. Defaults to the vault's own `README.md`, which addresses someone\n   * browsing the repo on GitHub rather than a reader working through the vault.\n   */\n  readonly excludedNotes?: string[];\n\n  /**\n   * The note (path relative to the demo vault) every other note must be reachable from. Defaults to\n   * `00 Start.md`.\n   */\n  readonly startNote?: string;\n}\n\n/**\n * Reflects a config interface whose options are demonstrated by their bare name.\n */\nexport interface DemoVaultConfigInterfaceCoverageSpec {\n  /**\n   * The name of the `export interface`, `export class`, or `export enum` whose properties are the config\n   * options.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface, class, or enum.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * The parameters for the {@link DemoVaultCoverageChecker} constructor.\n */\nexport interface DemoVaultCoverageCheckerConstructorParams {\n  /**\n   * The notes (paths relative to the demo vault) exempt from the authoring checks. Defaults to the\n   * vault's own `README.md`.\n   */\n  readonly excludedNotes?: string[];\n\n  /**\n   * The absolute path of the plugin repo root \u2014 the folder containing `demo-vault/` and the source being\n   * reflected. Callers typically pass `getRootFolder() ?? process.cwd()`.\n   */\n  readonly rootFolder: string;\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findStaleReferences}.\n */\nexport interface DemoVaultCoverageCheckerFindStaleReferencesParams {\n  /**\n   * The receiver whose `` `${receiver}.<member>` `` references are scanned for in the demo corpus.\n   */\n  readonly receiver: string;\n\n  /**\n   * The members that currently exist on the receiver; any referenced member not in this set is stale.\n   */\n  readonly validMembers: string[];\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findUndemonstratedMembers}.\n */\nexport interface DemoVaultCoverageCheckerFindUndemonstratedMembersParams {\n  /**\n   * The member names that must each appear in the demo corpus.\n   */\n  readonly members: string[];\n\n  /**\n   * When set, a member is demonstrated only if `` `${receiver}.${member}` `` appears (e.g. a context object's\n   * methods); when absent, the bare member name is looked up (e.g. a config option).\n   */\n  readonly receiver?: string;\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findUnlinkedFeatureDocs}.\n */\nexport interface DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams {\n  /**\n   * The docs folder (relative to the repo root) whose top-level `*.md` files are the feature docs.\n   */\n  readonly docsFolder: string;\n\n  /**\n   * The doc basenames (without `.md`) that are NOT per-feature pages and so need no linking demo note.\n   */\n  readonly nonFeatureDocs: string[];\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findUnreachableNotes}.\n */\nexport interface DemoVaultCoverageCheckerFindUnreachableNotesParams {\n  /**\n   * The note (path relative to the demo vault) the walk starts from, e.g. `00 Start.md`.\n   */\n  readonly startNote: string;\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.getExportedFunctionNames}.\n */\nexport interface DemoVaultCoverageCheckerGetExportedFunctionNamesParams {\n  /**\n   * The source file path (relative to the repo root) whose `export function`s are parsed.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.getInterfaceMembers}.\n */\nexport interface DemoVaultCoverageCheckerGetInterfaceMembersParams {\n  /**\n   * The name of the `export interface`, `export class`, or `export enum` to parse.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface, class, or enum.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Configures the feature-doc linking check.\n */\nexport interface DemoVaultDocsCoverageSpec {\n  /**\n   * The docs folder (relative to the repo root) whose top-level `*.md` files are the feature docs.\n   */\n  readonly folder: string;\n\n  /**\n   * The doc basenames (without `.md`) that are NOT per-feature pages and so need no linking demo note.\n   */\n  readonly nonFeatureDocs: string[];\n}\n\n/**\n * Reflects a module's exported functions, each demonstrated by its bare name in the demo corpus.\n */\nexport interface DemoVaultFunctionsCoverageSpec {\n  /**\n   * The source file path (relative to the repo root) whose `export function`s must each be demonstrated.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Reflects a single interface's members and demonstrates them via `` `${receiver}.<member>` `` references.\n */\nexport interface DemoVaultInterfaceCoverageSpec {\n  /**\n   * The name of the `export interface`, `export class`, or `export enum` to reflect.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * Whether the demonstrated members are the reflected type's methods or its properties (enum members count as\n   * properties).\n   */\n  readonly kind: DemoVaultInterfaceMemberKind;\n\n  /**\n   * The identifier the notes call the members on (e.g. `codeButtonContext`).\n   */\n  readonly receiver: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface, class, or enum.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Whether an interface's demonstrated members are its methods or its properties.\n */\nexport type DemoVaultInterfaceMemberKind = 'methods' | 'properties';\n\n/**\n * Configures the guard that the reflected surface is non-trivial (protects against a parsing regression\n * silently emptying every other check).\n */\nexport interface DemoVaultNonTrivialGuardSpec {\n  /**\n   * A demo note (path relative to the demo vault) that must be present.\n   */\n  readonly expectDemoNote: string;\n\n  /**\n   * A member that must be reflected from {@link DemoVaultNonTrivialGuardSpec.interfaceName}.\n   */\n  readonly expectMember: string;\n\n  /**\n   * The name of the `export interface`, `export class`, or `export enum` whose members are re-parsed for the\n   * guard.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface, class, or enum.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * A single demo note, as read from the demo vault.\n */\nexport interface DemoVaultNote {\n  /**\n   * The note's raw Markdown content.\n   */\n  readonly content: string;\n\n  /**\n   * The note's path relative to the demo vault folder, e.g. `00 Start.md`.\n   */\n  readonly relativePath: string;\n}\n\n/**\n * The parsed members of a source interface, class, or enum.\n */\nexport interface InterfaceMembers {\n  /**\n   * Every member \u2014 {@link InterfaceMembers.methods} followed by {@link InterfaceMembers.properties}.\n   */\n  readonly all: string[];\n\n  /**\n   * The method members (declared as `name(...)`).\n   */\n  readonly methods: string[];\n\n  /**\n   * The property members (declared as `name?: ...`).\n   */\n  readonly properties: string[];\n}\n\n/**\n * The parameters for {@link registerDemoVaultCoverageSuite}.\n */\nexport interface RegisterDemoVaultCoverageSuiteParams {\n  /**\n   * Tunes the always-on authoring checks, or `undefined` to take their defaults. It cannot disable them.\n   */\n  readonly authoring?: DemoVaultAuthoringSpec;\n\n  /**\n   * The config interfaces whose options must each be demonstrated by their bare name.\n   */\n  readonly configInterfaces: DemoVaultConfigInterfaceCoverageSpec[];\n\n  /**\n   * The feature-doc linking check, or `undefined` when the plugin ships no `docs/` folder.\n   */\n  readonly docs?: DemoVaultDocsCoverageSpec;\n\n  /**\n   * The modules whose `export function`s must each be demonstrated by their bare name, or `undefined` when the\n   * plugin exposes no such module to check.\n   */\n  readonly functionModules?: DemoVaultFunctionsCoverageSpec[];\n\n  /**\n   * The interfaces whose members must each be demonstrated (and referenced without drift).\n   */\n  readonly interfaces: DemoVaultInterfaceCoverageSpec[];\n\n  /**\n   * The guard that keeps the reflected surface non-trivial.\n   */\n  readonly nonTrivialGuard: DemoVaultNonTrivialGuardSpec;\n\n  /**\n   * The absolute path of the plugin repo root. Callers typically pass `getRootFolder() ?? process.cwd()`.\n   */\n  readonly rootFolder: string;\n}\n\n/**\n * Reflects a plugin's public surface from source and checks its in-repo `demo-vault/` stays in sync with it.\n *\n * Every method is a pure query over files under the repo root (the demo corpus is read once and cached), so\n * the checker is trivially unit-testable against a fixture repo and carries no test-framework dependency.\n */\nexport class DemoVaultCoverageChecker {\n  private cachedCorpus: null | string = null;\n  private cachedNotes: DemoVaultNote[] | null = null;\n  private readonly demoVaultFolder: string;\n  private readonly excludedNotes: Set<string>;\n  private readonly rootFolder: string;\n\n  /**\n   * Creates a checker rooted at a plugin repo.\n   *\n   * @param params - The parameters for the constructor.\n   */\n  public constructor(params: DemoVaultCoverageCheckerConstructorParams) {\n    this.rootFolder = params.rootFolder;\n    this.demoVaultFolder = join(this.rootFolder, ObsidianPluginRepoPaths.DemoVault);\n    this.excludedNotes = new Set(params.excludedNotes ?? DEFAULT_EXCLUDED_NOTES);\n  }\n\n  /**\n   * Collects the demo notes as paths relative to the demo vault folder (for a non-trivial-surface guard).\n   *\n   * @returns The relative paths of every `*.md` note in the demo vault.\n   */\n  public collectDemoNoteRelativePaths(): string[] {\n    return this.collectNotes().map((note) => note.relativePath);\n  }\n\n  /**\n   * Reads and caches every demo note individually \u2014 the per-note view the authoring checks work on, as\n   * opposed to the concatenated {@link DemoVaultCoverageChecker.readCorpus}.\n   *\n   * @returns Every `*.md` note in the demo vault, excluded ones included.\n   */\n  public collectNotes(): DemoVaultNote[] {\n    this.cachedNotes ??= this.collectMarkdownFiles(this.demoVaultFolder).map((file) => ({\n      content: readFileSync(file, 'utf-8'),\n      relativePath: relative(this.demoVaultFolder, file)\n    }));\n    return this.cachedNotes;\n  }\n\n  /**\n   * Finds notes carrying a `[Docs](\u2026)` link line. The note IS the documentation, so a line pointing\n   * elsewhere for the real explanation is the shape this convention exists to remove.\n   *\n   * @returns The relative paths of the offending notes.\n   */\n  public findNotesWithDocsLinks(): string[] {\n    return this.collectCheckableNotes()\n      .filter((note) => getLinesOutsideFences(note.content).some((line) => DOCS_LINK_REG_EXP.test(line)))\n      .map((note) => note.relativePath);\n  }\n\n  /**\n   * Finds notes that do not open with an `# H1` (frontmatter aside).\n   *\n   * @returns The relative paths of the offending notes.\n   */\n  public findNotesWithoutH1(): string[] {\n    return this.collectCheckableNotes()\n      .filter((note) => !hasH1(note.content))\n      .map((note) => note.relativePath);\n  }\n\n  /**\n   * Finds notes with no prose paragraph before their first code fence \u2014 the 1-3 sentences saying what the\n   * feature does and why a reader would want it, without which the note is a button with no lesson.\n   *\n   * @returns The relative paths of the offending notes.\n   */\n  public findNotesWithoutIntroProse(): string[] {\n    return this.collectCheckableNotes()\n      .filter((note) => !hasIntroProse(note.content))\n      .map((note) => note.relativePath);\n  }\n\n  /**\n   * Finds notes using an Obsidian `[[wikilink]]` outside a code fence. The demo vault is also read on\n   * GitHub, where a wikilink renders as literal brackets and leads nowhere. A wikilink shown INSIDE a\n   * fence is sample text, not navigation, so fenced blocks are skipped.\n   *\n   * @returns The relative paths of the offending notes.\n   */\n  public findNotesWithWikilinks(): string[] {\n    return this.collectCheckableNotes()\n      .filter((note) => getLinesOutsideFences(note.content).some((line) => WIKILINK_REG_EXP.test(stripInlineCode(line))))\n      .map((note) => note.relativePath);\n  }\n\n  /**\n   * Finds members that the demo notes reference on a receiver but that no longer exist on it (rename drift).\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The distinct stale member names referenced in the demo corpus.\n   */\n  public findStaleReferences(params: DemoVaultCoverageCheckerFindStaleReferencesParams): string[] {\n    const validMembers = new Set(params.validMembers);\n    const referenced = [...this.readCorpus().matchAll(new RegExp(String.raw`${params.receiver}\\.(?<member>\\w+)`, 'g'))]\n      .map((match) => getMandatoryNamedGroup(match, 'member'));\n    return [...new Set(referenced)].filter((member) => !validMembers.has(member));\n  }\n\n  /**\n   * Finds members that are not demonstrated anywhere in the demo corpus.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The member names with no demonstration.\n   */\n  public findUndemonstratedMembers(params: DemoVaultCoverageCheckerFindUndemonstratedMembersParams): string[] {\n    const corpus = this.readCorpus();\n    return params.members.filter((member) => {\n      const needle = params.receiver === undefined ? member : `${params.receiver}.${member}`;\n      return !corpus.includes(needle);\n    });\n  }\n\n  /**\n   * Finds feature docs that no demo note links to.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The feature-doc basenames (without `.md`) not linked from any demo note.\n   */\n  public findUnlinkedFeatureDocs(params: DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams): string[] {\n    const nonFeatureDocs = new Set(params.nonFeatureDocs);\n    const featureDocs = readdirSync(join(this.rootFolder, params.docsFolder))\n      .filter((file) => file.endsWith('.md'))\n      .map((file) => file.replace(/\\.md$/, ''))\n      .filter((name) => !nonFeatureDocs.has(name));\n    const linkedDocs = new Set(\n      [...this.readCorpus().matchAll(/docs\\/(?<doc>[\\w-]+)\\.md/g)].map((match) => getMandatoryNamedGroup(match, 'doc'))\n    );\n    return featureDocs.filter((doc) => !linkedDocs.has(doc));\n  }\n\n  /**\n   * Finds notes that cannot be reached from the start note by following Markdown links between notes.\n   *\n   * The walk starts at {@link DemoVaultCoverageCheckerFindUnreachableNotesParams.startNote} and follows\n   * every `[Text](<./NN Name.md>)` link outside a code fence, transitively. A note nothing links to is\n   * one a reader can only find by browsing the file list \u2014 which is exactly what the grouped index in the\n   * start note is meant to replace. When the start note itself is missing, EVERY note is unreachable,\n   * because there is nowhere to start from.\n   *\n   * @param params - The parameters for the walk.\n   * @returns The relative paths of the unreachable notes.\n   */\n  public findUnreachableNotes(params: DemoVaultCoverageCheckerFindUnreachableNotesParams): string[] {\n    const notesByRelativePath = new Map(this.collectNotes().map((note) => [note.relativePath, note]));\n    const reachedNotes = new Set<string>();\n    const pendingNotes = [params.startNote];\n\n    while (pendingNotes.length > 0) {\n      const notePath = ensureNonNullable(pendingNotes.pop());\n      const note = notesByRelativePath.get(notePath);\n      if (!note || reachedNotes.has(notePath)) {\n        continue;\n      }\n      reachedNotes.add(notePath);\n      pendingNotes.push(...collectNoteLinkTargets(note));\n    }\n\n    return this.collectCheckableNotes()\n      .map((note) => note.relativePath)\n      .filter((notePath) => !reachedNotes.has(notePath));\n  }\n\n  /**\n   * Parses the names of the `export function`s (including `async` and generator declarations) in a source file.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The exported function names in source order.\n   */\n  public getExportedFunctionNames(params: DemoVaultCoverageCheckerGetExportedFunctionNamesParams): string[] {\n    const source = readFileSync(join(this.rootFolder, params.sourcePath), 'utf-8');\n    return [...source.matchAll(/^export (?:async )?function\\*? (?<name>\\w+)/gm)]\n      .map((match) => getMandatoryNamedGroup(match, 'name'));\n  }\n\n  /**\n   * Parses the members of an `export interface`, `export class`, or `export enum` declared in a source file.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The parsed {@link InterfaceMembers}.\n   * @throws When the interface, class, or enum cannot be found in the source file.\n   */\n  public getInterfaceMembers(params: DemoVaultCoverageCheckerGetInterfaceMembersParams): InterfaceMembers {\n    const source = readFileSync(join(this.rootFolder, params.sourcePath), 'utf-8');\n    const match = new RegExp(String.raw`export (?<keyword>interface|class|enum) ${params.interfaceName}\\b[^{]*\\{(?<body>[\\s\\S]*?)\\n\\}`).exec(source);\n    if (!match) {\n      throw new Error(`Could not find interface ${params.interfaceName}`);\n    }\n    return parseMembers(getMandatoryNamedGroup(match, 'keyword'), getMandatoryNamedGroup(match, 'body'));\n  }\n\n  /**\n   * Reads and caches the demo corpus \u2014 every `*.md` note in the demo vault joined into one string.\n   *\n   * @returns The concatenated demo-note contents.\n   */\n  public readCorpus(): string {\n    this.cachedCorpus ??= this.collectNotes()\n      .map((note) => note.content)\n      .join('\\n');\n    return this.cachedCorpus;\n  }\n\n  // The notes the authoring checks apply to: every note except the ones declared outside the learning\n  // Path (the vault's own `README.md` by default).\n  private collectCheckableNotes(): DemoVaultNote[] {\n    return this.collectNotes().filter((note) => !this.excludedNotes.has(note.relativePath));\n  }\n\n  private collectMarkdownFiles(folder: string): string[] {\n    const result: string[] = [];\n    for (const entry of readdirSync(folder, { withFileTypes: true })) {\n      if (entry.isDirectory()) {\n        if (entry.name === ObsidianPluginRepoPaths.NodeModules as string) {\n          continue;\n        }\n        result.push(...this.collectMarkdownFiles(join(folder, entry.name)));\n      } else if (entry.name.endsWith('.md')) {\n        result.push(join(folder, entry.name));\n      }\n    }\n    return result;\n  }\n}\n\n/**\n * Registers a `vitest` suite that keeps a plugin's in-repo `demo-vault/` in sync with its public surface.\n *\n * Call it once from a plugin's `demo-vault.no-app.integration.test.ts`; it registers one test per check,\n * delegating to {@link DemoVaultCoverageChecker}.\n *\n * @param params - The declarative coverage specification.\n */\nexport function registerDemoVaultCoverageSuite(params: RegisterDemoVaultCoverageSuiteParams): void {\n  const checker = new DemoVaultCoverageChecker(normalizeOptionalProperties<DemoVaultCoverageCheckerConstructorParams>({\n    excludedNotes: params.authoring?.excludedNotes,\n    rootFolder: params.rootFolder\n  }));\n  const startNote = params.authoring?.startNote ?? DEFAULT_START_NOTE;\n\n  describe('demo-vault coverage', () => {\n    for (const spec of params.interfaces) {\n      it(`demonstrates every ${spec.interfaceName} ${spec.kind}`, () => {\n        const members = checker.getInterfaceMembers(spec);\n        const demonstrated = members[spec.kind];\n        expect(demonstrated.length).toBeGreaterThan(0);\n        expect(checker.findUndemonstratedMembers({ members: demonstrated, receiver: spec.receiver })).toEqual([]);\n      });\n\n      it(`references no ${spec.interfaceName} member that no longer exists`, () => {\n        const members = checker.getInterfaceMembers(spec);\n        expect(checker.findStaleReferences({ receiver: spec.receiver, validMembers: members.all })).toEqual([]);\n      });\n    }\n\n    for (const spec of params.configInterfaces) {\n      it(`demonstrates every ${spec.interfaceName} option`, () => {\n        const members = checker.getInterfaceMembers(spec);\n        expect(members.properties.length).toBeGreaterThan(0);\n        expect(checker.findUndemonstratedMembers({ members: members.properties })).toEqual([]);\n      });\n    }\n\n    for (const spec of params.functionModules ?? []) {\n      it(`demonstrates every exported function in ${spec.sourcePath}`, () => {\n        const functionNames = checker.getExportedFunctionNames(spec);\n        expect(functionNames.length).toBeGreaterThan(0);\n        expect(checker.findUndemonstratedMembers({ members: functionNames })).toEqual([]);\n      });\n    }\n\n    const docs = params.docs;\n    if (docs) {\n      it('links a demo note for every feature doc', () => {\n        expect(checker.findUnlinkedFeatureDocs({ docsFolder: docs.folder, nonFeatureDocs: docs.nonFeatureDocs }))\n          .toEqual([]);\n      });\n    }\n\n    it('opens every note with an H1', () => {\n      expect(checker.findNotesWithoutH1()).toEqual([]);\n    });\n\n    it('opens every note with a prose paragraph before its first code block', () => {\n      expect(checker.findNotesWithoutIntroProse()).toEqual([]);\n    });\n\n    it(`reaches every note from ${startNote}`, () => {\n      expect(checker.findUnreachableNotes({ startNote })).toEqual([]);\n    });\n\n    it('uses no wikilinks, which do not render on GitHub', () => {\n      expect(checker.findNotesWithWikilinks()).toEqual([]);\n    });\n\n    it('carries no Docs link line, because the note is the docs', () => {\n      expect(checker.findNotesWithDocsLinks()).toEqual([]);\n    });\n\n    it('keeps the reflected surface non-trivial', () => {\n      const guard = params.nonTrivialGuard;\n      const members = checker.getInterfaceMembers(guard);\n      expect(members.all).toContain(guard.expectMember);\n      expect(checker.collectDemoNoteRelativePaths()).toContain(guard.expectDemoNote);\n    });\n  });\n}\n\nconst CLASS_MEMBER_MODIFIERS = String.raw`(?:(?:public|private|protected|readonly|static|abstract|override)\\s+)*`;\nconst ABSOLUTE_URL_REG_EXP = /^[a-z][\\w+.-]*:/i;\nconst ANGLE_BRACKETS_REG_EXP = /^<|>$/g;\nconst CODE_FENCE_REG_EXP = /^\\s*(?:```|~~~)/;\nconst DEFAULT_EXCLUDED_NOTES = ['README.md'];\nconst DEFAULT_START_NOTE = '00 Start.md';\nconst DOCS_LINK_REG_EXP = /^\\s*\\[Docs]\\(/;\nconst FRONTMATTER_REG_EXP = /^---\\r?\\n[\\s\\S]*?\\r?\\n---[^\\S\\n]*\\r?\\n?/;\nconst H1_REG_EXP = /^# \\S/;\nconst HEADING_REG_EXP = /^#{1,6} /;\nconst INLINE_CODE_REG_EXP = /`[^`\\n]*`/g;\nconst MARKDOWN_LINK_REG_EXP = /\\[[^\\]]*]\\((?<target>[^)]+)\\)/g;\nconst WIKILINK_REG_EXP = /\\[\\[[^\\]]+]]/;\n\nfunction buildMembers(methods: string[], properties: string[]): InterfaceMembers {\n  return {\n    all: [...methods, ...properties],\n    methods,\n    properties\n  };\n}\n\n// Resolves the notes a note links to: every Markdown link outside a code fence whose target is a `.md`\n// File, made relative to the demo vault so it can be looked up in the note map. External URLs and\n// Non-note targets (images, scripts) are not part of the learning path and are skipped; a `#anchor` is\n// Dropped, since it addresses a place inside an already-resolved note.\nfunction collectNoteLinkTargets(note: DemoVaultNote): string[] {\n  const targets: string[] = [];\n  for (const line of getLinesOutsideFences(note.content)) {\n    for (const match of stripInlineCode(line).matchAll(MARKDOWN_LINK_REG_EXP)) {\n      const target = getMandatoryNamedGroup(match, 'target').replaceAll(ANGLE_BRACKETS_REG_EXP, '');\n      const [notePath = ''] = target.split('#', 1);\n      if (ABSOLUTE_URL_REG_EXP.test(notePath) || !notePath.toLowerCase().endsWith('.md')) {\n        continue;\n      }\n      targets.push(join(dirname(note.relativePath), tryDecodeUriComponent(notePath)));\n    }\n  }\n  return targets;\n}\n\nfunction extractClassMethodNames(classBody: string): string[] {\n  return [...classBody.matchAll(new RegExp(String.raw`^ {2}(?<modifiers>${CLASS_MEMBER_MODIFIERS})(?<name>\\w+)(?:<[^>]*>)?\\(`, 'gm'))]\n    .filter((match) => !isNonPublicMember(getMandatoryNamedGroup(match, 'modifiers')))\n    .map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction extractClassPropertyNames(classBody: string): string[] {\n  return [...classBody.matchAll(new RegExp(String.raw`^ {2}(?<modifiers>${CLASS_MEMBER_MODIFIERS})(?<name>\\w+)\\s*\\??\\s*[:=]`, 'gm'))]\n    .filter((match) => !isNonPublicMember(getMandatoryNamedGroup(match, 'modifiers')))\n    .map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction extractEnumMemberNames(enumBody: string): string[] {\n  return [...enumBody.matchAll(/^ {2}(?<name>\\w+)/gm)].map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction extractMethodNames(interfaceBody: string): string[] {\n  return [...interfaceBody.matchAll(/^ {2}(?<name>\\w+)(?:<[^>]*>)?\\(/gm)].map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction extractPropertyNames(interfaceBody: string): string[] {\n  return [...interfaceBody.matchAll(/^ {2}(?<name>\\w+)\\??:/gm)].map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\n// Returns the note's lines with fenced code blocks removed (the fence lines included), so a check never\n// Mistakes sample code for prose \u2014 a `[[wikilink]]` demonstrated inside a fence is text, not navigation.\nfunction getLinesOutsideFences(content: string): string[] {\n  const lines: string[] = [];\n  let isInsideFence = false;\n  for (const line of content.split('\\n')) {\n    if (CODE_FENCE_REG_EXP.test(line)) {\n      isInsideFence = !isInsideFence;\n      continue;\n    }\n    if (!isInsideFence) {\n      lines.push(line);\n    }\n  }\n  return lines;\n}\n\n// Whether the note's first content line (frontmatter and blank lines aside) is an `# H1`.\nfunction hasH1(content: string): boolean {\n  for (const line of stripFrontmatter(content).split('\\n')) {\n    const trimmedLine = line.trim();\n    if (trimmedLine === '') {\n      continue;\n    }\n    return H1_REG_EXP.test(trimmedLine);\n  }\n  return false;\n}\n\n// Whether a plain prose line appears before the note's first code fence. Headings are not prose \u2014 a note\n// That goes straight from its title to a button is exactly the shape this check rejects.\nfunction hasIntroProse(content: string): boolean {\n  for (const line of stripFrontmatter(content).split('\\n')) {\n    if (CODE_FENCE_REG_EXP.test(line)) {\n      return false;\n    }\n    const trimmedLine = line.trim();\n    if (trimmedLine === '' || HEADING_REG_EXP.test(trimmedLine)) {\n      continue;\n    }\n    return true;\n  }\n  return false;\n}\n\nfunction isNonPublicMember(modifiers: string): boolean {\n  return /\\b(?:private|protected)\\b/.test(modifiers);\n}\n\nfunction parseMembers(keyword: string, body: string): InterfaceMembers {\n  switch (keyword) {\n    case 'class': {\n      return buildMembers(extractClassMethodNames(body), extractClassPropertyNames(body));\n    }\n    case 'enum': {\n      return buildMembers([], extractEnumMemberNames(body));\n    }\n    default: {\n      return buildMembers(extractMethodNames(body), extractPropertyNames(body));\n    }\n  }\n}\n\nfunction stripFrontmatter(content: string): string {\n  return content.replace(FRONTMATTER_REG_EXP, '');\n}\n\nfunction stripInlineCode(line: string): string {\n  return line.replaceAll(INLINE_CODE_REG_EXP, '');\n}\n\n// A hand-written link may contain a bare `%` (or any other invalid percent-escape), which makes\n// `decodeURIComponent` throw. Such a target is meant literally, so it is used as written.\nfunction tryDecodeUriComponent(value: string): string {\n  try {\n    return decodeURIComponent(value);\n  } catch {\n    return value;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/script-utils/linters/eslint-rules/no-async-callback-to-unsafe-return.d.mts

@@ -4,4 +4,7 @@ import type { Rule } from 'eslint';
 Message ID reported when an async function is passed as a callback to a parameter whose return type is `any`/`unknown`, risking an unhandled promise rejection.
  */
 export declare const MESSAGE_ID = "noAsyncCallbackToUnsafeReturn";
+/**
+ * ESLint rule disallowing async functions passed as callbacks to parameters with an `any` or `unknown` return type, where the returned promise is silently dropped.
+ */
 export declare const noAsyncCallbackToUnsafeReturn: Rule.RuleModule;