basalt-ui 1.22.0 → 1.23.1

package/src/charts/primitives/CartesianChart.tsx

@@ -151,8 +151,24 @@ export type CartesianChartProps<T> = {
   /** Passing `y2` is what makes the chart dual-axis: it draws the right axis and widens the
    * right margin by measurement. Series opt in with `axis: 'right'`. */
   y2?: AxisConfig<T>
-  /** Exact number of x ticks. Default: as many as fit (`smartTicks`). */
+  /** Exact number of x ticks. Default: as many as fit (`smartTicks`). Ignored when
+   * `xTickValues` is set. */
   xTicks?: number
+  /**
+   * Which domain keys get a tick, chosen from the full key list and the resolved plot width.
+   * Takes precedence over `xTicks`; omit both for `smartTicks`.
+   *
+   * A COUNT is not always enough. `smartTicks`/`smartTicksEvery` append the final key
+   * unconditionally, so when the step does not land on the last index that appended tick sits a
+   * partial step from its neighbour — measured on a 24h window, two `DD.MM HH:MM` labels printed
+   * on top of each other at the right edge, at every tick count. The only fix a count can express
+   * is thinning the whole axis to avoid one crowded pair. A consumer whose labels are richer than
+   * the default `DD.MM` needs to pick the VALUES, which until now meant measuring the container
+   * itself with `useChartSize` to derive a count — the chart already knows its own width.
+   *
+   * `BandStrip`/`MirroredBars` take the identical prop, so the seam does not fork by kind.
+   */
+  xTickValues?: (keys: readonly string[], xMax: number) => readonly string[]
   /** X tick label formatter. Default `fmtAxisDate` (DD.MM). */
   formatX?: (key: string) => string
   /** Value-range bands on the left scale, drawn behind the marks. */
@@ -267,6 +283,7 @@ export function CartesianChart<T>({
   y,
   y2,
   xTicks,
+  xTickValues,
   formatX = fmtAxisDate,
   zones,
   xZones,
@@ -305,6 +322,7 @@ export function CartesianChart<T>({
           {...(y !== undefined && { y })}
           {...(y2 !== undefined && { y2 })}
           {...(xTicks !== undefined && { xTicks })}
+          {...(xTickValues !== undefined && { xTickValues })}
           formatX={formatX}
           {...(zones !== undefined && { zones })}
           {...(xZones !== undefined && { xZones })}
@@ -343,6 +361,7 @@ function CartesianPlot<T>({
   y,
   y2,
   xTicks,
+  xTickValues,
   formatX = fmtAxisDate,
   zones,
   xZones,
@@ -459,9 +478,15 @@ function CartesianPlot<T>({
     [rightDomain, yMax, y2?.nice],
   )
 
+  // Resolution order: explicit VALUES win, then an explicit COUNT, then as many as fit.
   const tickValues = useMemo(
-    () => (xTicks === undefined ? smartTicks(keys, xMax) : smartTicksEvery(keys, xTicks)),
-    [keys, xMax, xTicks],
+    () =>
+      xTickValues !== undefined
+        ? [...xTickValues(keys, xMax)]
+        : xTicks === undefined
+          ? smartTicks(keys, xMax)
+          : smartTicksEvery(keys, xTicks),
+    [keys, xMax, xTicks, xTickValues],
   )
 
   const cursor = useChartCursor<T>({

package/src/charts/primitives/HatchPattern.tsx

@@ -0,0 +1,55 @@
+import type { ReactNode } from 'react'
+import { alpha } from '../../tokens'
+
+/**
+ * A diagonal-hatch `<pattern>` — the one fill that reads as **absence** rather than as a weak
+ * measurement.
+ *
+ * A faint solid tint cannot do this job: it sits on the same perceptual axis as every other
+ * intensity of the same hue, so "nothing was measured here" and "everything measured here was
+ * fine" collapse into neighbouring steps of one ramp. Hatching is off that axis entirely and
+ * survives being placed beside a colour ramp of the same hue.
+ *
+ * `id` must be unique per document — `BandStrip` / `MirroredBars` namespace theirs with `chartId`.
+ * `opacity` is applied through `alpha()` on the stroke rather than as an `opacity` attribute, so
+ * the hue keeps resolving per colour scheme.
+ */
+export function HatchPattern({
+  id,
+  color,
+  opacity = 0.55,
+  size = 6,
+}: {
+  id: string
+  color: string
+  opacity?: number
+  size?: number
+}): ReactNode {
+  return (
+    <pattern
+      id={id}
+      width={size}
+      height={size}
+      patternUnits="userSpaceOnUse"
+      patternTransform="rotate(45)"
+    >
+      <line x1={0} y1={0} x2={0} y2={size} stroke={alpha(color, opacity)} strokeWidth={size / 3} />
+    </pattern>
+  )
+}
+
+/** `fill` value referencing a {@link HatchPattern} by id. */
+export function hatchFill(id: string): string {
+  return `url(#${id})`
+}
+
+/**
+ * The pattern's own repeat, shrunk to fit the band it textures.
+ *
+ * Left at a fixed 6px a sub-pixel band draws less than one diagonal rule, so a fill/hatch split
+ * inside one band antialiases into a single smudge no reader can tell from a fully-measured band.
+ * Floored at 2 — below that the stroke has nothing to render on.
+ */
+export function hatchSizeFor(bandWidth: number): number {
+  return Math.max(2, Math.min(6, Math.round(bandWidth)))
+}

package/src/cli/help.test.ts

@@ -4,7 +4,15 @@
  * matched `cmd === 'sync'` first and `--help` was just another item in `flags`, ignored).
  */
 import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { resolve } from 'node:path'
 
@@ -95,3 +103,68 @@ describe('run() --help short-circuits before dispatch', () => {
     expect(existsSync(resolve(dir, MANIFEST_PATH))).toBe(true)
   })
 })
+
+/**
+ * `--version` and the unknown-flag gate — one failure mode, two halves.
+ *
+ * Six consumer repos in one upgrade round reached for `basalt-ui --version` to prove WHICH CLI ran
+ * (a `bunx` cache does not re-resolve, so a pinned version and the version that gates you can
+ * differ) and got a usage dump with no version in it. The other half is the same shape: an
+ * unrecognized FLAG was silently ignored and the command exited 0, so a mistyped gate read as a
+ * passing gate.
+ */
+describe('run() --version and the unknown-flag gate', () => {
+  const version = (
+    JSON.parse(readFileSync(resolve(import.meta.dir, '../../package.json'), 'utf8')) as {
+      version: string
+    }
+  ).version
+
+  it('`--version` prints the bare resolved version and exits 0', () => {
+    const { code, log } = capture(() => run(['--version'], dir))
+    expect(code).toBe(0)
+    expect(log.trim()).toBe(version)
+  })
+
+  it('`-v` and `version` are the same thing', () => {
+    expect(capture(() => run(['-v'], dir)).log.trim()).toBe(version)
+    expect(capture(() => run(['version'], dir)).log.trim()).toBe(version)
+  })
+
+  it('the printed line is greppable on its own — no usage block around it', () => {
+    const { log } = capture(() => run(['--version'], dir))
+    expect(log).not.toContain('Usage: basalt')
+  })
+
+  it('an unrecognized flag exits 1 and NAMES it, on a command that would otherwise pass', () => {
+    const { code, log } = capture(() => run(['doctor', '--json'], dir))
+    expect(code).toBe(1)
+    expect(log).toContain("unrecognized flag '--json'")
+    expect(log).toContain('--tokens-only')
+  })
+
+  it('a near-miss flag does not slip through as a silent no-op', () => {
+    const { code, log } = capture(() => run(['check-theme', '--audit-allow'], dir))
+    expect(code).toBe(1)
+    expect(log).toContain("unrecognized flag '--audit-allow'")
+  })
+
+  it('a value-taking flag does not make its VALUE look like an unknown flag', () => {
+    const out = resolve(dir, 'tokens.css')
+    const { code } = capture(() => run(['tokens:css', '--out', out, '--only', 'core'], dir))
+    expect(code).toBe(0)
+  })
+
+  it('an unknown COMMAND names what it did not understand, above the usage block', () => {
+    const { code, log } = capture(() => run(['check-theme --audit-allows'], dir))
+    expect(code).toBe(1)
+    expect(log).toContain("unknown command 'check-theme --audit-allows'")
+    expect(log).toContain('Usage: basalt')
+  })
+
+  it('`--help` still wins over the flag gate, so a reader can always find out what is accepted', () => {
+    const { code, log } = capture(() => run(['doctor', '--json', '--help'], dir))
+    expect(code).toBe(0)
+    expect(log).toContain('Usage: basalt')
+  })
+})