obsidian-dev-utils 87.0.2 → 87.0.4

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

@@ -0,0 +1,298 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @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 /
+ *   class / enum members and exported functions, 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`, `export class`, or `export enum` whose properties are the config
+     * options.
+     */
+    readonly interfaceName: string;
+    /**
+     * The source file path (relative to the repo root) that declares the interface, class, or enum.
+     */
+    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.getExportedFunctionNames}.
+ */
+export interface DemoVaultCoverageCheckerGetExportedFunctionNamesParams {
+    /**
+     * The source file path (relative to the repo root) whose `export function`s are parsed.
+     */
+    readonly sourcePath: string;
+}
+/**
+ * The parameters for {@link DemoVaultCoverageChecker.getInterfaceMembers}.
+ */
+export interface DemoVaultCoverageCheckerGetInterfaceMembersParams {
+    /**
+     * The name of the `export interface`, `export class`, or `export enum` to parse.
+     */
+    readonly interfaceName: string;
+    /**
+     * The source file path (relative to the repo root) that declares the interface, class, or enum.
+     */
+    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 module's exported functions, each demonstrated by its bare name in the demo corpus.
+ */
+export interface DemoVaultFunctionsCoverageSpec {
+    /**
+     * The source file path (relative to the repo root) whose `export function`s must each be demonstrated.
+     */
+    readonly sourcePath: string;
+}
+/**
+ * Reflects a single interface's members and demonstrates them via `` `${receiver}.<member>` `` references.
+ */
+export interface DemoVaultInterfaceCoverageSpec {
+    /**
+     * The name of the `export interface`, `export class`, or `export enum` to reflect.
+     */
+    readonly interfaceName: string;
+    /**
+     * Whether the demonstrated members are the reflected type's methods or its properties (enum members count as
+     * 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, class, or enum.
+     */
+    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`, `export class`, or `export enum` whose members are re-parsed for the
+     * guard.
+     */
+    readonly interfaceName: string;
+    /**
+     * The source file path (relative to the repo root) that declares the interface, class, or enum.
+     */
+    readonly sourcePath: string;
+}
+/**
+ * The parsed members of a source interface, class, or enum.
+ */
+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 modules whose `export function`s must each be demonstrated by their bare name, or `undefined` when the
+     * plugin exposes no such module to check.
+     */
+    readonly functionModules?: DemoVaultFunctionsCoverageSpec[];
+    /**
+     * 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 names of the `export function`s (including `async` and generator declarations) in a source file.
+     *
+     * @param params - The parameters for the lookup.
+     * @returns The exported function names in source order.
+     */
+    getExportedFunctionNames(params: DemoVaultCoverageCheckerGetExportedFunctionNamesParams): string[];
+    /**
+     * Parses the members of an `export interface`, `export class`, or `export enum` declared in a source file.
+     *
+     * @param params - The parameters for the lookup.
+     * @returns The parsed {@link InterfaceMembers}.
+     * @throws When the interface, class, or enum 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;

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

@@ -0,0 +1,230 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import {
+  readdirSync,
+  readFileSync
+} from "node:fs";
+import {
+  describe,
+  expect,
+  it
+} from "vitest";
+import { ObsidianPluginRepoPaths } from "../obsidian/plugin/obsidian-plugin-repo-paths.mjs";
+import {
+  join,
+  relative
+} from "../path.mjs";
+import { getMandatoryNamedGroup } from "../reg-exp.mjs";
+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 = join(this.rootFolder, 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) => 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) => 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 = readdirSync(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) => getMandatoryNamedGroup(match, "doc"))
+    );
+    return featureDocs.filter((doc) => !linkedDocs.has(doc));
+  }
+  /**
+   * Parses the names of the `export function`s (including `async` and generator declarations) in a source file.
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The exported function names in source order.
+   */
+  getExportedFunctionNames(params) {
+    const source = readFileSync(join(this.rootFolder, params.sourcePath), "utf-8");
+    return [...source.matchAll(/^export (?:async )?function\*? (?<name>\w+)/gm)].map((match) => getMandatoryNamedGroup(match, "name"));
+  }
+  /**
+   * Parses the members of an `export interface`, `export class`, or `export enum` declared in a source file.
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The parsed {@link InterfaceMembers}.
+   * @throws When the interface, class, or enum cannot be found in the source file.
+   */
+  getInterfaceMembers(params) {
+    const source = readFileSync(join(this.rootFolder, params.sourcePath), "utf-8");
+    const match = new RegExp(`export (?<keyword>interface|class|enum) ${params.interfaceName}\\b[^{]*\\{(?<body>[\\s\\S]*?)\\n\\}`).exec(source);
+    if (!match) {
+      throw new Error(`Could not find interface ${params.interfaceName}`);
+    }
+    return parseMembers(getMandatoryNamedGroup(match, "keyword"), getMandatoryNamedGroup(match, "body"));
+  }
+  /**
+   * 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) => readFileSync(file, "utf-8")).join("\n");
+    return this.cachedCorpus;
+  }
+  collectMarkdownFiles(folder) {
+    const result = [];
+    for (const entry of readdirSync(folder, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (entry.name === ObsidianPluginRepoPaths.NodeModules) {
+          continue;
+        }
+        result.push(...this.collectMarkdownFiles(join(folder, entry.name)));
+      } else if (entry.name.endsWith(".md")) {
+        result.push(join(folder, entry.name));
+      }
+    }
+    return result;
+  }
+}
+function registerDemoVaultCoverageSuite(params) {
+  const checker = new DemoVaultCoverageChecker({ rootFolder: params.rootFolder });
+  describe("demo-vault coverage", () => {
+    for (const spec of params.interfaces) {
+      it(`demonstrates every ${spec.interfaceName} ${spec.kind}`, () => {
+        const members = checker.getInterfaceMembers(spec);
+        const demonstrated = members[spec.kind];
+        expect(demonstrated.length).toBeGreaterThan(0);
+        expect(checker.findUndemonstratedMembers({ members: demonstrated, receiver: spec.receiver })).toEqual([]);
+      });
+      it(`references no ${spec.interfaceName} member that no longer exists`, () => {
+        const members = checker.getInterfaceMembers(spec);
+        expect(checker.findStaleReferences({ receiver: spec.receiver, validMembers: members.all })).toEqual([]);
+      });
+    }
+    for (const spec of params.configInterfaces) {
+      it(`demonstrates every ${spec.interfaceName} option`, () => {
+        const members = checker.getInterfaceMembers(spec);
+        expect(members.properties.length).toBeGreaterThan(0);
+        expect(checker.findUndemonstratedMembers({ members: members.properties })).toEqual([]);
+      });
+    }
+    for (const spec of params.functionModules ?? []) {
+      it(`demonstrates every exported function in ${spec.sourcePath}`, () => {
+        const functionNames = checker.getExportedFunctionNames(spec);
+        expect(functionNames.length).toBeGreaterThan(0);
+        expect(checker.findUndemonstratedMembers({ members: functionNames })).toEqual([]);
+      });
+    }
+    const docs = params.docs;
+    if (docs) {
+      it("links a demo note for every feature doc", () => {
+        expect(checker.findUnlinkedFeatureDocs({ docsFolder: docs.folder, nonFeatureDocs: docs.nonFeatureDocs })).toEqual([]);
+      });
+    }
+    it("keeps the reflected surface non-trivial", () => {
+      const guard = params.nonTrivialGuard;
+      const members = checker.getInterfaceMembers(guard);
+      expect(members.all).toContain(guard.expectMember);
+      expect(checker.collectDemoNoteRelativePaths()).toContain(guard.expectDemoNote);
+    });
+  });
+}
+const CLASS_MEMBER_MODIFIERS = "(?:(?:public|private|protected|readonly|static|abstract|override)\\s+)*";
+function buildMembers(methods, properties) {
+  return {
+    all: [...methods, ...properties],
+    methods,
+    properties
+  };
+}
+function extractClassMethodNames(classBody) {
+  return [...classBody.matchAll(new RegExp(`^ {2}(?<modifiers>${CLASS_MEMBER_MODIFIERS})(?<name>\\w+)(?:<[^>]*>)?\\(`, "gm"))].filter((match) => !isNonPublicMember(getMandatoryNamedGroup(match, "modifiers"))).map((match) => getMandatoryNamedGroup(match, "name"));
+}
+function extractClassPropertyNames(classBody) {
+  return [...classBody.matchAll(new RegExp(`^ {2}(?<modifiers>${CLASS_MEMBER_MODIFIERS})(?<name>\\w+)\\s*\\??\\s*[:=]`, "gm"))].filter((match) => !isNonPublicMember(getMandatoryNamedGroup(match, "modifiers"))).map((match) => getMandatoryNamedGroup(match, "name"));
+}
+function extractEnumMemberNames(enumBody) {
+  return [...enumBody.matchAll(/^ {2}(?<name>\w+)/gm)].map((match) => getMandatoryNamedGroup(match, "name"));
+}
+function extractMethodNames(interfaceBody) {
+  return [...interfaceBody.matchAll(/^ {2}(?<name>\w+)(?:<[^>]*>)?\(/gm)].map((match) => getMandatoryNamedGroup(match, "name"));
+}
+function extractPropertyNames(interfaceBody) {
+  return [...interfaceBody.matchAll(/^ {2}(?<name>\w+)\??:/gm)].map((match) => getMandatoryNamedGroup(match, "name"));
+}
+function isNonPublicMember(modifiers) {
+  return /\b(?:private|protected)\b/.test(modifiers);
+}
+function parseMembers(keyword, body) {
+  switch (keyword) {
+    case "class":
+      return buildMembers(extractClassMethodNames(body), extractClassPropertyNames(body));
+    case "enum":
+      return buildMembers([], extractEnumMemberNames(body));
+    default:
+      return buildMembers(extractMethodNames(body), extractPropertyNames(body));
+  }
+}
+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(`${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(`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 = '(?:(?: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(`^ {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(`^ {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    case 'enum':\n      return buildMembers([], extractEnumMemberNames(body));\n    default:\n      return buildMembers(extractMethodNames(body), extractPropertyNames(body));\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -6,18 +6,18 @@
  *
  * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. At release time this
  * module installs the freshly built plugin into that vault's `.obsidian/plugins/<id>/` folder and
- * zips the whole vault into `dist/build/demo-vault-<version>.zip`, so the existing GitHub-release
- * step (which uploads every file in `dist/build/`) attaches it automatically.
+ * zips the whole vault into `dist/build/<plugin-id>.demo-vault.zip`, so the existing GitHub-release
+ * step (which uploads every file in `dist/build/`) attaches it automatically. The archive is named by
+ * plugin id (not just `demo-vault`) so several plugins' demo vaults never collide.
  */
 /**
  * Archives the plugin's demo vault (`demo-vault/` in the repo root) as a release artifact.
  *
  * Installs the freshly built plugin from `dist/build/` into the vault's
  * `.obsidian/plugins/<id>/` folder, then zips the whole vault to
- * `dist/build/demo-vault-<version>.zip`.
+ * `dist/build/<plugin-id>.demo-vault.zip`.
  *
- * @param newVersion - The version being released, used in the archive file name.
  * @returns A {@link Promise} that resolves to the absolute path of the created zip archive, or
  * `null` if the repo has no `demo-vault/` folder.
  */
-export declare function archivePluginDemoVault(newVersion: string): Promise<null | string>;
+export declare function archivePluginDemoVault(): Promise<null | string>;