basalt-ui 1.21.0 → 1.23.0

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/check-theme.test.ts

@@ -742,3 +742,38 @@ describe('severity — warnings report, errors fail', () => {
     expect(err).toContain('✖ Theme guard')
   })
 })
+
+// ── the manifest waiver hint, gated on the profile ────────────────────────────────────────────
+//
+// rollhook. The hint leads with `basaltAppPlugin`, which is right for a Mantine app — a hex in a
+// manifest can never be right, and the plugin removes the hand-copy entirely. A `tokens-only`
+// consumer has definitionally opted out of that layer: rollhook's Astro site has no index.html to
+// transform, imports no basalt JavaScript at all, and owns maskable icons the plugin does not emit.
+// Leading with it there is advice the consumer cannot take.
+
+describe('check-theme — the manifest waiver hint follows the profile', () => {
+  function manifestFixture(basalt: Record<string, unknown>): void {
+    writeFileSync(resolve(dir, 'package.json'), JSON.stringify({ name: 'fixture', basalt }))
+    mkdirSync(resolve(dir, 'src'), { recursive: true })
+    writeFileSync(resolve(dir, 'src', 'app.tsx'), 'export const App = () => null\n')
+    mkdirSync(resolve(dir, 'public'), { recursive: true })
+    writeFileSync(
+      resolve(dir, 'public', 'site.webmanifest'),
+      JSON.stringify({ name: 'x', theme_color: '#18181b' }, null, 2),
+    )
+  }
+
+  it('offers basaltAppPlugin first to a framework consumer', () => {
+    manifestFixture({ roots: ['src'] })
+    const { err } = run()
+    expect(err).toContain('let basaltAppPlugin emit it')
+  })
+
+  it('leads with the member for a tokens-only consumer, and says which remedy it withheld', () => {
+    manifestFixture({ roots: ['src'], profile: 'tokens-only' })
+    const { err } = run()
+    expect(err).toContain('JSON has no comments — declare a deliberate exception')
+    expect(err).not.toContain('let basaltAppPlugin emit it')
+    expect(err).toContain('a tokens-only consumer has opted out of')
+  })
+})

package/src/cli/help.test.ts

@@ -4,7 +4,7 @@
  * matched `cmd === 'sync'` first and `--help` was just another item in `flags`, ignored).
  */
 import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { resolve } from 'node:path'
 
@@ -86,6 +86,10 @@ describe('run() --help short-circuits before dispatch', () => {
   })
 
   it('`sync` without --help still runs for real and writes the manifest (control case)', () => {
+    // `sync` refuses to scaffold where nothing was ever installed, so the control case has to be a
+    // repo that HAS an install — which is what `sync` is for.
+    mkdirSync(resolve(dir, '.basalt'), { recursive: true })
+    writeFileSync(resolve(dir, MANIFEST_PATH), JSON.stringify({ version: 1, files: {} }))
     const { code } = capture(() => run(['sync'], dir))
     expect(code).toBe(0)
     expect(existsSync(resolve(dir, MANIFEST_PATH))).toBe(true)