basalt-ui 1.14.0 → 1.16.0

package/dist/tokens/palette.d.ts

@@ -501,6 +501,9 @@ declare const SPACE_STEP_BASE: {
     readonly chartMarginTop: 12;
     /** Chart plot-area margin, right (`VX.margin.right`). */
     readonly chartMarginRight: 16;
+    /** Minimum right margin when an `AxisRightNumeric` is rendered — labels like "100"/"60m" need
+     * more room than the no-right-axis default (`chartMargin({ rightAxis: true })`, `tokens/index.ts`). */
+    readonly chartMarginRightAxis: 40;
     /** Chart plot-area margin, bottom (`VX.margin.bottom`). */
     readonly chartMarginBottom: 30;
     /** Chart plot-area margin, left (`VX.margin.left`). */
@@ -870,6 +873,7 @@ export declare const SPACE_STEP: {
     readonly chartLegendGap: number;
     readonly chartMarginTop: number;
     readonly chartMarginRight: number;
+    readonly chartMarginRightAxis: number;
     readonly chartMarginBottom: number;
     readonly chartMarginLeft: number;
     readonly chartDotR: number;

package/dist/tokens/palette.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"palette.d.ts","sourceRoot":"","sources":["../../src/tokens/palette.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"palette.d.ts","sourceRoot":"","sources":["../../src/tokens/palette.ts"],"names":[],"mappings":"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"}

package/dist/tokens/palette.js

@@ -420,6 +420,9 @@ const SPACE_STEP_BASE = {
   chartMarginTop: 12,
   /** Chart plot-area margin, right (`VX.margin.right`). */
   chartMarginRight: 16,
+  /** Minimum right margin when an `AxisRightNumeric` is rendered — labels like "100"/"60m" need
+   * more room than the no-right-axis default (`chartMargin({ rightAxis: true })`, `tokens/index.ts`). */
+  chartMarginRightAxis: 40,
   /** Chart plot-area margin, bottom (`VX.margin.bottom`). */
   chartMarginBottom: 30,
   /** Chart plot-area margin, left (`VX.margin.left`). */

package/llms.txt

@@ -1,4 +1,4 @@
-# basalt-ui v1.14.0
+# basalt-ui v1.16.0
 # Opinionated framework for Mantine-based React apps — theme, app shell, visx charts, toolchain presets
 #
 # basalt-ui is an opinionated framework for Mantine-based React apps.
@@ -19,7 +19,7 @@
 # ./tokens.css subpath. Guide: docs/FRAMEWORK-FREE.md in the repo.
 
 Package: basalt-ui
-Version: 1.14.0
+Version: 1.16.0
 
 ## basalt-ui
 Import: import { ... } from 'basalt-ui'
@@ -30,7 +30,7 @@ OptionalPeers: react-markdown@^10.1.0, remark-gfm@^4.0.1, rehype-sanitize@^6.0.0
 
 ## basalt-ui/charts
 Import: import { ... } from 'basalt-ui/charts'
-Description: visx chart primitives, sparklines, hooks, and token re-exports (Mantine-free)
+Description: CartesianChart + visx chart primitives, kinds, sparklines, hooks, and token re-exports (Mantine-free)
 Layer: headless
 Rule: basalt-charts
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "basalt-ui",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "description": "Opinionated framework for Mantine-based React apps — theme, app shell, visx charts, toolchain presets",
   "keywords": [
     "charts",

package/src/charts/cursor/resolve.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'bun:test'
+import { buildDomainIndex, parseKey, resolveCursorPoint } from './resolve'
+
+type Point = { date: string }
+
+const daily = (days: string[]): Point[] => days.map((d) => ({ date: `2026-08-${d}` }))
+const index = (points: Point[]) => buildDomainIndex(points, (p) => p.date)
+
+describe('parseKey', () => {
+  test('reads numeric strings as numbers', () => {
+    expect(parseKey('42')).toBe(42)
+    expect(parseKey('-1.5')).toBe(-1.5)
+  })
+
+  test('reads ISO dates as timestamps', () => {
+    expect(parseKey('2026-08-18')).toBe(Date.parse('2026-08-18'))
+  })
+
+  test('returns null for a plain category', () => {
+    expect(parseKey('Direct')).toBeNull()
+  })
+})
+
+describe('resolveCursorPoint', () => {
+  test('resolves an exact key', () => {
+    const i = index(daily(['01', '02', '03']))
+    expect(resolveCursorPoint(i, '2026-08-02')?.date).toBe('2026-08-02')
+  })
+
+  test('resolves a FOLDED sibling key to the nearest own point', () => {
+    // The failure this replaced: a chart holding every other day never owned the keys its unfolded sibling
+    // broadcast, so the shared crosshair appeared on roughly one hover in two.
+    const folded = index(daily(['01', '03', '05']))
+    expect(resolveCursorPoint(folded, '2026-08-02')?.date).toBe('2026-08-01')
+    expect(resolveCursorPoint(folded, '2026-08-04')?.date).toBe('2026-08-03')
+  })
+
+  test('returns null beyond one domain step, so unrelated charts never sync', () => {
+    const i = index(daily(['01', '02', '03']))
+    expect(resolveCursorPoint(i, '2026-09-30')).toBeNull()
+  })
+
+  test('tolerates one step past each end', () => {
+    const i = index(daily(['02', '03', '04']))
+    expect(resolveCursorPoint(i, '2026-08-01')?.date).toBe('2026-08-02')
+    expect(resolveCursorPoint(i, '2026-08-05')?.date).toBe('2026-08-04')
+  })
+
+  test('categorical domains fall back to exact match only', () => {
+    const points = [{ date: 'Direct' }, { date: 'Referral' }]
+    const i = buildDomainIndex(points, (p) => p.date)
+    expect(resolveCursorPoint(i, 'Direct')?.date).toBe('Direct')
+    expect(resolveCursorPoint(i, 'Organic')).toBeNull()
+  })
+
+  test('a single-point chart resolves only its own key', () => {
+    const i = index(daily(['01']))
+    expect(resolveCursorPoint(i, '2026-08-01')?.date).toBe('2026-08-01')
+    expect(resolveCursorPoint(i, '2026-08-02')).toBeNull()
+  })
+})

package/src/charts/cursor/resolve.ts

@@ -0,0 +1,102 @@
+/**
+ * Domain-aware resolution of a BROADCAST cursor key against a chart's own points.
+ *
+ * The layer this replaced matched keys byte-for-byte, so two charts shared a cursor only if they emitted identical
+ * strings. A chart that folded its domain to fit a narrow viewport stopped owning most of the keys
+ * its siblings broadcast, and the shared crosshair then landed on roughly one hover in three with
+ * no rule a reader could infer — patched per chart by a manual `resolveKey`. Resolving on the
+ * PARSED domain instead makes that automatic (`docs/CHARTS-SPEC.md` §3).
+ */
+
+/**
+ * A key as a comparable number: numeric-looking strings as numbers, everything else as a date.
+ * Neither (a plain category like "Direct") → null, which degrades to exact-match only — correct,
+ * since "nearest category" is meaningless.
+ */
+export function parseKey(key: string): number | null {
+  if (/^[-+]?\d*\.?\d+$/.test(key)) {
+    const n = Number(key)
+    return Number.isFinite(n) ? n : null
+  }
+  const t = Date.parse(key)
+  return Number.isNaN(t) ? null : t
+}
+
+export type DomainIndex<T> = {
+  byKey: Map<string, T>
+  /** Parsed positions, ascending. Empty when the domain isn't parseable. */
+  values: number[]
+  /** Points parallel to `values`. */
+  points: T[]
+  /** Median spacing — the tolerance within which a foreign key still resolves. */
+  step: number
+}
+
+/** Build the lookup structure once per `data` identity. */
+export function buildDomainIndex<T>(data: readonly T[], getKey: (d: T) => string): DomainIndex<T> {
+  const byKey = new Map<string, T>()
+  const parsed: { value: number; point: T }[] = []
+  let parseable = true
+
+  for (const d of data) {
+    byKey.set(getKey(d), d)
+    if (!parseable) continue
+    const value = parseKey(getKey(d))
+    if (value === null) parseable = false
+    else parsed.push({ value, point: d })
+  }
+
+  // Under two parseable points there is no step to reason about, so nearest-match would be
+  // unbounded — fall back to exact match.
+  if (!parseable || parsed.length < 2) return { byKey, values: [], points: [], step: 0 }
+
+  parsed.sort((a, b) => a.value - b.value)
+  const values = parsed.map((p) => p.value)
+  const points = parsed.map((p) => p.point)
+
+  const diffs: number[] = []
+  for (let i = 1; i < values.length; i++) {
+    diffs.push((values[i] as number) - (values[i - 1] as number))
+  }
+  diffs.sort((a, b) => a - b)
+
+  return { byKey, values, points, step: diffs[Math.floor(diffs.length / 2)] ?? 0 }
+}
+
+/**
+ * The own point a broadcast `key` maps to: exact match first, else the nearest parsed position
+ * within one domain step. Out of range → null, so charts over unrelated domains never paint a
+ * cursor for each other — which is what makes "shared by default" safe.
+ */
+export function resolveCursorPoint<T>(index: DomainIndex<T>, key: string): T | null {
+  const exact = index.byKey.get(key)
+  if (exact !== undefined) return exact
+
+  const target = parseKey(key)
+  if (target === null || index.values.length === 0) return null
+
+  const first = index.values[0] as number
+  const last = index.values[index.values.length - 1] as number
+  if (target < first - index.step || target > last + index.step) return null
+
+  let lo = 0
+  let hi = index.values.length - 1
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1
+    if ((index.values[mid] as number) < target) lo = mid + 1
+    else hi = mid
+  }
+
+  let best = lo
+  let bestDist = Math.abs((index.values[lo] as number) - target)
+  if (lo > 0) {
+    const prevDist = Math.abs((index.values[lo - 1] as number) - target)
+    // `<=`, not `<`: a key landing exactly between two own points belongs to the EARLIER one —
+    // the folded bucket that swallowed it starts there, so ties resolve backwards, consistently.
+    if (prevDist <= bestDist) {
+      best = lo - 1
+      bestDist = prevDist
+    }
+  }
+  return bestDist <= index.step ? (index.points[best] as T) : null
+}

package/src/charts/cursor/scope.tsx

@@ -0,0 +1,32 @@
+import { createContext, useContext, useMemo, useSyncExternalStore } from 'react'
+import type { ReactNode } from 'react'
+import type { CursorState, CursorStore } from './store'
+import { createCursorStore, EMPTY_CURSOR, globalCursorStore } from './store'
+
+const CursorStoreContext = createContext<CursorStore>(globalCursorStore)
+
+export type ChartCursorScopeProps = {
+  children: ReactNode
+}
+
+/**
+ * ISOLATES its subtree onto a private cursor store — the inverse of the removed `ChartHoverSync`, which
+ * had to be mounted to enable sharing at all. Charts share a cursor by default now; wrap a group
+ * in this only when it must NOT follow the rest of the page (e.g. two independent dashboards
+ * rendered side by side over the same calendar).
+ */
+export function ChartCursorScope({ children }: ChartCursorScopeProps) {
+  const store = useMemo(() => createCursorStore(), [])
+  return <CursorStoreContext.Provider value={store}>{children}</CursorStoreContext.Provider>
+}
+
+/** The cursor store this chart belongs to — the nearest `ChartCursorScope`, else the global one. */
+export function useCursorStore(): CursorStore {
+  return useContext(CursorStoreContext)
+}
+
+/** Subscribe to the ambient cursor. Re-renders only on an actual cursor change. */
+export function useCursorState(): CursorState {
+  const store = useCursorStore()
+  return useSyncExternalStore(store.subscribe, store.get, () => EMPTY_CURSOR)
+}

package/src/charts/cursor/store.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'bun:test'
+import { createCursorStore, globalCursorStore } from './store'
+
+describe('cursor store', () => {
+  test('notifies subscribers on change', () => {
+    const store = createCursorStore()
+    let calls = 0
+    const unsubscribe = store.subscribe(() => {
+      calls++
+    })
+
+    store.set('2026-08-18', 'chart-a')
+    expect(calls).toBe(1)
+    expect(store.get()).toEqual({ key: '2026-08-18', source: 'chart-a' })
+
+    unsubscribe()
+    store.set('2026-08-19', 'chart-a')
+    expect(calls).toBe(1)
+  })
+
+  test('a redundant set does not notify — a re-hover of the same point costs no render', () => {
+    const store = createCursorStore()
+    let calls = 0
+    store.subscribe(() => {
+      calls++
+    })
+
+    store.set('2026-08-18', 'chart-a')
+    store.set('2026-08-18', 'chart-a')
+    expect(calls).toBe(1)
+  })
+
+  test('clearing returns the stable empty identity', () => {
+    const store = createCursorStore()
+    const before = store.get()
+    store.set('2026-08-18', 'chart-a')
+    store.set(null, null)
+    expect(store.get()).toBe(before)
+  })
+
+  test('scoped stores are independent of the global one', () => {
+    const scoped = createCursorStore()
+    scoped.set('2026-08-18', 'chart-a')
+    expect(globalCursorStore.get().key).toBeNull()
+  })
+})

package/src/charts/cursor/store.ts

@@ -0,0 +1,53 @@
+/**
+ * The shared chart cursor — an external store, not a React context value.
+ *
+ * Sharing used to require a `ChartHoverSync` ancestor, so it was opt-in and silently absent
+ * whenever someone forgot the wrapper. This inverts that: a module-level store means every
+ * chart on the page shares a cursor by default, and `ChartCursorScope` exists to ISOLATE a
+ * subtree (`docs/CHARTS-SPEC.md` §3). Charts with non-overlapping domains never resolve each
+ * other's keys, so "shared by default" cannot produce a false cursor.
+ *
+ * External store rather than context for a second reason: a cursor move re-renders only the
+ * charts subscribed to it, instead of every descendant of a provider whose value object is new
+ * on each pointer frame.
+ */
+
+/** Broadcast cursor position: an opaque domain key plus the chart that owns it. */
+export type CursorState = {
+  /** The hovered x-domain key (a date/category string), or null when nothing is hovered. */
+  key: string | null
+  /** `chartId` of the chart the pointer is actually over — the one that owns the tooltip. */
+  source: string | null
+}
+
+export type CursorStore = {
+  get: () => CursorState
+  set: (key: string | null, source: string | null) => void
+  subscribe: (onChange: () => void) => () => void
+}
+
+/** Stable identity for "nothing hovered" — also the SSR snapshot, so it must never be recreated. */
+export const EMPTY_CURSOR: CursorState = { key: null, source: null }
+
+export function createCursorStore(): CursorStore {
+  let state: CursorState = EMPTY_CURSOR
+  const listeners = new Set<() => void>()
+
+  return {
+    get: () => state,
+    set: (key, source) => {
+      if (state.key === key && state.source === source) return
+      state = key === null && source === null ? EMPTY_CURSOR : { key, source }
+      for (const listener of listeners) listener()
+    },
+    subscribe: (onChange) => {
+      listeners.add(onChange)
+      return () => {
+        listeners.delete(onChange)
+      }
+    },
+  }
+}
+
+/** The default store every chart shares unless a `ChartCursorScope` overrides it. */
+export const globalCursorStore: CursorStore = createCursorStore()

package/src/charts/hooks/useChartCursor.ts

@@ -0,0 +1,163 @@
+import { localPoint } from '@visx/event'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import type { KeyboardEvent, PointerEvent } from 'react'
+import { buildDomainIndex, resolveCursorPoint } from '../cursor/resolve'
+import { useCursorState, useCursorStore } from '../cursor/scope'
+
+/** Viewport-space pointer anchor the tooltip positions against. */
+export type CursorAnchor = { x: number; y: number }
+
+export type ChartCursor<T> = {
+  /** The point this chart paints its crosshair + dots at — own hover, or a resolved sibling key. */
+  point: T | null
+  /** True when the pointer is over THIS chart. Only the source chart shows the floating tooltip. */
+  isSource: boolean
+  /** Latest pointer position in viewport coords, or null when not hovered. */
+  anchor: CursorAnchor | null
+  onPointerMove: (event: PointerEvent<SVGRectElement>) => void
+  onPointerLeave: () => void
+  onKeyDown: (event: KeyboardEvent<SVGRectElement>) => void
+  onBlur: () => void
+}
+
+/**
+ * Wires a chart into the ambient cursor store: snaps the pointer to the nearest own point,
+ * broadcasts it, and reads back a sibling's broadcast through domain-aware resolution. Replaces
+ * the removed `useHoverSync` + `useChartTooltip` pair, including their `resolveKey` escape hatch —
+ * resolution is now automatic.
+ *
+ * The tooltip anchor is coalesced through `requestAnimationFrame`, so a fast scrub costs one local
+ * state write per frame instead of one per event. The BROADCAST is not rAF-gated — it is deduped
+ * instead (the store ignores a set that doesn't change the value), so a scrub within one x-bucket
+ * costs nothing while a real bucket change reaches siblings on the same tick rather than a frame
+ * late.
+ */
+export function useChartCursor<T>({
+  data,
+  chartId,
+  getKey,
+  xScale,
+  marginLeft,
+}: {
+  data: readonly T[]
+  chartId: string
+  getKey: (d: T) => string
+  /** Own x scale — maps a domain key to a plot-local x offset. */
+  xScale: (key: string) => number | undefined
+  marginLeft: number
+}): ChartCursor<T> {
+  const store = useCursorStore()
+  const cursor = useCursorState()
+  const [anchor, setAnchor] = useState<CursorAnchor | null>(null)
+
+  // Accessors read through refs so the pointer callbacks stay referentially stable: the natural
+  // call style is an inline arrow, fresh every render, and re-creating these would re-bind the
+  // overlay's listeners on every cursor frame in every sibling chart.
+  const getKeyRef = useRef(getKey)
+  getKeyRef.current = getKey
+  const xScaleRef = useRef(xScale)
+  xScaleRef.current = xScale
+
+  const index = useMemo(() => buildDomainIndex(data, getKeyRef.current), [data])
+
+  const frameRef = useRef<number | null>(null)
+  const pendingRef = useRef<CursorAnchor | null>(null)
+  useEffect(
+    () => () => {
+      if (frameRef.current !== null) cancelAnimationFrame(frameRef.current)
+      // Release the shared cursor if this chart still owns it. Unmounting while hovered (a filter
+      // drops the chart, a tab switches) fires no leave/blur, so the store would keep pointing at
+      // a dead chartId — and any sibling whose domain resolves that stale key would paint a ghost
+      // crosshair with no way to clear it. Same ownership guard as `clear()`.
+      if (store.get().source === chartId) store.set(null, null)
+    },
+    [store, chartId],
+  )
+
+  const scheduleAnchor = useCallback((next: CursorAnchor) => {
+    pendingRef.current = next
+    if (frameRef.current !== null) return
+    frameRef.current = requestAnimationFrame(() => {
+      frameRef.current = null
+      setAnchor(pendingRef.current)
+    })
+  }, [])
+
+  const onPointerMove = useCallback(
+    (event: PointerEvent<SVGRectElement>) => {
+      if (data.length === 0) return
+      // Explicit reference node: `localPoint(event)` resolves it from `event.target`, which is the
+      // overlay rect only while the overlay is genuinely the topmost hit element. Passing
+      // `currentTarget` pins the coordinate space to the overlay regardless of what a kind draws
+      // above it.
+      const local = localPoint(event.currentTarget, event.nativeEvent)
+      if (local === null) return
+      const px = local.x - marginLeft
+
+      let closest = data[0] as T
+      let minDist = Infinity
+      for (const d of data) {
+        const x = xScaleRef.current(getKeyRef.current(d)) ?? 0
+        const dist = Math.abs(x - px)
+        if (dist < minDist) {
+          minDist = dist
+          closest = d
+        }
+      }
+
+      scheduleAnchor({ x: event.clientX, y: event.clientY })
+      store.set(getKeyRef.current(closest), chartId)
+    },
+    [data, marginLeft, chartId, store, scheduleAnchor],
+  )
+
+  const clear = useCallback(() => {
+    if (frameRef.current !== null) {
+      cancelAnimationFrame(frameRef.current)
+      frameRef.current = null
+    }
+    pendingRef.current = null
+    setAnchor(null)
+    // Only clear the SHARED cursor if this chart still owns it: moving fast from chart A to B lets
+    // A's leave fire after B's move, and an unconditional clear would wipe B's cursor.
+    if (store.get().source === chartId) store.set(null, null)
+  }, [store, chartId])
+
+  const onKeyDown = useCallback(
+    (event: KeyboardEvent<SVGRectElement>) => {
+      if (data.length === 0) return
+      if (event.key === 'Escape') {
+        clear()
+        return
+      }
+      const delta = event.key === 'ArrowRight' ? 1 : event.key === 'ArrowLeft' ? -1 : 0
+      if (delta === 0) return
+      event.preventDefault()
+
+      const current = store.get().key
+      const currentIndex = data.findIndex((d) => getKeyRef.current(d) === current)
+      const nextIndex = Math.min(
+        Math.max((currentIndex === -1 ? (delta > 0 ? -1 : data.length) : currentIndex) + delta, 0),
+        data.length - 1,
+      )
+      const next = data[nextIndex] as T
+      const rect = event.currentTarget.getBoundingClientRect()
+      const x = xScaleRef.current(getKeyRef.current(next)) ?? 0
+      scheduleAnchor({ x: rect.left + x, y: rect.top })
+      store.set(getKeyRef.current(next), chartId)
+    },
+    [data, store, chartId, clear, scheduleAnchor],
+  )
+
+  const point = cursor.key === null ? null : resolveCursorPoint(index, cursor.key)
+
+  return {
+    point,
+    isSource: cursor.source === chartId,
+    anchor,
+    onPointerMove,
+    onPointerLeave: clear,
+    onKeyDown,
+    onBlur: clear,
+  }
+}

package/src/charts/hooks/useChartSize.ts

@@ -15,12 +15,16 @@ export type UseChartSizeResult = ChartSize & {
  * A thin basalt wrapper over `@visx/responsive`'s `useParentSize` — keeps the
  * `@visx/*` import inside `src/charts/**` per the Mantine-free boundary rule.
  *
+ * Charts do not call this directly — `ChartFrame` (and `CartesianChart` above it) measure for
+ * them, including the legend band. Reach for it when something OUTSIDE the chart system needs a
+ * measured box, e.g. sizing a sparkline to its table cell.
+ *
  * @example
- * function MyChart() {
- *   const { ref, width, height } = useChartSize()
+ * function CellSparkline({ points }: { points: number[] }) {
+ *   const { ref, width } = useChartSize()
  *   return (
- *     <div ref={ref} style={{ width: '100%', height: 240 }}>
- *       {width > 0 && <Bars width={width} height={height} ... />}
+ *     <div ref={ref} style={{ width: '100%', height: 24 }}>
+ *       {width > 0 && <LineSparkline data={points} width={width} height={24} />}
  *     </div>
  *   )
  * }