obsidian-dev-utils 87.0.2 → 87.0.3

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

@@ -0,0 +1,264 @@
+/// <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
+ *   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;

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

@@ -0,0 +1,190 @@
+/*
+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 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 = readFileSync(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 = 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) => 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([]);
+      });
+    }
+    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);
+    });
+  });
+}
+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"));
+}
+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 *   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": ";;;;;;;;;;;;;;;;;;;;;;;AAkBA;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;AAwNhC,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,GAAG,OAAO,QAAQ,sBAAsB,GAAG,CAAC,CAAC,EACvG,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;AAAA,EASO,oBAAoB,QAA6E;AACtG,UAAM,SAAS,aAAa,KAAK,KAAK,YAAY,OAAO,UAAU,GAAG,OAAO;AAC7E,UAAM,QAAQ,IAAI,OAAO,oBAAoB,OAAO,aAAa,+BAA+B,EAAE,KAAK,MAAM;AAC7G,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,4BAA4B,OAAO,aAAa,EAAE;AAAA,IACpE;AACA,UAAM,OAAO,uBAAuB,OAAO,MAAM;AACjD,UAAM,UAAU,mBAAmB,IAAI;AACvC,UAAM,aAAa,qBAAqB,IAAI;AAC5C,WAAO;AAAA,MACL,KAAK,CAAC,GAAG,SAAS,GAAG,UAAU;AAAA,MAC/B;AAAA,MACA;AAAA,IACF;AAAA,EACF;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,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,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;",
  "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>;

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

@@ -29,9 +29,17 @@ import {
   readFile
 } from "node:fs/promises";
 import { ObsidianPluginRepoPaths } from "../obsidian/plugin/obsidian-plugin-repo-paths.mjs";
-import { join } from "../path.mjs";
-import { resolvePathFromRootSafe } from "./root.mjs";
-async function archivePluginDemoVault(newVersion) {
+import {
+  getFolderName,
+  join
+} from "../path.mjs";
+import { ObsidianDevUtilsRepoPaths } from "./obsidian-dev-utils-repo-paths.mjs";
+import {
+  getRootFolder,
+  resolvePathFromRootSafe
+} from "./root.mjs";
+const DEMO_VAULT_HELPER_PLUGIN_ID = "demo-vault-helper";
+async function archivePluginDemoVault() {
   const demoVaultPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DemoVault });
   if (!existsSync(demoVaultPath)) {
     return null;
@@ -49,15 +57,33 @@ async function archivePluginDemoVault(newVersion) {
   await mkdir(pluginFolder, { recursive: true });
   const distBuildPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DistBuild });
   await cp(distBuildPath, pluginFolder, { recursive: true });
+  await injectDemoVaultHelper();
   const zipPath = resolvePathFromRootSafe({
-    path: join(ObsidianPluginRepoPaths.DistBuild, `demo-vault-${newVersion}.zip`)
+    path: join(ObsidianPluginRepoPaths.DistBuild, `${manifest.id}.demo-vault.zip`)
   });
   const zip = new AdmZip();
   zip.addLocalFolder(demoVaultPath);
   await zip.writeZipPromise(zipPath);
   return zipPath;
 }
+async function injectDemoVaultHelper() {
+  const packageFolder = getRootFolder(getFolderName(import.meta.url));
+  if (!packageFolder) {
+    throw new Error("Could not resolve the obsidian-dev-utils package folder to inject the demo-vault-helper plugin.");
+  }
+  const helperSourcePath = join(packageFolder, ObsidianDevUtilsRepoPaths.DistDemoVaultHelper);
+  const helperFolder = resolvePathFromRootSafe({
+    path: join(
+      ObsidianPluginRepoPaths.DemoVault,
+      ObsidianPluginRepoPaths.DotObsidian,
+      ObsidianPluginRepoPaths.Plugins,
+      DEMO_VAULT_HELPER_PLUGIN_ID
+    )
+  });
+  await mkdir(helperFolder, { recursive: true });
+  await cp(helperSourcePath, helperFolder, { recursive: true });
+}
 export {
   archivePluginDemoVault
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/index.d.mts

@@ -5,6 +5,7 @@ export * as 'check-project-types' from './check-project-types.mjs';
 export * as 'cli-utils' from './cli-utils.mjs';
 export * as 'code-generator' from './code-generator.mjs';
 export * as 'commitlint-config' from './commitlint-config.mjs';
+export * as 'demo-vault-coverage' from './demo-vault-coverage.mjs';
 export * as 'demo-vault' from './demo-vault.mjs';
 export * as 'exec' from './exec.mjs';
 export * as 'formatters' from './formatters/index.mjs';

package/dist/lib/esm/script-utils/index.mjs

@@ -27,6 +27,7 @@ import * as check_project_types from "./check-project-types.mjs";
 import * as cli_utils from "./cli-utils.mjs";
 import * as code_generator from "./code-generator.mjs";
 import * as commitlint_config from "./commitlint-config.mjs";
+import * as demo_vault_coverage from "./demo-vault-coverage.mjs";
 import * as demo_vault from "./demo-vault.mjs";
 import * as exec from "./exec.mjs";
 import * as formatters from "./formatters/index.mjs";
@@ -51,6 +52,7 @@ export {
   code_generator as "code-generator",
   commitlint_config as "commitlint-config",
   demo_vault as "demo-vault",
+  demo_vault_coverage as "demo-vault-coverage",
   exec,
   formatters,
   fs,
@@ -67,4 +69,4 @@ export {
   version,
   warnings_as_errors as "warnings-as-errors"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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