obsidian-dev-utils 87.0.2 → 87.0.3

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;

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

@@ -143,8 +143,23 @@ var import_node_fs = require('node:fs');
 var import_promises = require('node:fs/promises');
 var import_obsidian_plugin_repo_paths = require('../obsidian/plugin/obsidian-plugin-repo-paths.cjs');
 var import_path = require('../path.cjs');
+var import_obsidian_dev_utils_repo_paths = require('./obsidian-dev-utils-repo-paths.cjs');
 var import_root = require('./root.cjs');
-async function archivePluginDemoVault(newVersion) {
+var __import_meta_url = globalThis["import.meta.url"] ?? (() => {
+  if (typeof __filename === "string") {
+    const localRequire = require;
+    const url = localRequire("node:url");
+    if (typeof url.pathToFileURL === "function") {
+      return url.pathToFileURL(__filename).href;
+    }
+  }
+  if (typeof window !== "undefined") {
+    return activeWindow.location.href;
+  }
+  return "";
+})();
+const DEMO_VAULT_HELPER_PLUGIN_ID = "demo-vault-helper";
+async function archivePluginDemoVault() {
   const demoVaultPath = (0, import_root.resolvePathFromRootSafe)({ path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DemoVault });
   if (!(0, import_node_fs.existsSync)(demoVaultPath)) {
     return null;
@@ -162,16 +177,34 @@ async function archivePluginDemoVault(newVersion) {
   await (0, import_promises.mkdir)(pluginFolder, { recursive: true });
   const distBuildPath = (0, import_root.resolvePathFromRootSafe)({ path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DistBuild });
   await (0, import_promises.cp)(distBuildPath, pluginFolder, { recursive: true });
+  await injectDemoVaultHelper();
   const zipPath = (0, import_root.resolvePathFromRootSafe)({
-    path: (0, import_path.join)(import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DistBuild, `demo-vault-${newVersion}.zip`)
+    path: (0, import_path.join)(import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DistBuild, `${manifest.id}.demo-vault.zip`)
   });
   const zip = new import_adm_zip.default();
   zip.addLocalFolder(demoVaultPath);
   await zip.writeZipPromise(zipPath);
   return zipPath;
 }
+async function injectDemoVaultHelper() {
+  const packageFolder = (0, import_root.getRootFolder)((0, import_path.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 = (0, import_path.join)(packageFolder, import_obsidian_dev_utils_repo_paths.ObsidianDevUtilsRepoPaths.DistDemoVaultHelper);
+  const helperFolder = (0, import_root.resolvePathFromRootSafe)({
+    path: (0, import_path.join)(
+      import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DemoVault,
+      import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DotObsidian,
+      import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.Plugins,
+      DEMO_VAULT_HELPER_PLUGIN_ID
+    )
+  });
+  await (0, import_promises.mkdir)(helperFolder, { recursive: true });
+  await (0, import_promises.cp)(helperSourcePath, helperFolder, { recursive: true });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   archivePluginDemoVault
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/demo-vault.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (() => {\n      if (typeof __filename === 'string') {\n        const localRequire = require;\n        const url = localRequire('node:url');\n        if (typeof url.pathToFileURL === 'function') {\n          return url.pathToFileURL(__filename).href;\n        }\n      }\n\n      if (typeof window !== 'undefined') {\n        return activeWindow.location.href;\n      }\n\n      // Fallback to an empty string if the environment is unknown\n      return '';\n    })();\n/**\n * @file\n *\n * Archives a plugin's demo vault as a release artifact.\n *\n * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. At release time this\n * module installs the freshly built plugin into that vault's `.obsidian/plugins/<id>/` folder and\n * zips the whole vault into `dist/build/<plugin-id>.demo-vault.zip`, so the existing GitHub-release\n * step (which uploads every file in `dist/build/`) attaches it automatically. The archive is named by\n * plugin id (not just `demo-vault`) so several plugins' demo vaults never collide.\n */\n\nimport AdmZip from 'adm-zip';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile\n} from 'node:fs/promises';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport {\n  getFolderName,\n  join\n} from '../path.ts';\nimport { ObsidianDevUtilsRepoPaths } from './obsidian-dev-utils-repo-paths.ts';\nimport {\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\nconst DEMO_VAULT_HELPER_PLUGIN_ID = 'demo-vault-helper';\n\n/**\n * The minimal shape of a plugin `manifest.json` read by {@link archivePluginDemoVault}.\n */\ninterface PluginManifest {\n  /**\n   * The plugin id, used as the folder name under `demo-vault/.obsidian/plugins/`.\n   */\n  readonly id: string;\n}\n\n/**\n * Archives the plugin's demo vault (`demo-vault/` in the repo root) as a release artifact.\n *\n * Installs the freshly built plugin from `dist/build/` into the vault's\n * `.obsidian/plugins/<id>/` folder, then zips the whole vault to\n * `dist/build/<plugin-id>.demo-vault.zip`.\n *\n * @returns A {@link Promise} that resolves to the absolute path of the created zip archive, or\n * `null` if the repo has no `demo-vault/` folder.\n */\nexport async function archivePluginDemoVault(): Promise<null | string> {\n  const demoVaultPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DemoVault });\n  if (!existsSync(demoVaultPath)) {\n    return null;\n  }\n\n  const manifestPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.ManifestJson });\n  const manifest = JSON.parse(await readFile(manifestPath, 'utf-8')) as PluginManifest;\n\n  const pluginFolder = resolvePathFromRootSafe({\n    path: join(\n      ObsidianPluginRepoPaths.DemoVault,\n      ObsidianPluginRepoPaths.DotObsidian,\n      ObsidianPluginRepoPaths.Plugins,\n      manifest.id\n    )\n  });\n  await mkdir(pluginFolder, { recursive: true });\n\n  const distBuildPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DistBuild });\n  await cp(distBuildPath, pluginFolder, { recursive: true });\n\n  await injectDemoVaultHelper();\n\n  // Archive name is hand-synced with the runtime `openDemoVault` opener, which downloads this exact asset name.\n  const zipPath = resolvePathFromRootSafe({\n    path: join(ObsidianPluginRepoPaths.DistBuild, `${manifest.id}.demo-vault.zip`)\n  });\n  const zip = new AdmZip();\n  zip.addLocalFolder(demoVaultPath);\n  await zip.writeZipPromise(zipPath);\n  return zipPath;\n}\n\n// Injects the built, `obsidian-dev-utils`-owned `demo-vault-helper` bootstrap plugin (shipped in this package) into the demo vault, so no per-vault copy is committed and an `obsidian-dev-utils` bump propagates fixes.\nasync function injectDemoVaultHelper(): Promise<void> {\n  const packageFolder = getRootFolder(getFolderName(import.meta.url));\n  if (!packageFolder) {\n    throw new Error('Could not resolve the obsidian-dev-utils package folder to inject the demo-vault-helper plugin.');\n  }\n\n  const helperSourcePath = join(packageFolder, ObsidianDevUtilsRepoPaths.DistDemoVaultHelper);\n  const helperFolder = resolvePathFromRootSafe({\n    path: join(\n      ObsidianPluginRepoPaths.DemoVault,\n      ObsidianPluginRepoPaths.DotObsidian,\n      ObsidianPluginRepoPaths.Plugins,\n      DEMO_VAULT_HELPER_PLUGIN_ID\n    )\n  });\n  await mkdir(helperFolder, { recursive: true });\n  await cp(helperSourcePath, helperFolder, { recursive: true });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA4BA,qBAAmB;AACnB,qBAA2B;AAC3B,sBAIO;AAEP,wCAAwC;AACxC,kBAGO;AACP,2CAA0C;AAC1C,kBAGO;AA7CP,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAM;AAC1D,MAAI,OAAO,eAAe,UAAU;AAClC,UAAM,eAAe;AACrB,UAAM,MAAM,aAAa,UAAU;AACnC,QAAI,OAAO,IAAI,kBAAkB,YAAY;AAC3C,aAAO,IAAI,cAAc,UAAU,EAAE;AAAA,IACvC;AAAA,EACF;AAEA,MAAI,OAAO,WAAW,aAAa;AACjC,WAAO,aAAa,SAAS;AAAA,EAC/B;AAGA,SAAO;AACT,GAAG;AAgCP,MAAM,8BAA8B;AAsBpC,eAAsB,yBAAiD;AACrE,QAAM,oBAAgB,qCAAwB,EAAE,MAAM,0DAAwB,UAAU,CAAC;AACzF,MAAI,KAAC,2BAAW,aAAa,GAAG;AAC9B,WAAO;AAAA,EACT;AAEA,QAAM,mBAAe,qCAAwB,EAAE,MAAM,0DAAwB,aAAa,CAAC;AAC3F,QAAM,WAAW,KAAK,MAAM,UAAM,0BAAS,cAAc,OAAO,CAAC;AAEjE,QAAM,mBAAe,qCAAwB;AAAA,IAC3C,UAAM;AAAA,MACJ,0DAAwB;AAAA,MACxB,0DAAwB;AAAA,MACxB,0DAAwB;AAAA,MACxB,SAAS;AAAA,IACX;AAAA,EACF,CAAC;AACD,YAAM,uBAAM,cAAc,EAAE,WAAW,KAAK,CAAC;AAE7C,QAAM,oBAAgB,qCAAwB,EAAE,MAAM,0DAAwB,UAAU,CAAC;AACzF,YAAM,oBAAG,eAAe,cAAc,EAAE,WAAW,KAAK,CAAC;AAEzD,QAAM,sBAAsB;AAG5B,QAAM,cAAU,qCAAwB;AAAA,IACtC,UAAM,kBAAK,0DAAwB,WAAW,GAAG,SAAS,EAAE,iBAAiB;AAAA,EAC/E,CAAC;AACD,QAAM,MAAM,IAAI,eAAAA,QAAO;AACvB,MAAI,eAAe,aAAa;AAChC,QAAM,IAAI,gBAAgB,OAAO;AACjC,SAAO;AACT;AAGA,eAAe,wBAAuC;AACpD,QAAM,oBAAgB,+BAAc,2BAAc,iBAAe,CAAC;AAClE,MAAI,CAAC,eAAe;AAClB,UAAM,IAAI,MAAM,iGAAiG;AAAA,EACnH;AAEA,QAAM,uBAAmB,kBAAK,eAAe,+DAA0B,mBAAmB;AAC1F,QAAM,mBAAe,qCAAwB;AAAA,IAC3C,UAAM;AAAA,MACJ,0DAAwB;AAAA,MACxB,0DAAwB;AAAA,MACxB,0DAAwB;AAAA,MACxB;AAAA,IACF;AAAA,EACF,CAAC;AACD,YAAM,uBAAM,cAAc,EAAE,WAAW,KAAK,CAAC;AAC7C,YAAM,oBAAG,kBAAkB,cAAc,EAAE,WAAW,KAAK,CAAC;AAC9D;",
  "names": ["AdmZip"]
}


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

@@ -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/cjs/script-utils/index.cjs

@@ -142,6 +142,7 @@ __export(script_utils_exports, {
   "code-generator": () => code_generator,
   "commitlint-config": () => commitlint_config,
   "demo-vault": () => demo_vault,
+  "demo-vault-coverage": () => demo_vault_coverage,
   exec: () => exec,
   formatters: () => formatters,
   fs: () => fs,
@@ -165,6 +166,7 @@ var check_project_types = __toESM(__extractDefault(require('./check-project-type
 var cli_utils = __toESM(__extractDefault(require('./cli-utils.cjs')), 1);
 var code_generator = __toESM(__extractDefault(require('./code-generator.cjs')), 1);
 var commitlint_config = __toESM(__extractDefault(require('./commitlint-config.cjs')), 1);
+var demo_vault_coverage = __toESM(__extractDefault(require('./demo-vault-coverage.cjs')), 1);
 var demo_vault = __toESM(__extractDefault(require('./demo-vault.cjs')), 1);
 var exec = __toESM(__extractDefault(require('./exec.cjs')), 1);
 var formatters = __toESM(__extractDefault(require('./formatters/index.cjs')), 1);
@@ -190,6 +192,7 @@ var warnings_as_errors = __toESM(__extractDefault(require('./warnings-as-errors.
   "code-generator": null,
   "commitlint-config": null,
   "demo-vault": null,
+  "demo-vault-coverage": null,
   exec,
   formatters,
   fs,
@@ -206,4 +209,4 @@ var warnings_as_errors = __toESM(__extractDefault(require('./warnings-as-errors.
   version,
   "warnings-as-errors": null
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdidWlsZCcgZnJvbSAnLi9idWlsZC50cyc7XG5leHBvcnQgKiBhcyAnYnVuZGxlcnMnIGZyb20gJy4vYnVuZGxlcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ2NoZWNrLXByb2plY3QtdHlwZXMnIGZyb20gJy4vY2hlY2stcHJvamVjdC10eXBlcy50cyc7XG5leHBvcnQgKiBhcyAnY2xpLXV0aWxzJyBmcm9tICcuL2NsaS11dGlscy50cyc7XG5leHBvcnQgKiBhcyAnY29kZS1nZW5lcmF0b3InIGZyb20gJy4vY29kZS1nZW5lcmF0b3IudHMnO1xuZXhwb3J0ICogYXMgJ2NvbW1pdGxpbnQtY29uZmlnJyBmcm9tICcuL2NvbW1pdGxpbnQtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdkZW1vLXZhdWx0JyBmcm9tICcuL2RlbW8tdmF1bHQudHMnO1xuZXhwb3J0ICogYXMgJ2V4ZWMnIGZyb20gJy4vZXhlYy50cyc7XG5leHBvcnQgKiBhcyAnZm9ybWF0dGVycycgZnJvbSAnLi9mb3JtYXR0ZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdmcycgZnJvbSAnLi9mcy50cyc7XG5leHBvcnQgKiBhcyAnanNvbicgZnJvbSAnLi9qc29uLnRzJztcbmV4cG9ydCAqIGFzICdsaW50ZXJzJyBmcm9tICcuL2xpbnRlcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ25hbm8tc3RhZ2VkLWNvbmZpZycgZnJvbSAnLi9uYW5vLXN0YWdlZC1jb25maWcudHMnO1xuZXhwb3J0ICogYXMgJ25wbS1wdWJsaXNoJyBmcm9tICcuL25wbS1wdWJsaXNoLnRzJztcbmV4cG9ydCAqIGFzICducG0tcnVuJyBmcm9tICcuL25wbS1ydW4udHMnO1xuZXhwb3J0ICogYXMgJ25wbScgZnJvbSAnLi9ucG0udHMnO1xuZXhwb3J0ICogYXMgJ29ic2lkaWFuLWRldi11dGlscy1yZXBvLXBhdGhzJyBmcm9tICcuL29ic2lkaWFuLWRldi11dGlscy1yZXBvLXBhdGhzLnRzJztcbmV4cG9ydCAqIGFzICdyb290JyBmcm9tICcuL3Jvb3QudHMnO1xuZXhwb3J0ICogYXMgJ3Rlc3QtcnVubmVycycgZnJvbSAnLi90ZXN0LXJ1bm5lcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ3ZhbGlkYXRlLWRlY2xhcmF0aW9ucycgZnJvbSAnLi92YWxpZGF0ZS1kZWNsYXJhdGlvbnMudHMnO1xuZXhwb3J0ICogYXMgJ3ZlcnNpb24nIGZyb20gJy4vdmVyc2lvbi50cyc7XG5leHBvcnQgKiBhcyAnd2FybmluZ3MtYXMtZXJyb3JzJyBmcm9tICcuL3dhcm5pbmdzLWFzLWVycm9ycy50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLCtCQUFBQTtBQUFBLEVBQUEsbUJBQUFDO0FBQUEsRUFBQSx3QkFBQUM7QUFBQSxFQUFBLDJCQUFBQztBQUFBLEVBQUEsb0JBQUFDO0FBQUEsRUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsOEJBQUFDO0FBQUEsRUFBQTtBQUFBLHVCQUFBQztBQUFBLEVBQUEsaUJBQUFDO0FBQUEsRUFBQSx1Q0FBQUM7QUFBQSxFQUFBO0FBQUEsd0JBQUFDO0FBQUEsRUFBQSwrQkFBQUM7QUFBQSxFQUFBO0FBQUEsOEJBQUFDO0FBQUE7QUFBQTtBQUVBLFlBQXlCO0FBQ3pCLGVBQTRCO0FBQzVCLElBQUFYLHNCQUF1QztBQUN2QyxJQUFBQyxZQUE2QjtBQUM3QixJQUFBQyxpQkFBa0M7QUFDbEMsSUFBQUMsb0JBQXFDO0FBQ3JDLElBQUFDLGFBQThCO0FBQzlCLFdBQXdCO0FBQ3hCLGlCQUE4QjtBQUM5QixTQUFzQjtBQUN0QixXQUF3QjtBQUN4QixjQUEyQjtBQUMzQixJQUFBQyxxQkFBc0M7QUFDdEMsSUFBQUMsY0FBK0I7QUFDL0IsSUFBQUMsVUFBMkI7QUFDM0IsVUFBdUI7QUFDdkIsSUFBQUMsZ0NBQWlEO0FBQ2pELFdBQXdCO0FBQ3hCLElBQUFDLGVBQWdDO0FBQ2hDLElBQUFDLHdCQUF5QztBQUN6QyxjQUEyQjtBQUMzQixJQUFBQyxxQkFBc0M7IiwKICAibmFtZXMiOiBbImNoZWNrLXByb2plY3QtdHlwZXMiLCAiY2xpLXV0aWxzIiwgImNvZGUtZ2VuZXJhdG9yIiwgImNvbW1pdGxpbnQtY29uZmlnIiwgImRlbW8tdmF1bHQiLCAibmFuby1zdGFnZWQtY29uZmlnIiwgIm5wbS1wdWJsaXNoIiwgIm5wbS1ydW4iLCAib2JzaWRpYW4tZGV2LXV0aWxzLXJlcG8tcGF0aHMiLCAidGVzdC1ydW5uZXJzIiwgInZhbGlkYXRlLWRlY2xhcmF0aW9ucyIsICJ3YXJuaW5ncy1hcy1lcnJvcnMiXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdidWlsZCcgZnJvbSAnLi9idWlsZC50cyc7XG5leHBvcnQgKiBhcyAnYnVuZGxlcnMnIGZyb20gJy4vYnVuZGxlcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ2NoZWNrLXByb2plY3QtdHlwZXMnIGZyb20gJy4vY2hlY2stcHJvamVjdC10eXBlcy50cyc7XG5leHBvcnQgKiBhcyAnY2xpLXV0aWxzJyBmcm9tICcuL2NsaS11dGlscy50cyc7XG5leHBvcnQgKiBhcyAnY29kZS1nZW5lcmF0b3InIGZyb20gJy4vY29kZS1nZW5lcmF0b3IudHMnO1xuZXhwb3J0ICogYXMgJ2NvbW1pdGxpbnQtY29uZmlnJyBmcm9tICcuL2NvbW1pdGxpbnQtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdkZW1vLXZhdWx0LWNvdmVyYWdlJyBmcm9tICcuL2RlbW8tdmF1bHQtY292ZXJhZ2UudHMnO1xuZXhwb3J0ICogYXMgJ2RlbW8tdmF1bHQnIGZyb20gJy4vZGVtby12YXVsdC50cyc7XG5leHBvcnQgKiBhcyAnZXhlYycgZnJvbSAnLi9leGVjLnRzJztcbmV4cG9ydCAqIGFzICdmb3JtYXR0ZXJzJyBmcm9tICcuL2Zvcm1hdHRlcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ2ZzJyBmcm9tICcuL2ZzLnRzJztcbmV4cG9ydCAqIGFzICdqc29uJyBmcm9tICcuL2pzb24udHMnO1xuZXhwb3J0ICogYXMgJ2xpbnRlcnMnIGZyb20gJy4vbGludGVycy9pbmRleC50cyc7XG5leHBvcnQgKiBhcyAnbmFuby1zdGFnZWQtY29uZmlnJyBmcm9tICcuL25hbm8tc3RhZ2VkLWNvbmZpZy50cyc7XG5leHBvcnQgKiBhcyAnbnBtLXB1Ymxpc2gnIGZyb20gJy4vbnBtLXB1Ymxpc2gudHMnO1xuZXhwb3J0ICogYXMgJ25wbS1ydW4nIGZyb20gJy4vbnBtLXJ1bi50cyc7XG5leHBvcnQgKiBhcyAnbnBtJyBmcm9tICcuL25wbS50cyc7XG5leHBvcnQgKiBhcyAnb2JzaWRpYW4tZGV2LXV0aWxzLXJlcG8tcGF0aHMnIGZyb20gJy4vb2JzaWRpYW4tZGV2LXV0aWxzLXJlcG8tcGF0aHMudHMnO1xuZXhwb3J0ICogYXMgJ3Jvb3QnIGZyb20gJy4vcm9vdC50cyc7XG5leHBvcnQgKiBhcyAndGVzdC1ydW5uZXJzJyBmcm9tICcuL3Rlc3QtcnVubmVycy9pbmRleC50cyc7XG5leHBvcnQgKiBhcyAndmFsaWRhdGUtZGVjbGFyYXRpb25zJyBmcm9tICcuL3ZhbGlkYXRlLWRlY2xhcmF0aW9ucy50cyc7XG5leHBvcnQgKiBhcyAndmVyc2lvbicgZnJvbSAnLi92ZXJzaW9uLnRzJztcbmV4cG9ydCAqIGFzICd3YXJuaW5ncy1hcy1lcnJvcnMnIGZyb20gJy4vd2FybmluZ3MtYXMtZXJyb3JzLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsK0JBQUFBO0FBQUEsRUFBQSxtQkFBQUM7QUFBQSxFQUFBLHdCQUFBQztBQUFBLEVBQUEsMkJBQUFDO0FBQUEsRUFBQSxvQkFBQUM7QUFBQSxFQUFBLDZCQUFBQztBQUFBLEVBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLDhCQUFBQztBQUFBLEVBQUE7QUFBQSx1QkFBQUM7QUFBQSxFQUFBLGlCQUFBQztBQUFBLEVBQUEsdUNBQUFDO0FBQUEsRUFBQTtBQUFBLHdCQUFBQztBQUFBLEVBQUEsK0JBQUFDO0FBQUEsRUFBQTtBQUFBLDhCQUFBQztBQUFBO0FBQUE7QUFFQSxZQUF5QjtBQUN6QixlQUE0QjtBQUM1QixJQUFBWixzQkFBdUM7QUFDdkMsSUFBQUMsWUFBNkI7QUFDN0IsSUFBQUMsaUJBQWtDO0FBQ2xDLElBQUFDLG9CQUFxQztBQUNyQyxJQUFBRSxzQkFBdUM7QUFDdkMsSUFBQUQsYUFBOEI7QUFDOUIsV0FBd0I7QUFDeEIsaUJBQThCO0FBQzlCLFNBQXNCO0FBQ3RCLFdBQXdCO0FBQ3hCLGNBQTJCO0FBQzNCLElBQUFFLHFCQUFzQztBQUN0QyxJQUFBQyxjQUErQjtBQUMvQixJQUFBQyxVQUEyQjtBQUMzQixVQUF1QjtBQUN2QixJQUFBQyxnQ0FBaUQ7QUFDakQsV0FBd0I7QUFDeEIsSUFBQUMsZUFBZ0M7QUFDaEMsSUFBQUMsd0JBQXlDO0FBQ3pDLGNBQTJCO0FBQzNCLElBQUFDLHFCQUFzQzsiLAogICJuYW1lcyI6IFsiY2hlY2stcHJvamVjdC10eXBlcyIsICJjbGktdXRpbHMiLCAiY29kZS1nZW5lcmF0b3IiLCAiY29tbWl0bGludC1jb25maWciLCAiZGVtby12YXVsdCIsICJkZW1vLXZhdWx0LWNvdmVyYWdlIiwgIm5hbm8tc3RhZ2VkLWNvbmZpZyIsICJucG0tcHVibGlzaCIsICJucG0tcnVuIiwgIm9ic2lkaWFuLWRldi11dGlscy1yZXBvLXBhdGhzIiwgInRlc3QtcnVubmVycyIsICJ2YWxpZGF0ZS1kZWNsYXJhdGlvbnMiLCAid2FybmluZ3MtYXMtZXJyb3JzIl0KfQo=

package/dist/lib/cjs/script-utils/index.d.cts

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