@ksp-gonogo/ui-kit 0.1.0 → 0.2.0-rc.10

package/dist/guards.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Build-time guards an Uplink can run against its own source.
+ *
+ * Published as `@ksp-gonogo/ui-kit/guards`, separate from `./testing` because
+ * it reads the filesystem (`node:fs`), which would break a browser test runner.
+ *
+ * ## Why
+ *
+ * A widget that writes
+ *
+ *     `${closingSpeed.toFixed(1)} m/s`
+ *
+ * type-checks and renders, but the symbol cannot be dimmed, cannot be kept off
+ * a line break, is announced as the letters "m", "slash", "s", and does not
+ * follow when the value's ladder changes rung. `<Unit>` solves all four.
+ *
+ * ## Using it
+ *
+ * One test file, anywhere your test runner will find it:
+ *
+ * ```ts
+ * import { expectNoHandTypedUnits } from "@ksp-gonogo/ui-kit/guards";
+ * import { it } from "vitest";
+ *
+ * it("renders units through <Unit>, not by typing the symbol", () => {
+ *   expectNoHandTypedUnits({ dir: "src" });
+ * });
+ * ```
+ *
+ * On an existing codebase with offenders already in it, seed a `baseline` and
+ * lower it as you convert: a guessed conversion is worse than a hand-typed
+ * symbol, because it renders a confident wrong label.
+ */
+/**
+ * The unit symbols the check looks for by default. It is a chosen list and
+ * not every unit: a symbol nobody types beside a number, or one short enough
+ * to turn up in ordinary prose, is left out.
+ *
+ * Pass your own through `symbols` when your Uplink registers a unit of its own.
+ *
+ * @category Testing
+ */
+declare const HAND_TYPED_SYMBOLS: readonly string[];
+/**
+ * Somewhere a unit symbol was typed next to a number.
+ *
+ * @category Testing
+ */
+interface HandTypedUnit {
+    /** Path relative to the scanned directory, with `/` separators. */
+    file: string;
+    /** 1-based, so it is clickable in a terminal. */
+    line: number;
+    /** The offending source line, trimmed. */
+    source: string;
+    /** The symbol that matched. */
+    symbol: string;
+}
+/**
+ * Options for {@link findHandTypedUnits} and {@link expectNoHandTypedUnits}.
+ *
+ * @category Testing
+ */
+interface HandTypedUnitOptions {
+    /** Directory to scan. Defaults to `src` under the current directory. */
+    dir?: string;
+    /** Override the symbols looked for. See {@link HAND_TYPED_SYMBOLS}. */
+    symbols?: readonly string[];
+    /**
+     * Per-file allowance, keyed by the path as it appears in a finding. A file
+     * at its entry passes, and a file below it throws, so an allowance left
+     * higher than needed is reported rather than left open.
+     */
+    baseline?: Readonly<Record<string, number>>;
+    /**
+     * Extra paths to skip, matched against the relative path. Tests, snapshots,
+     * `node_modules` and build output are already skipped.
+     */
+    ignore?: (file: string) => boolean;
+}
+/**
+ * Every place a unit symbol is typed next to a number, under `dir`.
+ *
+ * Returns findings rather than throwing, so a caller can report them their own
+ * way. {@link expectNoHandTypedUnits} is the assertion built on top.
+ *
+ * @category Testing
+ */
+declare function findHandTypedUnits(options?: HandTypedUnitOptions): HandTypedUnit[];
+/**
+ * Throws when a unit symbol is typed next to a number, with the fix in the
+ * message. Silent for a file at its `baseline` entry; a file below its entry
+ * throws, so an allowance left higher than needed cannot let the symbol come
+ * back unnoticed.
+ *
+ * @example
+ * ```ts
+ * import { expectNoHandTypedUnits } from "@ksp-gonogo/ui-kit/guards";
+ * import { it } from "vitest";
+ *
+ * it("renders units through <Unit>, not by typing the symbol", () => {
+ *   expectNoHandTypedUnits({ dir: "src" });
+ * });
+ * ```
+ *
+ * @category Testing
+ */
+declare function expectNoHandTypedUnits(options?: HandTypedUnitOptions): void;
+
+export { HAND_TYPED_SYMBOLS, type HandTypedUnit, type HandTypedUnitOptions, expectNoHandTypedUnits, findHandTypedUnits };

package/dist/guards.js

@@ -0,0 +1,171 @@
+import "./chunk-G3PMV62Z.js";
+
+// src/guards.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join, relative, sep } from "path";
+var HAND_TYPED_SYMBOLS = [
+  "m/s\xB2",
+  "m/s",
+  "km/h",
+  "km",
+  "Mm",
+  "Gm",
+  "mm",
+  "cm",
+  "kPa",
+  "MPa",
+  "kN",
+  "MN",
+  "kW",
+  "MW",
+  "GW",
+  "kg",
+  "\xB0C",
+  "\xB0",
+  "%",
+  "m",
+  "s",
+  "t",
+  "N",
+  "W",
+  "f",
+  "sci",
+  "rep",
+  "Mit",
+  "deg",
+  "rad",
+  /*
+   * Matching is case-sensitive, since single letters like `m` and `W` would
+   * otherwise match prose and CSS, so a unit conventionally written both ways
+   * (`rpm`, `RPM`) is listed in both spellings.
+   */
+  "rpm",
+  "RPM",
+  "dB",
+  "rad/s",
+  "bit/s",
+  "J/s",
+  "N\xB7m",
+  "m\xB2",
+  "Pa",
+  "kg/m\xB3",
+  "g/m\xB3"
+];
+var CSS_PROPERTY = /(width|height|left|top|right|bottom|transform|translate|inset|margin|padding|gap|flex|stroke|offset|dasharray|dashoffset|hsl|hsla|rgb|rgba)\s*[:(={]/i;
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".git",
+  ".turbo",
+  "__snapshots__"
+]);
+var SOURCE = /\.(ts|tsx|js|jsx)$/;
+function stripComments(source) {
+  const out = [];
+  let inBlock = false;
+  for (const line of source.split("\n")) {
+    let kept = "";
+    let i = 0;
+    while (i < line.length) {
+      if (inBlock) {
+        if (line.startsWith("*/", i)) {
+          inBlock = false;
+          i += 2;
+        } else {
+          i += 1;
+        }
+        continue;
+      }
+      if (line.startsWith("/*", i)) {
+        inBlock = true;
+        i += 2;
+        continue;
+      }
+      if (line.startsWith("//", i)) break;
+      kept += line[i];
+      i += 1;
+    }
+    out.push(kept);
+  }
+  return out;
+}
+function isTest(file) {
+  return file.includes(".test.") || file.includes(".spec.");
+}
+function walk(root, dir, out) {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      if (!SKIP_DIRS.has(entry)) walk(root, full, out);
+      continue;
+    }
+    if (SOURCE.test(entry)) out.push(relative(root, full).split(sep).join("/"));
+  }
+}
+function patternFor(symbols) {
+  const alternatives = [...symbols].sort((a, b) => b.length - a.length);
+  const escaped = alternatives.map(
+    (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  );
+  return new RegExp(`\\}\\s?(${escaped.join("|")})([^A-Za-z0-9_/]|\`|$)`);
+}
+function findHandTypedUnits(options = {}) {
+  const dir = options.dir ?? "src";
+  const pattern = patternFor(options.symbols ?? HAND_TYPED_SYMBOLS);
+  const files = [];
+  walk(dir, dir, files);
+  const found = [];
+  for (const file of files) {
+    if (isTest(file)) continue;
+    if (options.ignore?.(file)) continue;
+    const raw = readFileSync(join(dir, file), "utf8").split("\n");
+    stripComments(raw.join("\n")).forEach((code, index) => {
+      const match = pattern.exec(code);
+      if (match === null) return;
+      if (CSS_PROPERTY.test(code)) return;
+      found.push({
+        file,
+        line: index + 1,
+        // The raw line, not the blanked form the scan matched against.
+        source: raw[index].trim(),
+        symbol: match[1]
+      });
+    });
+  }
+  return found;
+}
+function expectNoHandTypedUnits(options = {}) {
+  const baseline = options.baseline ?? {};
+  const found = findHandTypedUnits(options);
+  const counts = {};
+  for (const one of found) counts[one.file] = (counts[one.file] ?? 0) + 1;
+  const over = found.filter(
+    (one) => (counts[one.file] ?? 0) > (baseline[one.file] ?? 0)
+  );
+  if (over.length > 0) {
+    throw new Error(
+      `A unit symbol was typed next to a number in ${over.length} place(s). Render <Unit value={x} /> instead, so the symbol keeps its styling, follows the value's ladder, and is announced as a word rather than as letters.
+
+Where a string is genuinely required: speakQuantity for an accessible name, writeQuantity for visible text that is MEASURED (an SVG <text>, a canvas label), and nothing else.
+
+` + over.map((one) => `  ${one.file}:${one.line}  ${one.source}`).join("\n")
+    );
+  }
+  const stale = Object.keys(baseline).filter(
+    (file) => (counts[file] ?? 0) < baseline[file]
+  );
+  if (stale.length > 0) {
+    throw new Error(
+      `These are below their baseline, which is good news. Lower or remove the entry so the gain is locked in, otherwise the symbol is free to come back:
+${stale.map((f) => `  ${f}: now ${counts[f] ?? 0}, baseline ${baseline[f]}`).join("\n")}`
+    );
+  }
+}
+export {
+  HAND_TYPED_SYMBOLS,
+  expectNoHandTypedUnits,
+  findHandTypedUnits
+};
+//# sourceMappingURL=guards.js.map

package/dist/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/guards.ts"],"sourcesContent":["import { readdirSync, readFileSync, statSync } from \"node:fs\";\nimport { join, relative, sep } from \"node:path\";\n\n/**\n * Build-time guards an Uplink can run against its own source.\n *\n * Published as `@ksp-gonogo/ui-kit/guards`, separate from `./testing` because\n * it reads the filesystem (`node:fs`), which would break a browser test runner.\n *\n * ## Why\n *\n * A widget that writes\n *\n *     `${closingSpeed.toFixed(1)} m/s`\n *\n * type-checks and renders, but the symbol cannot be dimmed, cannot be kept off\n * a line break, is announced as the letters \"m\", \"slash\", \"s\", and does not\n * follow when the value's ladder changes rung. `<Unit>` solves all four.\n *\n * ## Using it\n *\n * One test file, anywhere your test runner will find it:\n *\n * ```ts\n * import { expectNoHandTypedUnits } from \"@ksp-gonogo/ui-kit/guards\";\n * import { it } from \"vitest\";\n *\n * it(\"renders units through <Unit>, not by typing the symbol\", () => {\n *   expectNoHandTypedUnits({ dir: \"src\" });\n * });\n * ```\n *\n * On an existing codebase with offenders already in it, seed a `baseline` and\n * lower it as you convert: a guessed conversion is worse than a hand-typed\n * symbol, because it renders a confident wrong label.\n */\n\n/**\n * The unit symbols the check looks for by default. It is a chosen list and\n * not every unit: a symbol nobody types beside a number, or one short enough\n * to turn up in ordinary prose, is left out.\n *\n * Pass your own through `symbols` when your Uplink registers a unit of its own.\n *\n * @category Testing\n */\nexport const HAND_TYPED_SYMBOLS: readonly string[] = [\n  \"m/s²\",\n  \"m/s\",\n  \"km/h\",\n  \"km\",\n  \"Mm\",\n  \"Gm\",\n  \"mm\",\n  \"cm\",\n  \"kPa\",\n  \"MPa\",\n  \"kN\",\n  \"MN\",\n  \"kW\",\n  \"MW\",\n  \"GW\",\n  \"kg\",\n  \"°C\",\n  \"°\",\n  \"%\",\n  \"m\",\n  \"s\",\n  \"t\",\n  \"N\",\n  \"W\",\n  \"f\",\n  \"sci\",\n  \"rep\",\n  \"Mit\",\n  \"deg\",\n  \"rad\",\n  /*\n   * Matching is case-sensitive, since single letters like `m` and `W` would\n   * otherwise match prose and CSS, so a unit conventionally written both ways\n   * (`rpm`, `RPM`) is listed in both spellings.\n   */\n  \"rpm\",\n  \"RPM\",\n  \"dB\",\n  \"rad/s\",\n  \"bit/s\",\n  \"J/s\",\n  \"N·m\",\n  \"m²\",\n  \"Pa\",\n  \"kg/m³\",\n  \"g/m³\",\n];\n\n/**\n * A CSS length or colour is not a readout. `[:(={]` covers a declaration\n * (`width: ...`), a call (`translate(...)`) and an attribute (`offset={...}`);\n * the colour functions cover `hsl(${h}deg ${s}% ${l}%)`.\n */\nconst CSS_PROPERTY =\n  /(width|height|left|top|right|bottom|transform|translate|inset|margin|padding|gap|flex|stroke|offset|dasharray|dashoffset|hsl|hsla|rgb|rgba)\\s*[:(={]/i;\n\n/**\n * Somewhere a unit symbol was typed next to a number.\n *\n * @category Testing\n */\nexport interface HandTypedUnit {\n  /** Path relative to the scanned directory, with `/` separators. */\n  file: string;\n  /** 1-based, so it is clickable in a terminal. */\n  line: number;\n  /** The offending source line, trimmed. */\n  source: string;\n  /** The symbol that matched. */\n  symbol: string;\n}\n\n/**\n * Options for {@link findHandTypedUnits} and {@link expectNoHandTypedUnits}.\n *\n * @category Testing\n */\nexport interface HandTypedUnitOptions {\n  /** Directory to scan. Defaults to `src` under the current directory. */\n  dir?: string;\n  /** Override the symbols looked for. See {@link HAND_TYPED_SYMBOLS}. */\n  symbols?: readonly string[];\n  /**\n   * Per-file allowance, keyed by the path as it appears in a finding. A file\n   * at its entry passes, and a file below it throws, so an allowance left\n   * higher than needed is reported rather than left open.\n   */\n  baseline?: Readonly<Record<string, number>>;\n  /**\n   * Extra paths to skip, matched against the relative path. Tests, snapshots,\n   * `node_modules` and build output are already skipped.\n   */\n  ignore?: (file: string) => boolean;\n}\n\nconst SKIP_DIRS = new Set([\n  \"node_modules\",\n  \"dist\",\n  \"build\",\n  \"coverage\",\n  \".git\",\n  \".turbo\",\n  \"__snapshots__\",\n]);\n\nconst SOURCE = /\\.(ts|tsx|js|jsx)$/;\n\n/**\n * Blank out comments, keeping line structure so reported line numbers still\n * point at the source, so prose about the rule is not a breach of it. Not a\n * parser: over-blanking would at worst hide a symbol inside a string literal.\n */\nfunction stripComments(source: string): string[] {\n  const out: string[] = [];\n  let inBlock = false;\n  for (const line of source.split(\"\\n\")) {\n    let kept = \"\";\n    let i = 0;\n    while (i < line.length) {\n      if (inBlock) {\n        if (line.startsWith(\"*/\", i)) {\n          inBlock = false;\n          i += 2;\n        } else {\n          i += 1;\n        }\n        continue;\n      }\n      if (line.startsWith(\"/*\", i)) {\n        inBlock = true;\n        i += 2;\n        continue;\n      }\n      if (line.startsWith(\"//\", i)) break;\n      kept += line[i];\n      i += 1;\n    }\n    out.push(kept);\n  }\n  return out;\n}\n\nfunction isTest(file: string): boolean {\n  return file.includes(\".test.\") || file.includes(\".spec.\");\n}\n\nfunction walk(root: string, dir: string, out: string[]): void {\n  for (const entry of readdirSync(dir)) {\n    const full = join(dir, entry);\n    if (statSync(full).isDirectory()) {\n      if (!SKIP_DIRS.has(entry)) walk(root, full, out);\n      continue;\n    }\n    if (SOURCE.test(entry)) out.push(relative(root, full).split(sep).join(\"/\"));\n  }\n}\n\n/**\n * The pattern every offender takes: a `${...}` interpolation, then optionally\n * one space, then a unit symbol ending at a non-word boundary.\n *\n * Longest symbol first, so `m/s` cannot be matched as a bare `m` and reported\n * with the wrong symbol.\n */\nfunction patternFor(symbols: readonly string[]): RegExp {\n  const alternatives = [...symbols].sort((a, b) => b.length - a.length);\n  const escaped = alternatives.map((s) =>\n    s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"),\n  );\n  return new RegExp(`\\\\}\\\\s?(${escaped.join(\"|\")})([^A-Za-z0-9_/]|\\`|$)`);\n}\n\n/**\n * Every place a unit symbol is typed next to a number, under `dir`.\n *\n * Returns findings rather than throwing, so a caller can report them their own\n * way. {@link expectNoHandTypedUnits} is the assertion built on top.\n *\n * @category Testing\n */\nexport function findHandTypedUnits(\n  options: HandTypedUnitOptions = {},\n): HandTypedUnit[] {\n  const dir = options.dir ?? \"src\";\n  const pattern = patternFor(options.symbols ?? HAND_TYPED_SYMBOLS);\n  const files: string[] = [];\n  walk(dir, dir, files);\n\n  const found: HandTypedUnit[] = [];\n  for (const file of files) {\n    if (isTest(file)) continue;\n    if (options.ignore?.(file)) continue;\n    const raw = readFileSync(join(dir, file), \"utf8\").split(\"\\n\");\n    stripComments(raw.join(\"\\n\")).forEach((code, index) => {\n      const match = pattern.exec(code);\n      if (match === null) return;\n      if (CSS_PROPERTY.test(code)) return;\n      found.push({\n        file,\n        line: index + 1,\n        // The raw line, not the blanked form the scan matched against.\n        source: raw[index].trim(),\n        symbol: match[1],\n      });\n    });\n  }\n  return found;\n}\n\n/**\n * Throws when a unit symbol is typed next to a number, with the fix in the\n * message. Silent for a file at its `baseline` entry; a file below its entry\n * throws, so an allowance left higher than needed cannot let the symbol come\n * back unnoticed.\n *\n * @example\n * ```ts\n * import { expectNoHandTypedUnits } from \"@ksp-gonogo/ui-kit/guards\";\n * import { it } from \"vitest\";\n *\n * it(\"renders units through <Unit>, not by typing the symbol\", () => {\n *   expectNoHandTypedUnits({ dir: \"src\" });\n * });\n * ```\n *\n * @category Testing\n */\nexport function expectNoHandTypedUnits(\n  options: HandTypedUnitOptions = {},\n): void {\n  const baseline = options.baseline ?? {};\n  const found = findHandTypedUnits(options);\n\n  const counts: Record<string, number> = {};\n  for (const one of found) counts[one.file] = (counts[one.file] ?? 0) + 1;\n\n  const over = found.filter(\n    (one) => (counts[one.file] ?? 0) > (baseline[one.file] ?? 0),\n  );\n  if (over.length > 0) {\n    throw new Error(\n      `A unit symbol was typed next to a number in ${over.length} place(s). ` +\n        \"Render <Unit value={x} /> instead, so the symbol keeps its styling, \" +\n        \"follows the value's ladder, and is announced as a word rather than \" +\n        \"as letters.\\n\\nWhere a string is genuinely required: speakQuantity \" +\n        \"for an accessible name, writeQuantity for visible text that is \" +\n        \"MEASURED (an SVG <text>, a canvas label), and nothing else.\\n\\n\" +\n        over\n          .map((one) => `  ${one.file}:${one.line}  ${one.source}`)\n          .join(\"\\n\"),\n    );\n  }\n\n  const stale = Object.keys(baseline).filter(\n    (file) => (counts[file] ?? 0) < baseline[file],\n  );\n  if (stale.length > 0) {\n    throw new Error(\n      \"These are below their baseline, which is good news. Lower or remove \" +\n        \"the entry so the gain is locked in, otherwise the symbol is free to \" +\n        `come back:\\n${stale\n          .map((f) => `  ${f}: now ${counts[f] ?? 0}, baseline ${baseline[f]}`)\n          .join(\"\\n\")}`,\n    );\n  }\n}\n"],"mappings":"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","names":[]}