obsidian-dev-utils 87.0.1 → 87.0.3

package/dist/lib/cjs/script-utils/demo-vault-coverage.cjs

@@ -0,0 +1,289 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@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.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    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 demo_vault_coverage_exports = {};
+__export(demo_vault_coverage_exports, {
+  DemoVaultCoverageChecker: () => DemoVaultCoverageChecker,
+  registerDemoVaultCoverageSuite: () => registerDemoVaultCoverageSuite
+});
+module.exports = __toCommonJS(demo_vault_coverage_exports);
+var import_node_fs = require('node:fs');
+var import_vitest = require('vitest');
+var import_obsidian_plugin_repo_paths = require('../obsidian/plugin/obsidian-plugin-repo-paths.cjs');
+var import_path = require('../path.cjs');
+var import_reg_exp = require('../reg-exp.cjs');
+class DemoVaultCoverageChecker {
+  cachedCorpus = null;
+  demoVaultFolder;
+  rootFolder;
+  /**
+   * Creates a checker rooted at a plugin repo.
+   *
+   * @param params - The parameters for the constructor.
+   */
+  constructor(params) {
+    this.rootFolder = params.rootFolder;
+    this.demoVaultFolder = (0, import_path.join)(this.rootFolder, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DemoVault);
+  }
+  /**
+   * Collects the demo notes as paths relative to the demo vault folder (for a non-trivial-surface guard).
+   *
+   * @returns The relative paths of every `*.md` note in the demo vault.
+   */
+  collectDemoNoteRelativePaths() {
+    return this.collectMarkdownFiles(this.demoVaultFolder).map((file) => (0, import_path.relative)(this.demoVaultFolder, file));
+  }
+  /**
+   * Finds members that the demo notes reference on a receiver but that no longer exist on it (rename drift).
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The distinct stale member names referenced in the demo corpus.
+   */
+  findStaleReferences(params) {
+    const validMembers = new Set(params.validMembers);
+    const referenced = [...this.readCorpus().matchAll(new RegExp(`${params.receiver}\\.(?<member>\\w+)`, "g"))].map((match) => (0, import_reg_exp.getMandatoryNamedGroup)(match, "member"));
+    return [...new Set(referenced)].filter((member) => !validMembers.has(member));
+  }
+  /**
+   * Finds members that are not demonstrated anywhere in the demo corpus.
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The member names with no demonstration.
+   */
+  findUndemonstratedMembers(params) {
+    const corpus = this.readCorpus();
+    return params.members.filter((member) => {
+      const needle = params.receiver === void 0 ? member : `${params.receiver}.${member}`;
+      return !corpus.includes(needle);
+    });
+  }
+  /**
+   * Finds feature docs that no demo note links to.
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The feature-doc basenames (without `.md`) not linked from any demo note.
+   */
+  findUnlinkedFeatureDocs(params) {
+    const nonFeatureDocs = new Set(params.nonFeatureDocs);
+    const featureDocs = (0, import_node_fs.readdirSync)((0, import_path.join)(this.rootFolder, params.docsFolder)).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).filter((name) => !nonFeatureDocs.has(name));
+    const linkedDocs = new Set(
+      [...this.readCorpus().matchAll(/docs\/(?<doc>[\w-]+)\.md/g)].map((match) => (0, import_reg_exp.getMandatoryNamedGroup)(match, "doc"))
+    );
+    return featureDocs.filter((doc) => !linkedDocs.has(doc));
+  }
+  /**
+   * Parses the members of an `export interface` declared in a source file.
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The parsed {@link InterfaceMembers}.
+   * @throws When the interface cannot be found in the source file.
+   */
+  getInterfaceMembers(params) {
+    const source = (0, import_node_fs.readFileSync)((0, import_path.join)(this.rootFolder, params.sourcePath), "utf-8");
+    const match = new RegExp(`export interface ${params.interfaceName} \\{(?<body>[\\s\\S]*?)\\n\\}`).exec(source);
+    if (!match) {
+      throw new Error(`Could not find interface ${params.interfaceName}`);
+    }
+    const body = (0, import_reg_exp.getMandatoryNamedGroup)(match, "body");
+    const methods = extractMethodNames(body);
+    const properties = extractPropertyNames(body);
+    return {
+      all: [...methods, ...properties],
+      methods,
+      properties
+    };
+  }
+  /**
+   * Reads and caches the demo corpus — every `*.md` note in the demo vault joined into one string.
+   *
+   * @returns The concatenated demo-note contents.
+   */
+  readCorpus() {
+    this.cachedCorpus ??= this.collectMarkdownFiles(this.demoVaultFolder).map((file) => (0, import_node_fs.readFileSync)(file, "utf-8")).join("\n");
+    return this.cachedCorpus;
+  }
+  collectMarkdownFiles(folder) {
+    const result = [];
+    for (const entry of (0, import_node_fs.readdirSync)(folder, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (entry.name === import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.NodeModules) {
+          continue;
+        }
+        result.push(...this.collectMarkdownFiles((0, import_path.join)(folder, entry.name)));
+      } else if (entry.name.endsWith(".md")) {
+        result.push((0, import_path.join)(folder, entry.name));
+      }
+    }
+    return result;
+  }
+}
+function registerDemoVaultCoverageSuite(params) {
+  const checker = new DemoVaultCoverageChecker({ rootFolder: params.rootFolder });
+  (0, import_vitest.describe)("demo-vault coverage", () => {
+    for (const spec of params.interfaces) {
+      (0, import_vitest.it)(`demonstrates every ${spec.interfaceName} ${spec.kind}`, () => {
+        const members = checker.getInterfaceMembers(spec);
+        const demonstrated = members[spec.kind];
+        (0, import_vitest.expect)(demonstrated.length).toBeGreaterThan(0);
+        (0, import_vitest.expect)(checker.findUndemonstratedMembers({ members: demonstrated, receiver: spec.receiver })).toEqual([]);
+      });
+      (0, import_vitest.it)(`references no ${spec.interfaceName} member that no longer exists`, () => {
+        const members = checker.getInterfaceMembers(spec);
+        (0, import_vitest.expect)(checker.findStaleReferences({ receiver: spec.receiver, validMembers: members.all })).toEqual([]);
+      });
+    }
+    for (const spec of params.configInterfaces) {
+      (0, import_vitest.it)(`demonstrates every ${spec.interfaceName} option`, () => {
+        const members = checker.getInterfaceMembers(spec);
+        (0, import_vitest.expect)(members.properties.length).toBeGreaterThan(0);
+        (0, import_vitest.expect)(checker.findUndemonstratedMembers({ members: members.properties })).toEqual([]);
+      });
+    }
+    const docs = params.docs;
+    if (docs) {
+      (0, import_vitest.it)("links a demo note for every feature doc", () => {
+        (0, import_vitest.expect)(checker.findUnlinkedFeatureDocs({ docsFolder: docs.folder, nonFeatureDocs: docs.nonFeatureDocs })).toEqual([]);
+      });
+    }
+    (0, import_vitest.it)("keeps the reflected surface non-trivial", () => {
+      const guard = params.nonTrivialGuard;
+      const members = checker.getInterfaceMembers(guard);
+      (0, import_vitest.expect)(members.all).toContain(guard.expectMember);
+      (0, import_vitest.expect)(checker.collectDemoNoteRelativePaths()).toContain(guard.expectDemoNote);
+    });
+  });
+}
+function extractMethodNames(interfaceBody) {
+  return [...interfaceBody.matchAll(/^ {2}(?<name>\w+)(?:<[^>]*>)?\(/gm)].map((match) => (0, import_reg_exp.getMandatoryNamedGroup)(match, "name"));
+}
+function extractPropertyNames(interfaceBody) {
+  return [...interfaceBody.matchAll(/^ {2}(?<name>\w+)\??:/gm)].map((match) => (0, import_reg_exp.getMandatoryNamedGroup)(match, "name"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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 *   members, and returns diagnostic arrays (what is undemonstrated / stale / 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` whose properties are the config options.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface.\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.getInterfaceMembers}.\n */\nexport interface DemoVaultCoverageCheckerGetInterfaceMembersParams {\n  /**\n   * The name of the `export interface` to parse.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface.\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 single interface's members and demonstrates them via `` `${receiver}.<member>` `` references.\n */\nexport interface DemoVaultInterfaceCoverageSpec {\n  /**\n   * The name of the `export interface` to reflect.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * Whether the demonstrated members are the interface's methods or its 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.\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` whose members are re-parsed for the guard.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * The parsed members of a source interface.\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 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(`${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 members of an `export interface` 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 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(`export interface ${params.interfaceName} \\\\{(?<body>[\\\\s\\\\S]*?)\\\\n\\\\}`).exec(source);\n    if (!match) {\n      throw new Error(`Could not find interface ${params.interfaceName}`);\n    }\n    const body = getMandatoryNamedGroup(match, 'body');\n    const methods = extractMethodNames(body);\n    const properties = extractPropertyNames(body);\n    return {\n      all: [...methods, ...properties],\n      methods,\n      properties\n    };\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    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\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"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/script-utils/demo-vault-coverage.d.cts

@@ -0,0 +1,264 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Static coverage/freshness checks that keep a plugin's in-repo `demo-vault/` in sync with its public surface.
+ *
+ * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. These helpers reflect the real
+ * public API/config/docs straight from source and assert — WITHOUT launching Obsidian — that every feature is
+ * demonstrated in the notes and that the notes reference no API member that no longer exists (rename drift).
+ * 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.
+ *
+ * Two layers are exposed:
+ * - {@link DemoVaultCoverageChecker} — a framework-agnostic core that reads the corpus, parses interface
+ *   members, and returns diagnostic arrays (what is undemonstrated / stale / unlinked).
+ * - {@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.
+ */
+/**
+ * Reflects a config interface whose options are demonstrated by their bare name.
+ */
+export interface DemoVaultConfigInterfaceCoverageSpec {
+    /**
+     * The name of the `export interface` whose properties are the config options.
+     */
+    readonly interfaceName: string;
+    /**
+     * The source file path (relative to the repo root) that declares the interface.
+     */
+    readonly sourcePath: string;
+}
+/**
+ * The parameters for the {@link DemoVaultCoverageChecker} constructor.
+ */
+export interface DemoVaultCoverageCheckerConstructorParams {
+    /**
+     * The absolute path of the plugin repo root — the folder containing `demo-vault/` and the source being
+     * reflected. Callers typically pass `getRootFolder() ?? process.cwd()`.
+     */
+    readonly rootFolder: string;
+}
+/**
+ * The parameters for {@link DemoVaultCoverageChecker.findStaleReferences}.
+ */
+export interface DemoVaultCoverageCheckerFindStaleReferencesParams {
+    /**
+     * The receiver whose `` `${receiver}.<member>` `` references are scanned for in the demo corpus.
+     */
+    readonly receiver: string;
+    /**
+     * The members that currently exist on the receiver; any referenced member not in this set is stale.
+     */
+    readonly validMembers: string[];
+}
+/**
+ * The parameters for {@link DemoVaultCoverageChecker.findUndemonstratedMembers}.
+ */
+export interface DemoVaultCoverageCheckerFindUndemonstratedMembersParams {
+    /**
+     * The member names that must each appear in the demo corpus.
+     */
+    readonly members: string[];
+    /**
+     * When set, a member is demonstrated only if `` `${receiver}.${member}` `` appears (e.g. a context object's
+     * methods); when absent, the bare member name is looked up (e.g. a config option).
+     */
+    readonly receiver?: string;
+}
+/**
+ * The parameters for {@link DemoVaultCoverageChecker.findUnlinkedFeatureDocs}.
+ */
+export interface DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams {
+    /**
+     * The docs folder (relative to the repo root) whose top-level `*.md` files are the feature docs.
+     */
+    readonly docsFolder: string;
+    /**
+     * The doc basenames (without `.md`) that are NOT per-feature pages and so need no linking demo note.
+     */
+    readonly nonFeatureDocs: string[];
+}
+/**
+ * The parameters for {@link DemoVaultCoverageChecker.getInterfaceMembers}.
+ */
+export interface DemoVaultCoverageCheckerGetInterfaceMembersParams {
+    /**
+     * The name of the `export interface` to parse.
+     */
+    readonly interfaceName: string;
+    /**
+     * The source file path (relative to the repo root) that declares the interface.
+     */
+    readonly sourcePath: string;
+}
+/**
+ * Configures the feature-doc linking check.
+ */
+export interface DemoVaultDocsCoverageSpec {
+    /**
+     * The docs folder (relative to the repo root) whose top-level `*.md` files are the feature docs.
+     */
+    readonly folder: string;
+    /**
+     * The doc basenames (without `.md`) that are NOT per-feature pages and so need no linking demo note.
+     */
+    readonly nonFeatureDocs: string[];
+}
+/**
+ * Reflects a single interface's members and demonstrates them via `` `${receiver}.<member>` `` references.
+ */
+export interface DemoVaultInterfaceCoverageSpec {
+    /**
+     * The name of the `export interface` to reflect.
+     */
+    readonly interfaceName: string;
+    /**
+     * Whether the demonstrated members are the interface's methods or its properties.
+     */
+    readonly kind: DemoVaultInterfaceMemberKind;
+    /**
+     * The identifier the notes call the members on (e.g. `codeButtonContext`).
+     */
+    readonly receiver: string;
+    /**
+     * The source file path (relative to the repo root) that declares the interface.
+     */
+    readonly sourcePath: string;
+}
+/**
+ * Whether an interface's demonstrated members are its methods or its properties.
+ */
+export type DemoVaultInterfaceMemberKind = 'methods' | 'properties';
+/**
+ * Configures the guard that the reflected surface is non-trivial (protects against a parsing regression
+ * silently emptying every other check).
+ */
+export interface DemoVaultNonTrivialGuardSpec {
+    /**
+     * A demo note (path relative to the demo vault) that must be present.
+     */
+    readonly expectDemoNote: string;
+    /**
+     * A member that must be reflected from {@link DemoVaultNonTrivialGuardSpec.interfaceName}.
+     */
+    readonly expectMember: string;
+    /**
+     * The name of the `export interface` whose members are re-parsed for the guard.
+     */
+    readonly interfaceName: string;
+    /**
+     * The source file path (relative to the repo root) that declares the interface.
+     */
+    readonly sourcePath: string;
+}
+/**
+ * The parsed members of a source interface.
+ */
+export interface InterfaceMembers {
+    /**
+     * Every member — {@link InterfaceMembers.methods} followed by {@link InterfaceMembers.properties}.
+     */
+    readonly all: string[];
+    /**
+     * The method members (declared as `name(...)`).
+     */
+    readonly methods: string[];
+    /**
+     * The property members (declared as `name?: ...`).
+     */
+    readonly properties: string[];
+}
+/**
+ * The parameters for {@link registerDemoVaultCoverageSuite}.
+ */
+export interface RegisterDemoVaultCoverageSuiteParams {
+    /**
+     * The config interfaces whose options must each be demonstrated by their bare name.
+     */
+    readonly configInterfaces: DemoVaultConfigInterfaceCoverageSpec[];
+    /**
+     * The feature-doc linking check, or `undefined` when the plugin ships no `docs/` folder.
+     */
+    readonly docs?: DemoVaultDocsCoverageSpec;
+    /**
+     * The interfaces whose members must each be demonstrated (and referenced without drift).
+     */
+    readonly interfaces: DemoVaultInterfaceCoverageSpec[];
+    /**
+     * The guard that keeps the reflected surface non-trivial.
+     */
+    readonly nonTrivialGuard: DemoVaultNonTrivialGuardSpec;
+    /**
+     * The absolute path of the plugin repo root. Callers typically pass `getRootFolder() ?? process.cwd()`.
+     */
+    readonly rootFolder: string;
+}
+/**
+ * Reflects a plugin's public surface from source and checks its in-repo `demo-vault/` stays in sync with it.
+ *
+ * Every method is a pure query over files under the repo root (the demo corpus is read once and cached), so
+ * the checker is trivially unit-testable against a fixture repo and carries no test-framework dependency.
+ */
+export declare class DemoVaultCoverageChecker {
+    private cachedCorpus;
+    private readonly demoVaultFolder;
+    private readonly rootFolder;
+    /**
+     * Creates a checker rooted at a plugin repo.
+     *
+     * @param params - The parameters for the constructor.
+     */
+    constructor(params: DemoVaultCoverageCheckerConstructorParams);
+    /**
+     * Collects the demo notes as paths relative to the demo vault folder (for a non-trivial-surface guard).
+     *
+     * @returns The relative paths of every `*.md` note in the demo vault.
+     */
+    collectDemoNoteRelativePaths(): string[];
+    /**
+     * Finds members that the demo notes reference on a receiver but that no longer exist on it (rename drift).
+     *
+     * @param params - The parameters for the lookup.
+     * @returns The distinct stale member names referenced in the demo corpus.
+     */
+    findStaleReferences(params: DemoVaultCoverageCheckerFindStaleReferencesParams): string[];
+    /**
+     * Finds members that are not demonstrated anywhere in the demo corpus.
+     *
+     * @param params - The parameters for the lookup.
+     * @returns The member names with no demonstration.
+     */
+    findUndemonstratedMembers(params: DemoVaultCoverageCheckerFindUndemonstratedMembersParams): string[];
+    /**
+     * Finds feature docs that no demo note links to.
+     *
+     * @param params - The parameters for the lookup.
+     * @returns The feature-doc basenames (without `.md`) not linked from any demo note.
+     */
+    findUnlinkedFeatureDocs(params: DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams): string[];
+    /**
+     * Parses the members of an `export interface` declared in a source file.
+     *
+     * @param params - The parameters for the lookup.
+     * @returns The parsed {@link InterfaceMembers}.
+     * @throws When the interface cannot be found in the source file.
+     */
+    getInterfaceMembers(params: DemoVaultCoverageCheckerGetInterfaceMembersParams): InterfaceMembers;
+    /**
+     * Reads and caches the demo corpus — every `*.md` note in the demo vault joined into one string.
+     *
+     * @returns The concatenated demo-note contents.
+     */
+    readCorpus(): string;
+    private collectMarkdownFiles;
+}
+/**
+ * Registers a `vitest` suite that keeps a plugin's in-repo `demo-vault/` in sync with its public surface.
+ *
+ * Call it once from a plugin's `demo-vault.no-app.integration.test.ts`; it registers one test per check,
+ * delegating to {@link DemoVaultCoverageChecker}.
+ *
+ * @param params - The declarative coverage specification.
+ */
+export declare function registerDemoVaultCoverageSuite(params: RegisterDemoVaultCoverageSuiteParams): void;