@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.1.0

package/dist/lib/esm/demo-vault-cli.mjs

@@ -0,0 +1,23 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import process from "node:process";
+import { archivePluginDemoVault } from "./demo-vault.mjs";
+async function runArchiveDemoVaultCli() {
+  try {
+    const zipPath = await archivePluginDemoVault();
+    process.stdout.write(zipPath === null ? "No demo-vault/ folder: nothing to archive.\n" : `Archived the demo vault to ${zipPath}
+`);
+    return 0;
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+}
+export {
+  runArchiveDemoVaultCli
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/index.d.mts

@@ -6,6 +6,7 @@
 export * as 'bundlers' from './bundlers/index.mjs';
 export * as 'demo-vault-app-json' from './demo-vault-app-json.mjs';
 export * as 'demo-vault-buttons' from './demo-vault-buttons.mjs';
+export * as 'demo-vault-cli' from './demo-vault-cli.mjs';
 export * as 'demo-vault-coverage' from './demo-vault-coverage.mjs';
 export * as 'demo-vault' from './demo-vault.mjs';
 export * as 'docs-site' from './docs-site/index.mjs';

package/dist/lib/esm/index.mjs

@@ -6,6 +6,7 @@ if you want to view the source, please visit the github repository of this plugi
 import * as bundlers from "./bundlers/index.mjs";
 import * as demo_vault_app_json from "./demo-vault-app-json.mjs";
 import * as demo_vault_buttons from "./demo-vault-buttons.mjs";
+import * as demo_vault_cli from "./demo-vault-cli.mjs";
 import * as demo_vault_coverage from "./demo-vault-coverage.mjs";
 import * as demo_vault from "./demo-vault.mjs";
 import * as docs_site from "./docs-site/index.mjs";
@@ -20,6 +21,7 @@ export {
   demo_vault as "demo-vault",
   demo_vault_app_json as "demo-vault-app-json",
   demo_vault_buttons as "demo-vault-buttons",
+  demo_vault_cli as "demo-vault-cli",
   demo_vault_coverage as "demo-vault-coverage",
   docs_site as "docs-site",
   formatters,
@@ -29,4 +31,4 @@ export {
   test_runners as "test-runners",
   version
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2J1bmRsZXJzJyBmcm9tICcuL2J1bmRsZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdkZW1vLXZhdWx0LWFwcC1qc29uJyBmcm9tICcuL2RlbW8tdmF1bHQtYXBwLWpzb24udHMnO1xuZXhwb3J0ICogYXMgJ2RlbW8tdmF1bHQtYnV0dG9ucycgZnJvbSAnLi9kZW1vLXZhdWx0LWJ1dHRvbnMudHMnO1xuZXhwb3J0ICogYXMgJ2RlbW8tdmF1bHQtY292ZXJhZ2UnIGZyb20gJy4vZGVtby12YXVsdC1jb3ZlcmFnZS50cyc7XG5leHBvcnQgKiBhcyAnZGVtby12YXVsdCcgZnJvbSAnLi9kZW1vLXZhdWx0LnRzJztcbmV4cG9ydCAqIGFzICdkb2NzLXNpdGUnIGZyb20gJy4vZG9jcy1zaXRlL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdmb3JtYXR0ZXJzJyBmcm9tICcuL2Zvcm1hdHRlcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ2xpbnRlcnMnIGZyb20gJy4vbGludGVycy9pbmRleC50cyc7XG5leHBvcnQgKiBhcyAnb2JzaWRpYW4tcGx1Z2luLXJlcG8tcGF0aHMnIGZyb20gJy4vb2JzaWRpYW4tcGx1Z2luLXJlcG8tcGF0aHMudHMnO1xuZXhwb3J0ICogYXMgJ3RlbXBsYXRlcycgZnJvbSAnLi90ZW1wbGF0ZXMudHMnO1xuZXhwb3J0ICogYXMgJ3Rlc3QtcnVubmVycycgZnJvbSAnLi90ZXN0LXJ1bm5lcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ3ZlcnNpb24nIGZyb20gJy4vdmVyc2lvbi50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVksY0FBZ0I7QUFDNUIsWUFBWUEseUJBQTJCO0FBQ3ZDLFlBQVlDLHdCQUEwQjtBQUN0QyxZQUFZQyx5QkFBMkI7QUFDdkMsWUFBWUMsZ0JBQWtCO0FBQzlCLFlBQVlDLGVBQWlCO0FBQzdCLFlBQVksZ0JBQWtCO0FBQzlCLFlBQVksYUFBZTtBQUMzQixZQUFZQyxnQ0FBa0M7QUFDOUMsWUFBWSxlQUFpQjtBQUM3QixZQUFZQyxrQkFBb0I7QUFDaEMsWUFBWSxhQUFlOyIsCiAgIm5hbWVzIjogWyJkZW1vLXZhdWx0LWFwcC1qc29uIiwgImRlbW8tdmF1bHQtYnV0dG9ucyIsICJkZW1vLXZhdWx0LWNvdmVyYWdlIiwgImRlbW8tdmF1bHQiLCAiZG9jcy1zaXRlIiwgIm9ic2lkaWFuLXBsdWdpbi1yZXBvLXBhdGhzIiwgInRlc3QtcnVubmVycyJdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2J1bmRsZXJzJyBmcm9tICcuL2J1bmRsZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdkZW1vLXZhdWx0LWFwcC1qc29uJyBmcm9tICcuL2RlbW8tdmF1bHQtYXBwLWpzb24udHMnO1xuZXhwb3J0ICogYXMgJ2RlbW8tdmF1bHQtYnV0dG9ucycgZnJvbSAnLi9kZW1vLXZhdWx0LWJ1dHRvbnMudHMnO1xuZXhwb3J0ICogYXMgJ2RlbW8tdmF1bHQtY2xpJyBmcm9tICcuL2RlbW8tdmF1bHQtY2xpLnRzJztcbmV4cG9ydCAqIGFzICdkZW1vLXZhdWx0LWNvdmVyYWdlJyBmcm9tICcuL2RlbW8tdmF1bHQtY292ZXJhZ2UudHMnO1xuZXhwb3J0ICogYXMgJ2RlbW8tdmF1bHQnIGZyb20gJy4vZGVtby12YXVsdC50cyc7XG5leHBvcnQgKiBhcyAnZG9jcy1zaXRlJyBmcm9tICcuL2RvY3Mtc2l0ZS9pbmRleC50cyc7XG5leHBvcnQgKiBhcyAnZm9ybWF0dGVycycgZnJvbSAnLi9mb3JtYXR0ZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdsaW50ZXJzJyBmcm9tICcuL2xpbnRlcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ29ic2lkaWFuLXBsdWdpbi1yZXBvLXBhdGhzJyBmcm9tICcuL29ic2lkaWFuLXBsdWdpbi1yZXBvLXBhdGhzLnRzJztcbmV4cG9ydCAqIGFzICd0ZW1wbGF0ZXMnIGZyb20gJy4vdGVtcGxhdGVzLnRzJztcbmV4cG9ydCAqIGFzICd0ZXN0LXJ1bm5lcnMnIGZyb20gJy4vdGVzdC1ydW5uZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICd2ZXJzaW9uJyBmcm9tICcuL3ZlcnNpb24udHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFFQSxZQUFZLGNBQWdCO0FBQzVCLFlBQVlBLHlCQUEyQjtBQUN2QyxZQUFZQyx3QkFBMEI7QUFDdEMsWUFBWUMsb0JBQXNCO0FBQ2xDLFlBQVlDLHlCQUEyQjtBQUN2QyxZQUFZQyxnQkFBa0I7QUFDOUIsWUFBWUMsZUFBaUI7QUFDN0IsWUFBWSxnQkFBa0I7QUFDOUIsWUFBWSxhQUFlO0FBQzNCLFlBQVlDLGdDQUFrQztBQUM5QyxZQUFZLGVBQWlCO0FBQzdCLFlBQVlDLGtCQUFvQjtBQUNoQyxZQUFZLGFBQWU7IiwKICAibmFtZXMiOiBbImRlbW8tdmF1bHQtYXBwLWpzb24iLCAiZGVtby12YXVsdC1idXR0b25zIiwgImRlbW8tdmF1bHQtY2xpIiwgImRlbW8tdmF1bHQtY292ZXJhZ2UiLCAiZGVtby12YXVsdCIsICJkb2NzLXNpdGUiLCAib2JzaWRpYW4tcGx1Z2luLXJlcG8tcGF0aHMiLCAidGVzdC1ydW5uZXJzIl0KfQo=

package/dist/lib/esm/test-runners/coverage-badge-cli.d.mts

@@ -0,0 +1,25 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * The `generate-coverage-badge` command: reads its arguments, runs {@link generateCoverageBadge} and turns the result
+ * into an exit code. The `obsidian-plugin-ci.yml` reusable workflow runs it after the gate.
+ */
+import type { GenerateCoverageBadgeOptions } from './coverage-badge.mjs';
+/**
+ * Parses the command line of `generate-coverage-badge`: `--lcov=<path>`, `--output=<path>`, `--metric=<metric>` and
+ * `--label=<text>`, each optional.
+ *
+ * @param $arguments - The arguments, without the node and script paths.
+ * @returns The {@link GenerateCoverageBadgeOptions}.
+ * @throws When an argument is unknown, or `--metric` is not a {@link CoverageBadgeMetric}.
+ */
+export declare function parseCoverageBadgeArguments($arguments: string[]): GenerateCoverageBadgeOptions;
+/**
+ * Runs `generate-coverage-badge`.
+ *
+ * @param $arguments - The arguments, without the node and script paths.
+ * @returns A {@link Promise} that resolves to the exit code: `0` once the badge is written, `1` on any failure, which
+ *   is printed to stderr.
+ */
+export declare function runCoverageBadgeCli($arguments: string[]): Promise<number>;

package/dist/lib/esm/test-runners/coverage-badge-cli.mjs

@@ -0,0 +1,51 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import process from "node:process";
+import { parseArgs } from "node:util";
+import { generateCoverageBadge } from "./coverage-badge.mjs";
+const METRICS = ["branches", "functions", "lines", "lowest"];
+function parseCoverageBadgeArguments($arguments) {
+  const { values } = parseArgs({
+    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.
+    args: $arguments,
+    options: {
+      label: { type: "string" },
+      lcov: { type: "string" },
+      metric: { type: "string" },
+      output: { type: "string" }
+    }
+  });
+  const { label, lcov, metric, output } = values;
+  if (metric !== void 0 && !isCoverageBadgeMetric(metric)) {
+    throw new Error(`Unknown --metric '${metric}'. Use one of: ${METRICS.join(", ")}.`);
+  }
+  return {
+    ...label !== void 0 && { label },
+    ...lcov !== void 0 && { lcovPath: lcov },
+    ...metric !== void 0 && { metric },
+    ...output !== void 0 && { outputPath: output }
+  };
+}
+async function runCoverageBadgeCli($arguments) {
+  try {
+    const { outputPath, percent } = await generateCoverageBadge(parseCoverageBadgeArguments($arguments));
+    process.stdout.write(`Wrote the coverage badge (${String(percent)}%) to ${outputPath}
+`);
+    return 0;
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+}
+function isCoverageBadgeMetric(value) {
+  return METRICS.includes(value);
+}
+export {
+  parseCoverageBadgeArguments,
+  runCoverageBadgeCli
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/test-runners/coverage-badge.d.mts

@@ -0,0 +1,143 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Renders a coverage badge from the `coverage/lcov.info` report `testCoverage` writes, as a self-contained SVG in
+ * the shields.io flat style, so a README can show the measured coverage with no external service. The
+ * `obsidian-plugin-ci.yml` reusable workflow publishes it to a `badges` branch; see the CI and release guide.
+ */
+/**
+ * Which coverage figure the badge shows.
+ *
+ * - `lines`: the share of lines covered, the figure most coverage services show.
+ * - `functions`: the share of functions covered.
+ * - `branches`: the share of branches covered.
+ * - `lowest`: the lowest of the three, so the badge never shows a figure one of the others falls below.
+ */
+export type CoverageBadgeMetric = 'branches' | 'functions' | 'lines' | 'lowest';
+/**
+ * A covered and a total count of one kind of coverage item.
+ */
+export interface CoverageCount {
+    /**
+     * How many items are covered.
+     */
+    readonly covered: number;
+    /**
+     * How many items there are.
+     */
+    readonly total: number;
+}
+/**
+ * The coverage totals of a whole lcov report.
+ */
+export interface CoverageTotals {
+    /**
+     * The branches (`BRF` / `BRH`).
+     */
+    readonly branches: CoverageCount;
+    /**
+     * The functions (`FNF` / `FNH`).
+     */
+    readonly functions: CoverageCount;
+    /**
+     * The lines (`LF` / `LH`).
+     */
+    readonly lines: CoverageCount;
+}
+/**
+ * Options for {@link generateCoverageBadge}.
+ */
+export interface GenerateCoverageBadgeOptions {
+    /**
+     * The text on the left half of the badge.
+     *
+     * @default `'coverage'`
+     */
+    readonly label?: string;
+    /**
+     * The lcov report to read, relative to the project root.
+     *
+     * @default `'coverage/lcov.info'`
+     */
+    readonly lcovPath?: string;
+    /**
+     * Which coverage figure the badge shows.
+     *
+     * @default `'lines'`
+     */
+    readonly metric?: CoverageBadgeMetric;
+    /**
+     * Where to write the SVG, relative to the project root. The default sits beside the report, in a folder a
+     * project ignores, so a local coverage run never leaves a changed file behind.
+     *
+     * @default `'coverage/coverage-badge.svg'`
+     */
+    readonly outputPath?: string;
+}
+/**
+ * The result of {@link generateCoverageBadge}.
+ */
+export interface GenerateCoverageBadgeResult {
+    /**
+     * The absolute path of the SVG written.
+     */
+    readonly outputPath: string;
+    /**
+     * The coverage figure the badge shows, in percents, rounded down to one decimal.
+     */
+    readonly percent: number;
+}
+/**
+ * Parameters for {@link renderCoverageBadgeSvg}.
+ */
+export interface RenderCoverageBadgeSvgParams {
+    /**
+     * The text on the left half of the badge.
+     */
+    readonly label: string;
+    /**
+     * The coverage figure, in percents.
+     */
+    readonly percent: number;
+}
+/**
+ * Reads the lcov report, renders the badge and writes it.
+ *
+ * @param options - The {@link GenerateCoverageBadgeOptions}.
+ * @returns A {@link Promise} that resolves to the {@link GenerateCoverageBadgeResult}.
+ * @throws When the lcov report cannot be read; run the tests with coverage first.
+ */
+export declare function generateCoverageBadge(options?: GenerateCoverageBadgeOptions): Promise<GenerateCoverageBadgeResult>;
+/**
+ * Picks the badge color of a coverage figure, on the shields.io scale.
+ *
+ * @param percent - The coverage figure, in percents.
+ * @returns The color, as a CSS hex color.
+ */
+export declare function getCoverageBadgeColor(percent: number): string;
+/**
+ * Computes the figure a badge shows.
+ *
+ * A kind with nothing to cover counts as fully covered, as vitest's own summary reports it. The figure is rounded
+ * DOWN to one decimal, so a project at 99.96% never shows 100%.
+ *
+ * @param totals - The {@link CoverageTotals}.
+ * @param metric - The {@link CoverageBadgeMetric}.
+ * @returns The coverage figure, in percents.
+ */
+export declare function getCoveragePercent(totals: CoverageTotals, metric: CoverageBadgeMetric): number;
+/**
+ * Sums the per-file counts of an lcov report.
+ *
+ * @param lcov - The text of the report.
+ * @returns The {@link CoverageTotals}.
+ */
+export declare function parseLcovTotals(lcov: string): CoverageTotals;
+/**
+ * Renders a coverage badge in the shields.io flat style.
+ *
+ * @param params - The {@link RenderCoverageBadgeSvgParams}.
+ * @returns The SVG text.
+ */
+export declare function renderCoverageBadgeSvg(params: RenderCoverageBadgeSvgParams): string;

package/dist/lib/esm/test-runners/coverage-badge.mjs

@@ -0,0 +1,181 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { resolvePathFromRootSafe } from "@mnaoumov/typescript-dev-toolkit/root";
+import {
+  mkdir,
+  readFile,
+  writeFile
+} from "node:fs/promises";
+import { dirname } from "node:path";
+const DEFAULT_LABEL = "coverage";
+const DEFAULT_LCOV_PATH = "coverage/lcov.info";
+const DEFAULT_OUTPUT_PATH = "coverage/coverage-badge.svg";
+const FULL_PERCENT = 100;
+const PERCENT_PRECISION = 10;
+const GREEN_MIN_PERCENT = 90;
+const YELLOW_GREEN_MIN_PERCENT = 80;
+const YELLOW_MIN_PERCENT = 70;
+const ORANGE_MIN_PERCENT = 60;
+const RED = "#e05d44";
+const BADGE_COLOR_THRESHOLDS = [
+  { color: "#4c1", minPercent: FULL_PERCENT },
+  { color: "#97ca00", minPercent: GREEN_MIN_PERCENT },
+  { color: "#a4a61d", minPercent: YELLOW_GREEN_MIN_PERCENT },
+  { color: "#dfb317", minPercent: YELLOW_MIN_PERCENT },
+  { color: "#fe7d37", minPercent: ORANGE_MIN_PERCENT },
+  { color: RED, minPercent: 0 }
+];
+const BADGE_HEIGHT = 20;
+const TEXT_PADDING = 12;
+const HALF = 0.5;
+const TEXT_BASELINE = 14;
+const TEXT_SHADOW_BASELINE = 15;
+const NARROW_CHARACTER_WIDTH = 3.9;
+const DEFAULT_CHARACTER_WIDTH = 7;
+const WIDE_CHARACTER_WIDTH = 9.5;
+const PERCENT_SIGN_WIDTH = 11.9;
+const NARROW_CHARACTERS = /* @__PURE__ */ new Set([" ", "-", ",", ";", ":", "!", ".", "'", "(", ")", "/", "f", "I", "i", "j", "l", "r", "t"]);
+const WIDE_CHARACTERS = /* @__PURE__ */ new Set(["M", "m", "W", "w"]);
+async function generateCoverageBadge(options = {}) {
+  const {
+    label = DEFAULT_LABEL,
+    lcovPath = DEFAULT_LCOV_PATH,
+    metric = "lines",
+    outputPath = DEFAULT_OUTPUT_PATH
+  } = options;
+  const resolvedLcovPath = resolvePathFromRootSafe({ path: lcovPath });
+  let lcov;
+  try {
+    lcov = await readFile(resolvedLcovPath, "utf-8");
+  } catch (error) {
+    throw new Error(`Could not read the lcov report '${resolvedLcovPath}'. Run the tests with coverage first.`, { cause: error });
+  }
+  const percent = getCoveragePercent(parseLcovTotals(lcov), metric);
+  const resolvedOutputPath = resolvePathFromRootSafe({ path: outputPath });
+  await mkdir(dirname(resolvedOutputPath), { recursive: true });
+  await writeFile(resolvedOutputPath, renderCoverageBadgeSvg({ label, percent }));
+  return { outputPath: resolvedOutputPath, percent };
+}
+function getCoverageBadgeColor(percent) {
+  const threshold = BADGE_COLOR_THRESHOLDS.find((candidate) => percent >= candidate.minPercent);
+  return threshold?.color ?? RED;
+}
+function getCoveragePercent(totals, metric) {
+  const percents = {
+    branches: toPercent(totals.branches),
+    functions: toPercent(totals.functions),
+    lines: toPercent(totals.lines)
+  };
+  const percent = metric === "lowest" ? Math.min(percents.branches, percents.functions, percents.lines) : percents[metric];
+  return Math.floor(percent * PERCENT_PRECISION) / PERCENT_PRECISION;
+}
+function parseLcovTotals(lcov) {
+  const sums = /* @__PURE__ */ new Map();
+  for (const line of lcov.split(/\r?\n/u)) {
+    const match = /^(?<key>BRF|BRH|FNF|FNH|LF|LH):(?<value>\d+)$/u.exec(line.trim());
+    if (!match?.groups) {
+      continue;
+    }
+    const { key = "", value = "" } = match.groups;
+    sums.set(key, (sums.get(key) ?? 0) + Number(value));
+  }
+  function count(coveredKey, totalKey) {
+    return { covered: sums.get(coveredKey) ?? 0, total: sums.get(totalKey) ?? 0 };
+  }
+  return {
+    branches: count("BRH", "BRF"),
+    functions: count("FNH", "FNF"),
+    lines: count("LH", "LF")
+  };
+}
+function renderCoverageBadgeSvg(params) {
+  const { label, percent } = params;
+  const value = `${String(percent)}%`;
+  const labelTextWidth = measureText(label);
+  const valueTextWidth = measureText(value);
+  const labelWidth = labelTextWidth + TEXT_PADDING;
+  const valueWidth = valueTextWidth + TEXT_PADDING;
+  const width = labelWidth + valueWidth;
+  const labelCenter = labelWidth * HALF;
+  const valueCenter = labelWidth + valueWidth * HALF;
+  const color = getCoverageBadgeColor(percent);
+  const title = escapeXml(`${label}: ${value}`);
+  const escapedLabel = escapeXml(label);
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${String(width)}" height="${String(BADGE_HEIGHT)}" role="img" aria-label="${title}">
+  <title>${title}</title>
+  <linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient>
+  <clipPath id="r"><rect width="${String(width)}" height="${String(BADGE_HEIGHT)}" rx="3" fill="#fff"/></clipPath>
+  <g clip-path="url(#r)">
+    <rect width="${String(labelWidth)}" height="${String(BADGE_HEIGHT)}" fill="#555"/>
+    <rect x="${String(labelWidth)}" width="${String(valueWidth)}" height="${String(BADGE_HEIGHT)}" fill="${color}"/>
+    <rect width="${String(width)}" height="${String(BADGE_HEIGHT)}" fill="url(#s)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11" text-rendering="geometricPrecision">
+    <text x="${String(labelCenter)}" y="${String(TEXT_SHADOW_BASELINE)}" fill="#010101" fill-opacity=".3" textLength="${String(labelTextWidth)}">${escapedLabel}</text>
+    <text x="${String(labelCenter)}" y="${String(TEXT_BASELINE)}" textLength="${String(labelTextWidth)}">${escapedLabel}</text>
+    <text x="${String(valueCenter)}" y="${String(TEXT_SHADOW_BASELINE)}" fill="#010101" fill-opacity=".3" textLength="${String(valueTextWidth)}">${value}</text>
+    <text x="${String(valueCenter)}" y="${String(TEXT_BASELINE)}" textLength="${String(valueTextWidth)}">${value}</text>
+  </g>
+</svg>
+`;
+}
+function escapeXml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function measureCharacter(character) {
+  if (character === "%") {
+    return PERCENT_SIGN_WIDTH;
+  }
+  if (NARROW_CHARACTERS.has(character)) {
+    return NARROW_CHARACTER_WIDTH;
+  }
+  return WIDE_CHARACTERS.has(character) ? WIDE_CHARACTER_WIDTH : DEFAULT_CHARACTER_WIDTH;
+}
+function measureText(text) {
+  let width = 0;
+  for (const character of text) {
+    width += measureCharacter(character);
+  }
+  return Math.round(width);
+}
+function toPercent(count) {
+  return count.total === 0 ? FULL_PERCENT : count.covered / count.total * FULL_PERCENT;
+}
+export {
+  generateCoverageBadge,
+  getCoverageBadgeColor,
+  getCoveragePercent,
+  parseLcovTotals,
+  renderCoverageBadgeSvg
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/test-runners/coverage-badge.ts"],"sourcesContent":["/**\n * @file\n *\n * Renders a coverage badge from the `coverage/lcov.info` report `testCoverage` writes, as a self-contained SVG in\n * the shields.io flat style, so a README can show the measured coverage with no external service. The\n * `obsidian-plugin-ci.yml` reusable workflow publishes it to a `badges` branch; see the CI and release guide.\n */\n\nimport { resolvePathFromRootSafe } from '@mnaoumov/typescript-dev-toolkit/root';\nimport {\n  mkdir,\n  readFile,\n  writeFile\n} from 'node:fs/promises';\nimport { dirname } from 'node:path';\n\n/**\n * Which coverage figure the badge shows.\n *\n * - `lines`: the share of lines covered, the figure most coverage services show.\n * - `functions`: the share of functions covered.\n * - `branches`: the share of branches covered.\n * - `lowest`: the lowest of the three, so the badge never shows a figure one of the others falls below.\n */\nexport type CoverageBadgeMetric = 'branches' | 'functions' | 'lines' | 'lowest';\n\n/**\n * A covered and a total count of one kind of coverage item.\n */\nexport interface CoverageCount {\n  /**\n   * How many items are covered.\n   */\n  readonly covered: number;\n\n  /**\n   * How many items there are.\n   */\n  readonly total: number;\n}\n\n/**\n * The coverage totals of a whole lcov report.\n */\nexport interface CoverageTotals {\n  /**\n   * The branches (`BRF` / `BRH`).\n   */\n  readonly branches: CoverageCount;\n\n  /**\n   * The functions (`FNF` / `FNH`).\n   */\n  readonly functions: CoverageCount;\n\n  /**\n   * The lines (`LF` / `LH`).\n   */\n  readonly lines: CoverageCount;\n}\n\n/**\n * Options for {@link generateCoverageBadge}.\n */\nexport interface GenerateCoverageBadgeOptions {\n  /**\n   * The text on the left half of the badge.\n   *\n   * @default `'coverage'`\n   */\n  readonly label?: string;\n\n  /**\n   * The lcov report to read, relative to the project root.\n   *\n   * @default `'coverage/lcov.info'`\n   */\n  readonly lcovPath?: string;\n\n  /**\n   * Which coverage figure the badge shows.\n   *\n   * @default `'lines'`\n   */\n  readonly metric?: CoverageBadgeMetric;\n\n  /**\n   * Where to write the SVG, relative to the project root. The default sits beside the report, in a folder a\n   * project ignores, so a local coverage run never leaves a changed file behind.\n   *\n   * @default `'coverage/coverage-badge.svg'`\n   */\n  readonly outputPath?: string;\n}\n\n/**\n * The result of {@link generateCoverageBadge}.\n */\nexport interface GenerateCoverageBadgeResult {\n  /**\n   * The absolute path of the SVG written.\n   */\n  readonly outputPath: string;\n\n  /**\n   * The coverage figure the badge shows, in percents, rounded down to one decimal.\n   */\n  readonly percent: number;\n}\n\n/**\n * Parameters for {@link renderCoverageBadgeSvg}.\n */\nexport interface RenderCoverageBadgeSvgParams {\n  /**\n   * The text on the left half of the badge.\n   */\n  readonly label: string;\n\n  /**\n   * The coverage figure, in percents.\n   */\n  readonly percent: number;\n}\n\ninterface BadgeColorThreshold {\n  readonly color: string;\n  readonly minPercent: number;\n}\n\nconst DEFAULT_LABEL = 'coverage';\nconst DEFAULT_LCOV_PATH = 'coverage/lcov.info';\nconst DEFAULT_OUTPUT_PATH = 'coverage/coverage-badge.svg';\nconst FULL_PERCENT = 100;\nconst PERCENT_PRECISION = 10;\n\nconst GREEN_MIN_PERCENT = 90;\nconst YELLOW_GREEN_MIN_PERCENT = 80;\nconst YELLOW_MIN_PERCENT = 70;\nconst ORANGE_MIN_PERCENT = 60;\nconst RED = '#e05d44';\n\n// The shields.io color scale, from the top down; the last entry catches everything below it.\nconst BADGE_COLOR_THRESHOLDS: readonly BadgeColorThreshold[] = [\n  { color: '#4c1', minPercent: FULL_PERCENT },\n  { color: '#97ca00', minPercent: GREEN_MIN_PERCENT },\n  { color: '#a4a61d', minPercent: YELLOW_GREEN_MIN_PERCENT },\n  { color: '#dfb317', minPercent: YELLOW_MIN_PERCENT },\n  { color: '#fe7d37', minPercent: ORANGE_MIN_PERCENT },\n  { color: RED, minPercent: 0 }\n];\n\nconst BADGE_HEIGHT = 20;\n// The padding on both sides of a text together.\nconst TEXT_PADDING = 12;\nconst HALF = 0.5;\nconst TEXT_BASELINE = 14;\nconst TEXT_SHADOW_BASELINE = 15;\n\n// Approximate advance widths of 11px Verdana, the face shields.io measures with. The rendered text is stretched to\n// the computed width through `textLength`, so an estimate a pixel off moves the padding, never clips the text.\nconst NARROW_CHARACTER_WIDTH = 3.9;\nconst DEFAULT_CHARACTER_WIDTH = 7;\nconst WIDE_CHARACTER_WIDTH = 9.5;\nconst PERCENT_SIGN_WIDTH = 11.9;\nconst NARROW_CHARACTERS = new Set([' ', '-', ',', ';', ':', '!', '.', '\\'', '(', ')', '/', 'f', 'I', 'i', 'j', 'l', 'r', 't']);\nconst WIDE_CHARACTERS = new Set(['M', 'm', 'W', 'w']);\n\n/**\n * Reads the lcov report, renders the badge and writes it.\n *\n * @param options - The {@link GenerateCoverageBadgeOptions}.\n * @returns A {@link Promise} that resolves to the {@link GenerateCoverageBadgeResult}.\n * @throws When the lcov report cannot be read; run the tests with coverage first.\n */\nexport async function generateCoverageBadge(options: GenerateCoverageBadgeOptions = {}): Promise<GenerateCoverageBadgeResult> {\n  const {\n    label = DEFAULT_LABEL,\n    lcovPath = DEFAULT_LCOV_PATH,\n    metric = 'lines',\n    outputPath = DEFAULT_OUTPUT_PATH\n  } = options;\n\n  const resolvedLcovPath = resolvePathFromRootSafe({ path: lcovPath });\n  let lcov: string;\n  try {\n    lcov = await readFile(resolvedLcovPath, 'utf-8');\n  } catch (error) {\n    throw new Error(`Could not read the lcov report '${resolvedLcovPath}'. Run the tests with coverage first.`, { cause: error });\n  }\n\n  const percent = getCoveragePercent(parseLcovTotals(lcov), metric);\n  const resolvedOutputPath = resolvePathFromRootSafe({ path: outputPath });\n  await mkdir(dirname(resolvedOutputPath), { recursive: true });\n  await writeFile(resolvedOutputPath, renderCoverageBadgeSvg({ label, percent }));\n  return { outputPath: resolvedOutputPath, percent };\n}\n\n/**\n * Picks the badge color of a coverage figure, on the shields.io scale.\n *\n * @param percent - The coverage figure, in percents.\n * @returns The color, as a CSS hex color.\n */\nexport function getCoverageBadgeColor(percent: number): string {\n  const threshold = BADGE_COLOR_THRESHOLDS.find((candidate) => percent >= candidate.minPercent);\n  return threshold?.color ?? RED;\n}\n\n/**\n * Computes the figure a badge shows.\n *\n * A kind with nothing to cover counts as fully covered, as vitest's own summary reports it. The figure is rounded\n * DOWN to one decimal, so a project at 99.96% never shows 100%.\n *\n * @param totals - The {@link CoverageTotals}.\n * @param metric - The {@link CoverageBadgeMetric}.\n * @returns The coverage figure, in percents.\n */\nexport function getCoveragePercent(totals: CoverageTotals, metric: CoverageBadgeMetric): number {\n  const percents = {\n    branches: toPercent(totals.branches),\n    functions: toPercent(totals.functions),\n    lines: toPercent(totals.lines)\n  };\n  const percent = metric === 'lowest' ? Math.min(percents.branches, percents.functions, percents.lines) : percents[metric];\n  return Math.floor(percent * PERCENT_PRECISION) / PERCENT_PRECISION;\n}\n\n/**\n * Sums the per-file counts of an lcov report.\n *\n * @param lcov - The text of the report.\n * @returns The {@link CoverageTotals}.\n */\nexport function parseLcovTotals(lcov: string): CoverageTotals {\n  const sums = new Map<string, number>();\n  for (const line of lcov.split(/\\r?\\n/u)) {\n    const match = /^(?<key>BRF|BRH|FNF|FNH|LF|LH):(?<value>\\d+)$/u.exec(line.trim());\n    if (!match?.groups) {\n      continue;\n    }\n    const { key = '', value = '' } = match.groups;\n    sums.set(key, (sums.get(key) ?? 0) + Number(value));\n  }\n\n  function count(coveredKey: string, totalKey: string): CoverageCount {\n    return { covered: sums.get(coveredKey) ?? 0, total: sums.get(totalKey) ?? 0 };\n  }\n\n  return {\n    branches: count('BRH', 'BRF'),\n    functions: count('FNH', 'FNF'),\n    lines: count('LH', 'LF')\n  };\n}\n\n/**\n * Renders a coverage badge in the shields.io flat style.\n *\n * @param params - The {@link RenderCoverageBadgeSvgParams}.\n * @returns The SVG text.\n */\nexport function renderCoverageBadgeSvg(params: RenderCoverageBadgeSvgParams): string {\n  const { label, percent } = params;\n  const value = `${String(percent)}%`;\n  const labelTextWidth = measureText(label);\n  const valueTextWidth = measureText(value);\n  const labelWidth = labelTextWidth + TEXT_PADDING;\n  const valueWidth = valueTextWidth + TEXT_PADDING;\n  const width = labelWidth + valueWidth;\n  const labelCenter = labelWidth * HALF;\n  const valueCenter = labelWidth + valueWidth * HALF;\n  const color = getCoverageBadgeColor(percent);\n  const title = escapeXml(`${label}: ${value}`);\n  const escapedLabel = escapeXml(label);\n\n  return `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"${String(width)}\" height=\"${String(BADGE_HEIGHT)}\" role=\"img\" aria-label=\"${title}\">\n  <title>${title}</title>\n  <linearGradient id=\"s\" x2=\"0\" y2=\"100%\"><stop offset=\"0\" stop-color=\"#bbb\" stop-opacity=\".1\"/><stop offset=\"1\" stop-opacity=\".1\"/></linearGradient>\n  <clipPath id=\"r\"><rect width=\"${String(width)}\" height=\"${String(BADGE_HEIGHT)}\" rx=\"3\" fill=\"#fff\"/></clipPath>\n  <g clip-path=\"url(#r)\">\n    <rect width=\"${String(labelWidth)}\" height=\"${String(BADGE_HEIGHT)}\" fill=\"#555\"/>\n    <rect x=\"${String(labelWidth)}\" width=\"${String(valueWidth)}\" height=\"${String(BADGE_HEIGHT)}\" fill=\"${color}\"/>\n    <rect width=\"${String(width)}\" height=\"${String(BADGE_HEIGHT)}\" fill=\"url(#s)\"/>\n  </g>\n  <g fill=\"#fff\" text-anchor=\"middle\" font-family=\"Verdana,Geneva,DejaVu Sans,sans-serif\" font-size=\"11\" text-rendering=\"geometricPrecision\">\n    <text x=\"${String(labelCenter)}\" y=\"${String(TEXT_SHADOW_BASELINE)}\" fill=\"#010101\" fill-opacity=\".3\" textLength=\"${String(labelTextWidth)}\">${escapedLabel}</text>\n    <text x=\"${String(labelCenter)}\" y=\"${String(TEXT_BASELINE)}\" textLength=\"${String(labelTextWidth)}\">${escapedLabel}</text>\n    <text x=\"${String(valueCenter)}\" y=\"${String(TEXT_SHADOW_BASELINE)}\" fill=\"#010101\" fill-opacity=\".3\" textLength=\"${String(valueTextWidth)}\">${value}</text>\n    <text x=\"${String(valueCenter)}\" y=\"${String(TEXT_BASELINE)}\" textLength=\"${String(valueTextWidth)}\">${value}</text>\n  </g>\n</svg>\n`;\n}\n\nfunction escapeXml(text: string): string {\n  return text.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('\"', '&quot;');\n}\n\nfunction measureCharacter(character: string): number {\n  if (character === '%') {\n    return PERCENT_SIGN_WIDTH;\n  }\n  if (NARROW_CHARACTERS.has(character)) {\n    return NARROW_CHARACTER_WIDTH;\n  }\n  return WIDE_CHARACTERS.has(character) ? WIDE_CHARACTER_WIDTH : DEFAULT_CHARACTER_WIDTH;\n}\n\nfunction measureText(text: string): number {\n  let width = 0;\n  for (const character of text) {\n    width += measureCharacter(character);\n  }\n  return Math.round(width);\n}\n\nfunction toPercent(count: CoverageCount): number {\n  return count.total === 0 ? FULL_PERCENT : count.covered / count.total * FULL_PERCENT;\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/test-runners/e2e-runner-support.d.mts

@@ -0,0 +1,36 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * What the end-to-end runners share: where the specs live, and the check that the packages a runner drives are
+ * installed in the project, so a missing one is reported with the `npm install` line that fixes it instead of as a
+ * shell's `command not found`.
+ */
+/**
+ * The spec files the end-to-end runners run by default.
+ */
+export declare const DEFAULT_END_TO_END_SPECS = "./e2e/**/*.spec.ts";
+/**
+ * Parameters for {@link assertProjectPackagesInstalled}.
+ */
+export interface AssertProjectPackagesInstalledParams {
+    /**
+     * The packages the runner needs.
+     */
+    readonly packageNames: readonly string[];
+    /**
+     * The folder whose `node_modules` the packages are resolved from. Defaults to the project root.
+     */
+    readonly projectFolder?: string;
+    /**
+     * What needs the packages, as the error message names it, e.g. `testEndToEndWithWdioObsidian()`.
+     */
+    readonly requester: string;
+}
+/**
+ * Throws when any of the packages is not installed in the project, naming the `npm install` line.
+ *
+ * @param params - The {@link AssertProjectPackagesInstalledParams}.
+ * @throws When a package is missing.
+ */
+export declare function assertProjectPackagesInstalled(params: AssertProjectPackagesInstalledParams): void;

package/dist/lib/esm/test-runners/e2e-runner-support.mjs

@@ -0,0 +1,61 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { getRootFolder } from "@mnaoumov/typescript-dev-toolkit/root";
+import { join } from "@mnaoumov/typescript-lib/path";
+import { createRequire } from "node:module";
+import process from "node:process";
+const DEFAULT_END_TO_END_SPECS = "./e2e/**/*.spec.ts";
+function assertProjectPackagesInstalled(params) {
+  const projectFolder = params.projectFolder ?? getRootFolder() ?? process.cwd();
+  const require2 = createRequire(join(projectFolder, "package.json"));
+  const missingPackageNames = params.packageNames.filter((packageName) => !isPackageInstalled(require2, packageName));
+  if (missingPackageNames.length === 0) {
+    return;
+  }
+  throw new Error(
+    `${params.requester} needs ${missingPackageNames.map((packageName) => `\`${packageName}\``).join(", ")}, which the project does not have. Install with: npm install --save-dev ${missingPackageNames.join(" ")}`
+  );
+}
+function isPackageInstalled(require2, packageName) {
+  try {
+    require2.resolve(`${packageName}/package.json`);
+    return true;
+  } catch (error) {
+    return error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
+  }
+}
+export {
+  DEFAULT_END_TO_END_SPECS,
+  assertProjectPackagesInstalled
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/test-runners/index.d.mts

@@ -1,4 +1,9 @@
 /// <reference path="../library-references.d.mts" />
+export * as 'coverage-badge-cli' from './coverage-badge-cli.mjs';
+export * as 'coverage-badge' from './coverage-badge.mjs';
+export * as 'e2e-runner-support' from './e2e-runner-support.mjs';
 export * as 'integration-test-plugin' from './integration-test-plugin.mjs';
+export * as 'obsidian-test-runner' from './obsidian-test-runner.mjs';
 export * as 'performance-eval-cap' from './performance-eval-cap.mjs';
 export * as 'vitest-config' from './vitest-config.mjs';
+export * as 'wdio-obsidian' from './wdio-obsidian.mjs';