basalt-ui 1.27.0 → 1.29.0

package/dist/charts/sparklines/BarSparkline.js

@@ -11,7 +11,9 @@ function BarSparkline({
   barRadius = 0,
   emphasizeLast = false,
   emphasisColor,
-  ariaLabel
+  ariaLabel,
+  className,
+  style
 }) {
   const fillColor = color ?? VX.faint;
   const lastColor = emphasisColor ?? VX.accent;
@@ -20,11 +22,15 @@ function BarSparkline({
     const max = Math.max(...data.filter((v) => isFinite(v)), 1);
     return scaleLinear({ domain: [0, max], range: [0, height] });
   }, [data, height]);
-  if (!data.length) return /* @__PURE__ */ jsx("svg", { width, height, ...a11yProps });
+  const rootProps = {
+    ...className !== void 0 && { className },
+    ...style !== void 0 && { style }
+  };
+  if (!data.length) return /* @__PURE__ */ jsx("svg", { width, height, ...rootProps, ...a11yProps });
   const step = width / data.length;
   const barWidth = Math.max(step - barGap, 1);
   const lastIndex = data.length - 1;
-  return /* @__PURE__ */ jsx("svg", { width, height, ...a11yProps, children: data.map((v, i) => {
+  return /* @__PURE__ */ jsx("svg", { width, height, ...rootProps, ...a11yProps, children: data.map((v, i) => {
     const bh = Math.max(yScale(Math.max(v, 0)), 0);
     const isLast = emphasizeLast && i === lastIndex;
     return /* @__PURE__ */ jsx(

package/dist/charts/sparklines/LineSparkline.d.ts

@@ -1,4 +1,5 @@
-type LineSparklineProps = {
+import type { BasaltProps } from '../../common/props.js';
+export type LineSparklineProps = BasaltProps & {
     data: number[];
     width: number;
     height: number;
@@ -10,6 +11,5 @@ type LineSparklineProps = {
  * Quiet single-hue trend line (docs/DESIGN-SPEC.md §5: "single 1.6px faint line, no fill, no
  * axes, no dots"). Sparklines default to `VX.faint`, not the bolder `VX.line` used by full charts.
  */
-export declare function LineSparkline({ data, width, height, color, ariaLabel }: LineSparklineProps): import("react").JSX.Element;
-export {};
+export declare function LineSparkline({ data, width, height, color, ariaLabel, className, style, }: LineSparklineProps): import("react").JSX.Element;
 //# sourceMappingURL=LineSparkline.d.ts.map

package/dist/charts/sparklines/LineSparkline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LineSparkline.d.ts","sourceRoot":"","sources":["../../../src/charts/sparklines/LineSparkline.tsx"],"names":[],"mappings":"AAOA,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4FAA4F;IAC5F,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,kBAAkB,+BAoC1F"}
+{"version":3,"file":"LineSparkline.d.ts","sourceRoot":"","sources":["../../../src/charts/sparklines/LineSparkline.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGrD,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG;IAC7C,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4FAA4F;IAC5F,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAC5B,IAAI,EACJ,KAAK,EACL,MAAM,EACN,KAAK,EACL,SAAS,EACT,SAAS,EACT,KAAK,GACN,EAAE,kBAAkB,+BAyCpB"}

package/dist/charts/sparklines/LineSparkline.js

@@ -5,7 +5,15 @@ import { scaleLinear } from "@visx/scale";
 import { LinePath } from "@visx/shape";
 import { useMemo } from "react";
 import { VX } from "../../tokens/index.js";
-function LineSparkline({ data, width, height, color, ariaLabel }) {
+function LineSparkline({
+  data,
+  width,
+  height,
+  color,
+  ariaLabel,
+  className,
+  style
+}) {
   const strokeColor = color ?? VX.faint;
   const a11yProps = ariaLabel !== void 0 ? { role: "img", "aria-label": ariaLabel } : {};
   const xScale = useMemo(
@@ -20,9 +28,13 @@ function LineSparkline({ data, width, height, color, ariaLabel }) {
     const pad = (max - min) * 0.1 || 1;
     return scaleLinear({ domain: [min - pad, max + pad], range: [height, 0] });
   }, [data, height]);
-  if (data.length < 2) return /* @__PURE__ */ jsx("svg", { width, height, ...a11yProps });
+  const rootProps = {
+    ...className !== void 0 && { className },
+    ...style !== void 0 && { style }
+  };
+  if (data.length < 2) return /* @__PURE__ */ jsx("svg", { width, height, ...rootProps, ...a11yProps });
   const indexed = data.map((v, i) => ({ v, i }));
-  return /* @__PURE__ */ jsx("svg", { width, height, ...a11yProps, children: /* @__PURE__ */ jsx(Group, { children: /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx("svg", { width, height, ...rootProps, ...a11yProps, children: /* @__PURE__ */ jsx(Group, { children: /* @__PURE__ */ jsx(
     LinePath,
     {
       data: indexed,

package/dist/charts/sparklines/index.d.ts

@@ -1,3 +1,3 @@
-export { LineSparkline } from './LineSparkline.js';
-export { BarSparkline } from './BarSparkline.js';
+export { LineSparkline, type LineSparklineProps } from './LineSparkline.js';
+export { BarSparkline, type BarSparklineProps } from './BarSparkline.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/charts/sparklines/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/charts/sparklines/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/charts/sparklines/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACxE,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/charts/utils/format.d.ts

@@ -1,5 +1,8 @@
-/** Axis-friendly short date: DD.MM */
-export declare function fmtAxisDate(value: unknown): string;
-/** Tooltip-friendly long date: "Mon Apr 21 2026" */
-export declare function fmtTooltipDate(date: unknown): string;
+/**
+ * Re-export shim. The implementation moved to `basalt-ui/format` (C5 consolidation, so
+ * `money`/`percent`/`duration`/`clock`/… and the chart formatters share one implementation
+ * instead of two). This file stays so every existing relative import inside `src/charts/**`
+ * (`../utils/format`) keeps resolving unchanged.
+ */
+export { fmtAxisDate, fmtTooltipDate, fmtCompact, type FmtCompactOptions, fmtPercent, type FmtPercentOptions, fmtCurrency, type FmtCurrencyOptions, fmtInt, formatters, NON_FINITE, } from '../../format/index.js';
 //# sourceMappingURL=format.d.ts.map

package/dist/charts/utils/format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/charts/utils/format.ts"],"names":[],"mappings":"AAGA,sCAAsC;AACtC,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAUlD;AAED,oDAAoD;AACpD,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CASpD"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/charts/utils/format.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,WAAW,EACX,cAAc,EACd,UAAU,EACV,KAAK,iBAAiB,EACtB,UAAU,EACV,KAAK,iBAAiB,EACtB,WAAW,EACX,KAAK,kBAAkB,EACvB,MAAM,EACN,UAAU,EACV,UAAU,GACX,MAAM,cAAc,CAAA"}

package/dist/charts/utils/format.js

@@ -1,27 +1,20 @@
-const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-const SHORT_DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-function fmtAxisDate(value) {
-  if (value instanceof Date) {
-    const dd = String(value.getDate()).padStart(2, "0");
-    const mm = String(value.getMonth() + 1).padStart(2, "0");
-    return `${dd}.${mm}`;
-  }
-  const s = String(value ?? "");
-  const match = s.match(/(\d{4})-(\d{2})-(\d{2})/);
-  if (match) return `${match[3]}.${match[2]}`;
-  return s;
-}
-function fmtTooltipDate(date) {
-  if (date instanceof Date) {
-    return `${SHORT_DAYS[date.getDay()]} ${MONTHS[date.getMonth()]} ${date.getDate()} ${date.getFullYear()}`;
-  }
-  const s = String(date ?? "");
-  const match = s.match(/(\d{4})-(\d{2})-(\d{2})/);
-  if (!match) return s;
-  const d = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
-  return `${SHORT_DAYS[d.getDay()]} ${MONTHS[d.getMonth()]} ${d.getDate()} ${d.getFullYear()}`;
-}
+import {
+  fmtAxisDate,
+  fmtTooltipDate,
+  fmtCompact,
+  fmtPercent,
+  fmtCurrency,
+  fmtInt,
+  formatters,
+  NON_FINITE
+} from "../../format/index.js";
 export {
+  NON_FINITE,
   fmtAxisDate,
-  fmtTooltipDate
+  fmtCompact,
+  fmtCurrency,
+  fmtInt,
+  fmtPercent,
+  fmtTooltipDate,
+  formatters
 };

package/dist/charts/utils/ticks.d.ts

@@ -1,5 +1,84 @@
-/** Pick evenly-spaced tick values that fit the available width */
-export declare function smartTicks(dates: string[], xMax: number): string[];
+import type { ChartTier } from '../primitives/chart-frame-layout.js';
+/**
+ * The horizontal room one x tick label needs: the widest string in `labels`, plus breathing space
+ * to its neighbour. Feeds `smartTicks`, which otherwise thinned the axis by a constant that knew
+ * nothing about what was actually painted (`docs/CHARTS-SPEC.md` §1). Shared by `CartesianChart`,
+ * `useBandPlot` and `DualPanel` — the three call sites that used to reimplement this formula.
+ *
+ * `fontPx` defaults to `VX.axisFont`; a phone-tier chart passes its own smaller tick font
+ * (`chartTierMetrics().axisFont`) so the spacing is derived from the size actually painted.
+ */
+export declare function xLabelPxFor(labels: string[], fontPx?: number): number;
+/**
+ * Pick evenly-spaced tick values that fit the available width.
+ *
+ * `labelPx` is the width one formatted label actually needs (measured, plus the gap it wants from
+ * its neighbour) and overrides the `VX.minPxPerTick` floor whenever it is wider. Without it the
+ * spacing came from that constant alone regardless of what was painted, so a `formatX` returning
+ * `Mar 08 14:00` overlapped at every width — the one side of the chart that did not follow §1's
+ * "measure what you paint" law. Omit it and nothing moves.
+ *
+ * The final key is still appended when the step misses the last index — a thinned axis would
+ * otherwise paint no label at the right edge at all — but it no longer prints ON TOP of its
+ * neighbour. An appended tick lands a PARTIAL step from the last one on the grid, so at any tick
+ * count wide enough labels overlap there; measured at `/charts-stress` block (f1), `Mar 13 14:00`
+ * and `Mar 14 14:00` printed over each other at 1440px. When that gap is narrower than one label,
+ * the grid tick before it is dropped instead. Index 0 is never dropped: the left edge is the one
+ * label a reader orients from.
+ */
+export declare function smartTicks(dates: string[], xMax: number, labelPx?: number): string[];
+/**
+ * Which of a BAND axis's category labels may be painted so that no two neighbours overlap — the
+ * same measured law {@link smartTicks} applies to a point axis, for a chart that lays its labels
+ * out itself instead of through the `Axis*` primitives.
+ *
+ * `Heatmap` was the one kind rendering labels as plain `<text>`, and therefore the one kind exempt
+ * from §1's measured-margin law: it printed all 12 columns at 390px, ten of them overlapping. Here
+ * `bandPx` is the pitch between two neighbouring labels (a cell's width for columns, its height for
+ * rows) and `labelPx` the room one label needs ({@link xLabelPxFor} for a horizontal run, the line
+ * box for a vertical one); a label is kept every `ceil(labelPx / bandPx)` bands, so the gap between
+ * two painted labels is never narrower than one label.
+ *
+ * The first and last band always keep theirs — they are the two a reader orients from — and when
+ * the last one lands a partial step from the grid, the grid label before it is dropped rather than
+ * printed underneath, exactly as `smartTicks` does with its appended final tick.
+ */
+export declare function thinLabels(labels: readonly string[], bandPx: number, labelPx: number): Set<number>;
 /** Variant of smartTicks that targets an exact tick count rather than deriving from width. */
 export declare function smartTicksEvery(dates: string[], count: number): string[];
+/**
+ * The phone tier's default x-label rotation: 45° when the labels are so wide that fewer than
+ * {@link MIN_HORIZONTAL_TICKS} of them fit side by side, else none.
+ *
+ * `xLabelRotate` already existed as the answer to a `formatX` too wide to repeat horizontally
+ * (`docs/CHARTS-SPEC.md` §1) — it just had to be reached for by hand, per chart, by someone who
+ * had already seen it collide on a phone. This makes it the DEFAULT at phone width and only there:
+ * rotating trades horizontal crowding for bottom-gutter depth, which is the cheap axis on a narrow
+ * viewport and the expensive one on a wide screen that had room all along. Opt out with an
+ * explicit `xLabelRotate: 0`.
+ *
+ * Deliberately measured against the same `labelPx` `smartTicks` thins by, so the decision and the
+ * thinning cannot disagree about how wide a label is.
+ *
+ * **Wanting to rotate is not the same as rotating fitting.** A rotated label reaches into the LEFT
+ * gutter (`rotatedLabelExtents`), so rotating BUYS bottom-gutter depth and SPENDS plot width — and
+ * at a narrow enough box it spends more than it buys. `/charts-stress` block (f1) is the case:
+ * three clean horizontal labels at 390, and at 320 an auto-rotation that reached off the left edge
+ * and bought not one extra label for it. So the trade is CHECKED, not assumed. Pass `rotatedXMax`
+ * (the width left once `autoMargin({ rotate: 45 })` has taken its deeper left gutter) and the
+ * rotation is taken only when the rotated axis paints MORE labels than the flat one at its
+ * projected pitch (`labelPx · cos 45°`), and at least two of them. Otherwise the axis stays flat
+ * and `smartTicks` thins further — two readable horizontal labels beat two tilted ones in a
+ * narrower plot. Omit `rotatedXMax` and the check is skipped.
+ */
+export declare function autoXLabelRotate(input: {
+    tier: ChartTier;
+    /** Plot width available to the x axis, from the UNROTATED margin. */
+    xMax: number;
+    /** What one x label needs horizontally ({@link xLabelPxFor}). */
+    labelPx: number;
+    /** Plot width that would REMAIN once the rotated margin takes its deeper left gutter
+     * (`autoMargin({ rotate: 45 })`). Omit to skip the fit check. */
+    rotatedXMax?: number;
+}): 0 | 45;
 //# sourceMappingURL=ticks.d.ts.map

package/dist/charts/utils/ticks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ticks.d.ts","sourceRoot":"","sources":["../../../src/charts/utils/ticks.ts"],"names":[],"mappings":"AAEA,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAMlE;AAED,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAKxE"}
+{"version":3,"file":"ticks.d.ts","sourceRoot":"","sources":["../../../src/charts/utils/ticks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAMjE;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,GAAE,MAAoB,GAAG,MAAM,CAElF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAqBpF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,GAAG,CAAC,MAAM,CAAC,CAkBb;AAED,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAKxE;AAaD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,IAAI,EAAE,SAAS,CAAA;IACf,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAA;IACZ,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAA;IACf;qEACiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,CAAC,GAAG,EAAE,CAST"}

package/dist/charts/utils/ticks.js

@@ -1,10 +1,45 @@
 import { VX } from "../../tokens/index.js";
-function smartTicks(dates, xMax) {
+import { maxTextWidth } from "./measure-text.js";
+const X_TICK_LABEL_GAP = 8;
+function xLabelPxFor(labels, fontPx = VX.axisFont) {
+  return maxTextWidth(labels, fontPx) + X_TICK_LABEL_GAP;
+}
+function smartTicks(dates, xMax, labelPx) {
   if (dates.length === 0) return [];
-  const maxTicks = Math.max(2, Math.floor(xMax / VX.minPxPerTick));
+  const perTick = Math.max(VX.minPxPerTick, labelPx ?? 0);
+  const maxTicks = Math.max(2, Math.floor(xMax / perTick));
   if (dates.length <= maxTicks) return dates;
   const step = Math.ceil(dates.length / maxTicks);
-  return dates.filter((_, i) => i % step === 0 || i === dates.length - 1);
+  const last = dates.length - 1;
+  const keep = /* @__PURE__ */ new Set();
+  for (let i = 0; i <= last; i += step) keep.add(i);
+  const lastOnGrid = Math.floor(last / step) * step;
+  if (lastOnGrid !== last) {
+    const pxPerIndex = dates.length > 0 ? xMax / dates.length : 0;
+    const gapPx = (last - lastOnGrid) * pxPerIndex;
+    if (lastOnGrid > 0 && gapPx > 0 && gapPx < perTick) keep.delete(lastOnGrid);
+    keep.add(last);
+  }
+  return dates.filter((_, i) => keep.has(i));
+}
+function thinLabels(labels, bandPx, labelPx) {
+  const keep = /* @__PURE__ */ new Set();
+  const last = labels.length - 1;
+  if (last < 0) return keep;
+  keep.add(0);
+  if (last === 0) return keep;
+  if (bandPx <= 0 || labelPx <= 0) {
+    keep.add(last);
+    return keep;
+  }
+  const step = Math.max(1, Math.ceil(labelPx / bandPx));
+  for (let i = 0; i <= last; i += step) keep.add(i);
+  const lastOnGrid = Math.floor(last / step) * step;
+  if (lastOnGrid !== last && lastOnGrid > 0 && (last - lastOnGrid) * bandPx < labelPx) {
+    keep.delete(lastOnGrid);
+  }
+  keep.add(last);
+  return keep;
 }
 function smartTicksEvery(dates, count) {
   if (dates.length === 0) return [];
@@ -12,7 +47,22 @@ function smartTicksEvery(dates, count) {
   const step = Math.ceil(dates.length / count);
   return dates.filter((_, i) => i % step === 0 || i === dates.length - 1);
 }
+const MIN_HORIZONTAL_TICKS = 3;
+const COS_45 = Math.SQRT1_2;
+function autoXLabelRotate(input) {
+  const { tier, xMax, labelPx, rotatedXMax } = input;
+  if (tier !== "phone") return 0;
+  if (labelPx <= 0 || xMax <= 0) return 0;
+  const flatLabels = Math.floor(xMax / labelPx);
+  if (flatLabels >= MIN_HORIZONTAL_TICKS) return 0;
+  if (rotatedXMax === void 0) return 45;
+  const rotatedLabels = Math.floor(rotatedXMax / (labelPx * COS_45));
+  return rotatedLabels >= 2 && rotatedLabels > flatLabels ? 45 : 0;
+}
 export {
+  autoXLabelRotate,
   smartTicks,
-  smartTicksEvery
+  smartTicksEvery,
+  thinLabels,
+  xLabelPxFor
 };

package/dist/cli/audit-allows.d.ts

@@ -0,0 +1,24 @@
+import type { GuardConfig } from '../guard/index.js';
+import type { BasaltConfig } from './index.js';
+/**
+ * `check-theme --audit-allows` — list every active waiver and prove, per waiver, whether it still
+ * suppresses anything.
+ *
+ * The accountability release shipped `theme-allow-unscoped`, which reports a waiver that names no
+ * rule — but a waiver that is perfectly well written and covers a finding that no longer exists is
+ * invisible to it, and to everything else. Two consumers found five of those by hand, by editing
+ * the token out and re-running the guard. This is that method, automated: for each annotation the
+ * file is re-checked with THAT occurrence neutralized, and the findings that appear are exactly
+ * what it suppresses. Nothing is inferred from the annotation's text, so the audit cannot disagree
+ * with the scan — it IS the scan, run twice.
+ *
+ * `basalt.exemptRules` entries are audited the same way, one pattern at a time. That also answers
+ * the question the key could never answer for itself: a pattern that matches no scanned file (a
+ * real relative path, say, where the matcher takes whole path SEGMENTS) suppresses nothing and is
+ * reported as dead rather than passing silently.
+ *
+ * Exit 1 when anything is dead, so it can be wired into CI as a gate. A waiver nobody re-checks is
+ * how a rule quietly stops applying to the file that needed the exception most.
+ */
+export declare function auditAllows(cwd: string, cfg: BasaltConfig, guardCfg: GuardConfig, scanned: string[]): number;
+//# sourceMappingURL=audit-allows.d.ts.map

package/dist/cli/audit-allows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-allows.d.ts","sourceRoot":"","sources":["../../src/cli/audit-allows.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAW,WAAW,EAAa,MAAM,UAAU,CAAA;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,SAAS,CAAA;AAqJ5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,YAAY,EACjB,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE,MAAM,EAAE,GAChB,MAAM,CAqLR"}

package/dist/cli/audit-allows.js

@@ -0,0 +1,240 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+  checkSource,
+  findAllowAnnotations,
+  neutralizeAllowAnnotation,
+  unmatchedExemptPatterns
+} from "../guard/index.js";
+import { exemptRulePaths, exemptRuleReason, resolveRoots } from "./index.js";
+function findingKey(f) {
+  return `${f.relPath}:${f.line}:${f.kind}`;
+}
+function resolveToolBin(dir, name) {
+  let current = dir;
+  for (; ; ) {
+    const candidate = resolve(current, "node_modules/.bin", name);
+    if (existsSync(candidate)) return candidate;
+    const parent = resolve(current, "..");
+    if (parent === current) break;
+    current = parent;
+  }
+  const probe = spawnSync(name, ["--version"], { stdio: "ignore", timeout: 1e4 });
+  return probe.error === void 0 && probe.status === 0 ? name : null;
+}
+function diagnosticCounts(diagnostics, filename) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const d of diagnostics) {
+    if (d.filename !== filename) continue;
+    const code = typeof d.code === "string" ? d.code : "";
+    const rule = /^basalt\((.+)\)$/.exec(code)?.[1];
+    if (rule === void 0) continue;
+    const line = d.labels?.[0]?.span?.line;
+    const key = `${typeof line === "number" ? line : 0}:${rule}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function probePluginRules(cwd, guardCfg, probes, sources) {
+  if (probes.length === 0) return /* @__PURE__ */ new Map();
+  const bin = resolveToolBin(cwd, "oxlint");
+  if (bin === null) return null;
+  const written = [];
+  const probePaths = /* @__PURE__ */ new Map();
+  try {
+    for (const probe of probes) {
+      const probed = neutralizeAllowAnnotation(sources.get(probe.rel) ?? "", probe.line, guardCfg);
+      const dot = probe.rel.lastIndexOf(".");
+      const rel = dot === -1 ? `${probe.rel}.basalt-audit-${probe.slot}` : `${probe.rel.slice(0, dot)}.basalt-audit-${probe.slot}${probe.rel.slice(dot)}`;
+      const abs = resolve(cwd, rel);
+      if (existsSync(abs)) continue;
+      writeFileSync(abs, probed, "utf8");
+      written.push(abs);
+      probePaths.set(probe.slot, rel);
+    }
+    if (probePaths.size === 0) return null;
+    const targets = [...new Set(probes.map((p) => p.rel)), ...probePaths.values()];
+    const run = spawnSync(bin, ["--format=json", "--no-error-on-unmatched-pattern", ...targets], {
+      cwd,
+      encoding: "utf8",
+      timeout: 12e4,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (run.error !== void 0 || typeof run.stdout !== "string") return null;
+    let diagnostics;
+    try {
+      diagnostics = JSON.parse(run.stdout).diagnostics ?? [];
+    } catch {
+      return null;
+    }
+    const verdicts = /* @__PURE__ */ new Map();
+    for (const probe of probes) {
+      const probeRel = probePaths.get(probe.slot);
+      if (probeRel === void 0) continue;
+      const before = diagnosticCounts(diagnostics, probe.rel);
+      const after = diagnosticCounts(diagnostics, probeRel);
+      const revealed = [];
+      for (const [key, count] of after) {
+        if (count <= (before.get(key) ?? 0)) continue;
+        const [line = "", rule = ""] = key.split(":");
+        revealed.push(`${rule}@${line}`);
+      }
+      verdicts.set(probe.slot, revealed.toSorted());
+    }
+    return verdicts;
+  } finally {
+    for (const abs of written) {
+      try {
+        unlinkSync(abs);
+      } catch {
+      }
+    }
+  }
+}
+function auditAllows(cwd, cfg, guardCfg, scanned) {
+  const token = guardCfg.allowComment;
+  const lines = [`
+basalt-ui check-theme --audit-allows \u2014 ${cwd}
+`];
+  let dead = 0;
+  let live = 0;
+  let outOfReach = 0;
+  let unaccountable = 0;
+  const waiverLines = [];
+  const pluginProbes = [];
+  const sources = /* @__PURE__ */ new Map();
+  for (const rel of scanned) sources.set(rel, readFileSync(resolve(cwd, rel), "utf8"));
+  for (const rel of scanned) {
+    const text = sources.get(rel) ?? "";
+    if (!text.includes(token)) continue;
+    const baseline = checkSource(text, rel, guardCfg);
+    const baselineKeys = new Set(
+      baseline.filter((f) => f.kind !== "theme-allow-unscoped").map(findingKey)
+    );
+    const unscopedAt = new Map(
+      baseline.filter((f) => f.kind === "theme-allow-unscoped").map((f) => [f.line, f.token])
+    );
+    for (const site of findAllowAnnotations(text, rel, guardCfg)) {
+      const revealed = checkSource(
+        neutralizeAllowAnnotation(text, site.line, guardCfg),
+        rel,
+        guardCfg
+      ).filter((f) => f.kind !== "theme-allow-unscoped" && !baselineKeys.has(findingKey(f))).map((f) => `${f.kind}@${f.line}`);
+      const note = unscopedAt.get(site.line);
+      if (note !== void 0) unaccountable++;
+      const label = `  ${rel}:${site.line}`.padEnd(52);
+      const suffix = note === void 0 ? "" : ` [${note}]`;
+      if (revealed.length > 0) {
+        live++;
+        waiverLines.push(`${label} suppresses ${[...new Set(revealed)].join(", ")}${suffix}`);
+        continue;
+      }
+      if (site.pluginRules.length > 0 && site.guardKinds.length === 0) {
+        pluginProbes.push({
+          slot: waiverLines.length,
+          rel,
+          line: site.line,
+          ids: site.pluginRules,
+          site: label,
+          suffix
+        });
+        waiverLines.push("");
+        continue;
+      }
+      if (site.guardKinds.length === 0 && site.unknownRules.length > 0) {
+        outOfReach++;
+        waiverLines.push(
+          `${label} scoped to ${site.unknownRules.join(", ")} \u2014 names no guard kind and no plugin rule, so this audit cannot judge it (most likely a typo, which theme-allow-unscoped reports)${suffix}`
+        );
+        continue;
+      }
+      dead++;
+      waiverLines.push(`${label} SUPPRESSES NOTHING \u2014 dead, delete it${suffix}`);
+    }
+  }
+  const pluginVerdicts = probePluginRules(cwd, guardCfg, pluginProbes, sources);
+  for (const probe of pluginProbes) {
+    const revealed = pluginVerdicts?.get(probe.slot);
+    if (revealed === void 0) {
+      outOfReach++;
+      waiverLines[probe.slot] = `${probe.site} scoped to ${probe.ids.join(", ")} \u2014 an oxlint plugin rule, and oxlint could not be run here, so this audit cannot judge it${probe.suffix}`;
+      continue;
+    }
+    if (revealed.length > 0) {
+      live++;
+      waiverLines[probe.slot] = `${probe.site} suppresses ${revealed.join(", ")} (oxlint)${probe.suffix}`;
+      continue;
+    }
+    dead++;
+    waiverLines[probe.slot] = `${probe.site} SUPPRESSES NOTHING \u2014 dead, delete it (proved by re-running oxlint over the file with this annotation neutralized)${probe.suffix}`;
+  }
+  lines.push(`${token} annotations (${waiverLines.length}):`);
+  lines.push(...waiverLines.length === 0 ? ["  (none)"] : waiverLines);
+  const exemptLines = [];
+  let exemptCount = 0;
+  const declared = Object.entries(cfg.exemptRules ?? {});
+  if (declared.length > 0) {
+    const baselineKeys = /* @__PURE__ */ new Set();
+    for (const rel of scanned) {
+      for (const f of checkSource(sources.get(rel) ?? "", rel, guardCfg))
+        baselineKeys.add(findingKey(f));
+    }
+    for (const [kind, entry] of declared) {
+      const reason = exemptRuleReason(entry);
+      for (const pattern of exemptRulePaths(entry)) {
+        exemptCount++;
+        const probeCfg = {
+          ...guardCfg,
+          exemptRules: {
+            ...guardCfg.exemptRules,
+            [kind]: exemptRulePaths(entry).filter((p) => p !== pattern)
+          }
+        };
+        const revealed = /* @__PURE__ */ new Set();
+        for (const rel of scanned) {
+          for (const f of checkSource(sources.get(rel) ?? "", rel, probeCfg)) {
+            if (!baselineKeys.has(findingKey(f))) revealed.add(f.relPath);
+          }
+        }
+        const site = `  ${kind}: "${pattern}"`.padEnd(52);
+        const why = reason === null ? " [no reason recorded]" : ` \u2014 ${reason}`;
+        if (revealed.size === 0) {
+          dead++;
+          const unmatched = unmatchedExemptPatterns(guardCfg, scanned).find(
+            (u) => u.kind === kind && u.pattern === pattern
+          );
+          exemptLines.push(
+            `${site} SUPPRESSES NOTHING \u2014 ` + (unmatched === void 0 ? "the files it matches have no such finding; delete it" : unmatched.reason === "unknown-kind" ? "it names no guard kind (a typo, or a renamed kind)" : "it matches no scanned file at all") + why
+          );
+        } else {
+          live++;
+          exemptLines.push(
+            `${site} suppresses findings in ${[...revealed].toSorted().join(", ")}${why}`
+          );
+        }
+      }
+    }
+  }
+  lines.push(`
+basalt.exemptRules entries (${exemptCount}):`);
+  lines.push(...exemptLines.length === 0 ? ["  (none)"] : exemptLines);
+  lines.push(
+    `
+${live} live, ${dead} dead, ${outOfReach} unjudgeable, ${unaccountable} unaccountable (reported as theme-allow-unscoped by a normal run).`
+  );
+  const includes = cfg.include ?? [];
+  lines.push(
+    `Scope: the ${scanned.length} file(s) check-theme scans \u2014 everything under basalt.roots (${resolveRoots(cfg).join(", ")}), plus each root's sibling index.html and public/ tree, ` + (includes.length === 0 ? "plus anything named in basalt.include (none). " : `plus basalt.include (${includes.join(", ")}). `) + "A waiver in a file none of those reach is not audited \u2014 widen roots, or name it in basalt.include, or accept that nothing polices that file."
+  );
+  if (dead > 0) {
+    lines.push(
+      "A dead waiver is not harmless: it is an exception nobody re-checked, and it will silently cover the next real finding on that line."
+    );
+  }
+  console.log(lines.join("\n"));
+  return dead > 0 ? 1 : 0;
+}
+export {
+  auditAllows
+};

package/dist/cli/check-theme.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Theme guard — thin FS walker over the headless `../guard` core. Reads BasaltConfig, builds a
+ * GuardConfig, walks roots, calls checkSource per file, collects Finding[], groups/reports, returns
+ * 0 (clean) / 1 (violations). A `theme-allow` comment exempts a line.
+ *
+ * Runs against `resolveProjectDir(cwd)`, not `cwd` — see that type's doc for why a root-invoked
+ * hook or CI step has to find the package the config lives in rather than scan nothing and pass.
+ */
+export declare function checkTheme(invocationCwd?: string, flags?: readonly string[]): number;
+//# sourceMappingURL=check-theme.d.ts.map

package/dist/cli/check-theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-theme.d.ts","sourceRoot":"","sources":["../../src/cli/check-theme.ts"],"names":[],"mappings":"AA8BA;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,aAAa,GAAE,MAAsB,EACrC,KAAK,GAAE,SAAS,MAAM,EAAO,GAC5B,MAAM,CA2JR"}