basalt-ui 1.14.0 → 1.15.0

package/src/charts/series.ts

@@ -43,6 +43,8 @@ export type ChartLegendConfig = {
   groups?: boolean
   /** Wrap cap → "+N more" rollup at high cardinality. */
   maxRows?: number
+  /** Clicking an entry hides that series. Default: on whenever there is more than one entry. */
+  toggle?: boolean
 }
 
 /** Visual identity of a series — everything the legend + tooltip swatch need. No accessors, no `T`. */
@@ -58,12 +60,24 @@ export type SeriesStyle = {
   strokeWidth?: number
   /** bar/area: the swatch honors this so it cannot lie. */
   fillOpacity?: number
+  /** Which y-axis this series is measured against. Default 'left'. `'right'` is what makes a
+   * chart dual-axis — `CartesianChart` reads it for the crosshair dots and the tooltip. */
+  axis?: 'left' | 'right'
   /** Default 'series'. */
   role?: SeriesRole
   /** Default true; false = companion folded under `parent`. */
   legend?: boolean
+  /**
+   * Default true; false = drawn and legended, but NEVER listed as a tooltip row. The replacement
+   * for the per-kind `hideBarTooltipRows` escape the old layer had: it belongs to the series, not to the kind, so
+   * one series can opt out without the kind growing a prop for it.
+   */
+  tooltip?: boolean
   /** e.g. an MA line names its parent so hover-dimming keeps the pair. */
   parent?: string
+  /** Short qualifier rendered after the label in muted text — e.g. a flat-at-zero series that is
+   * invisible in the plot. */
+  note?: string
 }
 
 /** Full descriptor = visual identity + data accessors. Generic over the point type. */
@@ -99,6 +113,7 @@ function legendEntryFor(s: SeriesStyle): LegendEntry {
     ...(s.strokeWidth !== undefined && { strokeWidth: s.strokeWidth }),
     ...(s.fillOpacity !== undefined && { fillOpacity: s.fillOpacity }),
     ...(s.role !== undefined && { role: s.role }),
+    ...(s.note !== undefined && { note: s.note }),
   }
 }
 
@@ -136,7 +151,8 @@ export function deriveLegend(series: readonly SeriesStyle[]): LegendEntry[] {
 
 /**
  * Derive tooltip rows from a series descriptor array + the hovered datum. Skips rows where
- * `getValue(datum) === null`; honors per-series `formatValue` over the shared `fallbackFormat`.
+ * `getValue(datum) === null` or `tooltip === false`; honors per-series `formatValue` over the
+ * shared `fallbackFormat`.
  * Kinds pass `series.toReversed()` for stacked charts so the tooltip stack matches the visual stack.
  */
 export function deriveTooltipRows<T>(
@@ -146,6 +162,7 @@ export function deriveTooltipRows<T>(
 ): TooltipRowData[] {
   const rows: TooltipRowData[] = []
   for (const s of series) {
+    if (s.tooltip === false) continue
     const value = s.getValue(datum)
     if (value === null) continue
     const format = s.formatValue ?? fallbackFormat

package/src/charts/utils/measure-text.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'bun:test'
+import { maxTextWidth, measureText, resetTextMetrics } from './measure-text'
+
+describe('measureText', () => {
+  test('width grows with the string and with the font size', () => {
+    resetTextMetrics()
+    expect(measureText('1,250,000', 11)).toBeGreaterThan(measureText('0', 11))
+    expect(measureText('0', 22)).toBeGreaterThan(measureText('0', 11))
+  })
+
+  test('an empty string measures zero', () => {
+    expect(measureText('', 11)).toBe(0)
+  })
+
+  test('repeated measurement is stable — the memo cannot return a different width', () => {
+    resetTextMetrics()
+    const first = measureText('2026-08-18', 11)
+    expect(measureText('2026-08-18', 11)).toBe(first)
+  })
+
+  test('the same text at a different size is NOT a cache hit', () => {
+    resetTextMetrics()
+    expect(measureText('88', 11)).not.toBe(measureText('88', 30))
+  })
+})
+
+describe('maxTextWidth', () => {
+  test('returns 0 for no labels — an axis with no ticks reserves nothing extra', () => {
+    expect(maxTextWidth([], 11)).toBe(0)
+  })
+
+  test('returns the widest label, not the last', () => {
+    const labels = ['1', '1,250,000', '25']
+    expect(maxTextWidth(labels, 11)).toBe(measureText('1,250,000', 11))
+  })
+})

package/src/charts/utils/measure-text.ts

@@ -0,0 +1,109 @@
+/**
+ * Text measurement for chart layout — the input to {@link autoMargin}.
+ *
+ * A static margin token cannot know how wide a tick label is, which is why charts used to have to be
+ * hand-nudged whenever a label grew (`docs/CHARTS-SPEC.md` §1). This measures the strings that
+ * will actually be painted, via an OFFSCREEN canvas 2D context: no element is attached, so there
+ * is no layout thrash and no reflow — unlike an SVG `getBBox()` probe.
+ *
+ * Mantine-free and dependency-free by construction (`charts/**` boundary).
+ */
+
+/** Fallback advance width per character, as a fraction of the font size, when no DOM is
+ * available (SSR, `renderToStaticMarkup`). Mono faces sit near 0.6em; being deterministic matters
+ * more than being exact, since the measured value is only ever a floor-raiser. */
+const FALLBACK_CHAR_RATIO = 0.6
+
+/** Last-resort family when the `--basalt-font-mono` custom property cannot be read. */
+const FALLBACK_MONO = 'ui-monospace, SFMono-Regular, Menlo, monospace'
+
+/**
+ * Cap on the memo table. Tick labels are low-cardinality per chart, but a long-lived SPA with a
+ * live counter or currency axis mints a new string every update, and an unbounded module-level Map
+ * would then grow for the life of the tab. On overflow the whole table is dropped rather than
+ * evicted one by one: the working set is tiny and re-measuring it costs microseconds, so an LRU's
+ * bookkeeping would cost more than the misses it avoids.
+ */
+const CACHE_LIMIT = 2000
+
+const cache = new Map<string, number>()
+
+let ctx: CanvasRenderingContext2D | null | undefined
+let monoFamily: string | undefined
+
+function canvasContext(): CanvasRenderingContext2D | null {
+  if (ctx !== undefined) return ctx
+  if (typeof document === 'undefined') {
+    ctx = null
+    return ctx
+  }
+  ctx = document.createElement('canvas').getContext('2d')
+  // Webfonts swap in after first paint; measurements taken against the fallback face would then
+  // be stale (usually too narrow). Drop the cache once, when the real faces are ready.
+  // `?.` on every hop: a non-browser DOM harness can expose `document` with no `fonts`, or a
+  // `fonts` with no `ready` — neither is a reason to fail a measurement.
+  document.fonts?.ready?.then?.(() => cache.clear()).catch(() => {})
+  return ctx
+}
+
+/**
+ * The resolved value of `--basalt-font-mono` — canvas needs a concrete family list, it cannot
+ * resolve a CSS custom property. Read once from the document element.
+ */
+export function monoFontFamily(): string {
+  if (monoFamily !== undefined) return monoFamily
+  if (typeof document === 'undefined' || typeof getComputedStyle !== 'function') {
+    monoFamily = FALLBACK_MONO
+    return monoFamily
+  }
+  const value = getComputedStyle(document.documentElement)
+    .getPropertyValue('--basalt-font-mono')
+    .trim()
+  monoFamily = value.length > 0 ? value : FALLBACK_MONO
+  return monoFamily
+}
+
+/**
+ * Width in px of `text` at `fontPx` in the chart tick font. Memoized per `font|text` — a chart
+ * re-measures the same ~10 tick labels on every resize, and the cache turns that into a Map hit.
+ */
+export function measureText(text: string, fontPx: number, fontFamily?: string): number {
+  const family = fontFamily ?? monoFontFamily()
+  const font = `${fontPx}px ${family}`
+  const key = `${font}|${text}`
+  const hit = cache.get(key)
+  if (hit !== undefined) return hit
+
+  const c = canvasContext()
+  let width: number
+  if (c === null) {
+    width = text.length * fontPx * FALLBACK_CHAR_RATIO
+  } else {
+    c.font = font
+    width = c.measureText(text).width
+  }
+  if (cache.size >= CACHE_LIMIT) cache.clear()
+  cache.set(key, width)
+  return width
+}
+
+/** Widest of `texts` at `fontPx`. Returns 0 for an empty list. */
+export function maxTextWidth(
+  texts: readonly string[],
+  fontPx: number,
+  fontFamily?: string,
+): number {
+  let max = 0
+  for (const text of texts) {
+    const width = measureText(text, fontPx, fontFamily)
+    if (width > max) max = width
+  }
+  return max
+}
+
+/** Test seam — drops the memo table (and the resolved family) so a test can change fonts. */
+export function resetTextMetrics(): void {
+  cache.clear()
+  ctx = undefined
+  monoFamily = undefined
+}

package/src/content/fence-block.tsx

@@ -139,9 +139,8 @@ function lookupFenceRenderer(
 
 // ── Throw containment ────────────────────────────────────────────────────────────────────────────
 
-/** A `useRef(false)` handle, mutated in place — same per-instance "warn once" idiom as
- * `useHoverSync`'s `warnedRef` (`charts/hooks/useHoverSync.ts`) rather than a module-level
- * singleton: a singleton would make the FIRST fence anywhere in the process to throw silence the
+/** A `useRef(false)` handle, mutated in place — a per-instance "warn once" gate rather than a
+ * module-level singleton: a singleton would make the FIRST fence anywhere in the process to throw silence the
  * warning for every OTHER, unrelated broken fence for the rest of the run (and, worse, for every
  * later test in this suite — this file has module-singleton order-dependence history). Scoping the
  * gate to one `FenceBlock`'s `useRef` means each rendered fence position gets its own warning, reset

package/src/surfaces.ts

@@ -211,7 +211,8 @@ export const SURFACES = {
     rule: 'charts',
     skill: ['basalt-charts'],
     guardKinds: ['raw-hex', 'raw-color-fn', 'raw-visx-axis', 'unframed-chart'],
-    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)',
     globs: {
       shipped: ['**/charts/**'],
       repo: ['packages/basalt-ui/src/charts/**'],

package/src/theme/spacing.test.ts

@@ -369,6 +369,7 @@ const SPACE_STEP_SWEEP: ReadonlyArray<
   ['chartLegendGap', 22, null],
   ['chartMarginTop', 12, null],
   ['chartMarginRight', 16, null],
+  ['chartMarginRightAxis', 40, null],
   ['chartMarginBottom', 30, null],
   ['chartMarginLeft', 44, null],
   ['chartDotR', 5, null],
@@ -406,6 +407,7 @@ describe('SPACE_STEP CSS-module spacing-sweep one-offs match the shipped identit
       'chartLegendGap',
       'chartMarginTop',
       'chartMarginRight',
+      'chartMarginRightAxis',
       'chartMarginBottom',
       'chartMarginLeft',
       'chartDotR',

package/src/tokens/chart-margin.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from 'bun:test'
+import { chartMargin, VX } from './index'
+
+describe('chartMargin', () => {
+  test('a bare call deep-equals VX.margin', () => {
+    expect(chartMargin()).toEqual(VX.margin)
+  })
+
+  test('{ rightAxis: true } widens right to the right-axis minimum', () => {
+    expect(chartMargin({ rightAxis: true })).toEqual({
+      ...VX.margin,
+      right: 40,
+    })
+  })
+
+  test('{ rightAxis: false } (or omitted) leaves right at VX.margin.right', () => {
+    expect(chartMargin({ rightAxis: false })).toEqual(VX.margin)
+  })
+
+  test('an explicit right overrides the rightAxis-widened value', () => {
+    expect(chartMargin({ rightAxis: true, right: 12 })).toEqual({
+      ...VX.margin,
+      right: 12,
+    })
+  })
+
+  test('explicit sides override their VX.margin defaults independently', () => {
+    expect(chartMargin({ top: 1, left: 2 })).toEqual({
+      top: 1,
+      right: VX.margin.right,
+      bottom: VX.margin.bottom,
+      left: 2,
+    })
+  })
+
+  test('returns a new object each call', () => {
+    expect(chartMargin()).not.toBe(chartMargin())
+  })
+})

package/src/tokens/density.test.ts

@@ -242,6 +242,7 @@ describe('buildDensityCss', () => {
       'space-chart-legend-gap', // VX.legendGap / VX.margin / VX.dotR — visx SVG props
       'space-chart-margin-top',
       'space-chart-margin-right',
+      'space-chart-margin-right-axis',
       'space-chart-margin-bottom',
       'space-chart-margin-left',
       'space-chart-dot-r',

package/src/tokens/index.ts

@@ -241,6 +241,42 @@ export const VX = {
   minPxPerTick: 55,
 } as const
 
+/** Resolved chart plot-area margins — the return shape of {@link chartMargin}. */
+export type ChartMargin = { top: number; right: number; bottom: number; left: number }
+
+/**
+ * Chart plot-area margins — `VX.margin` widened for an `AxisRightNumeric`'s tick labels, and/or
+ * overridden per side. A token can't express "only when a right axis is rendered", so this is a
+ * function, not a second static token — also the seam that could one day track `density`
+ * (`VX.margin` itself is frozen at the level-0 snapshot; see `deriveSpacing`'s JSDoc).
+ *
+ * Law, applied in this order: start from `VX.margin`; when `rightAxis` is true, widen `right` to
+ * `Math.max(VX.margin.right, <right-axis minimum>)` (`SPACE_STEP.chartMarginRightAxis`); then any
+ * explicitly passed side wins last (including overriding `rightAxis`'s widened `right`).
+ * `chartMargin()` with no args deep-equals `VX.margin`.
+ *
+ * Returns a NEW object every call — memoize at the call site (`useMemo`), the same way `Bars`
+ * already memoizes its own margin.
+ */
+export function chartMargin(opts?: {
+  /** Reserve room for an `AxisRightNumeric`'s tick labels. */
+  rightAxis?: boolean
+  top?: number
+  right?: number
+  bottom?: number
+  left?: number
+}): ChartMargin {
+  const widenedRight = opts?.rightAxis
+    ? Math.max(VX.margin.right, SPACE_STEP.chartMarginRightAxis)
+    : VX.margin.right
+  return {
+    top: opts?.top ?? VX.margin.top,
+    right: opts?.right ?? widenedRight,
+    bottom: opts?.bottom ?? VX.margin.bottom,
+    left: opts?.left ?? VX.margin.left,
+  }
+}
+
 type Side = 'light' | 'dark'
 
 /** A CSS declaration line for a single `--vx-*` custom property. */

package/src/tokens/palette.ts

@@ -620,6 +620,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/dist/charts/hooks/useChartTooltip.d.ts

@@ -1,13 +0,0 @@
-export type TooltipState<T> = {
-    data: T;
-    x: number;
-    y: number;
-} | null;
-export declare function useChartTooltip<T>(): {
-    tip: TooltipState<T>;
-    show: (data: T, event: React.MouseEvent) => void;
-    hide: () => void;
-    tooltipRef: import("react").RefObject<HTMLDivElement | null>;
-    lastDateRef: import("react").RefObject<string | null>;
-};
-//# sourceMappingURL=useChartTooltip.d.ts.map

package/dist/charts/hooks/useChartTooltip.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useChartTooltip.d.ts","sourceRoot":"","sources":["../../../src/charts/hooks/useChartTooltip.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,CAAC,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAA;AAEtE,wBAAgB,eAAe,CAAC,CAAC;;iBAKC,CAAC,SAAS,KAAK,CAAC,UAAU;;;;EAqB3D"}

package/dist/charts/hooks/useChartTooltip.js

@@ -1,26 +0,0 @@
-import { useCallback, useRef, useState } from "react";
-function useChartTooltip() {
-  const [tip, setTip] = useState(null);
-  const tooltipRef = useRef(null);
-  const lastDateRef = useRef(null);
-  const show = useCallback((data, event) => {
-    const el = tooltipRef.current;
-    const width = el?.offsetWidth ?? 0;
-    const height = el?.offsetHeight ?? 0;
-    const margin = 8;
-    const vw = window.innerWidth;
-    const vh = window.innerHeight;
-    const overflowsRight = event.clientX + 12 + width + margin > vw;
-    const x = overflowsRight ? Math.max(margin, event.clientX - 12 - width) : event.clientX + 12;
-    const y = Math.min(Math.max(margin, event.clientY - 12), vh - height - margin);
-    setTip({ data, x, y });
-  }, []);
-  const hide = useCallback(() => {
-    setTip(null);
-    lastDateRef.current = null;
-  }, []);
-  return { tip, show, hide, tooltipRef, lastDateRef };
-}
-export {
-  useChartTooltip
-};

package/dist/charts/hooks/useHoverSync.d.ts

@@ -1,46 +0,0 @@
-type XScale = (x: string) => number | undefined;
-/**
- * Wires a chart into the shared-cursor HoverContext plus the local tooltip state.
- *
- * Returns everything a chart needs to:
- *   - snap mouse position to the nearest data point (by x-category)
- *   - broadcast that hover to other charts via HoverContext
- *   - read back hover from other charts (for ghost crosshair + dot)
- *   - drive its local tooltip
- *
- * Every non-sparkline chart kind MUST use this hook. Do not reimplement the
- * closest-point loop inline — drift across 15+ charts is the exact problem
- * this hook prevents.
- */
-export declare function useHoverSync<T>({ data, chartId, getKey, xScale, marginLeft, resolveKey, }: {
-    data: T[];
-    chartId: string;
-    getKey: (d: T) => string;
-    xScale: XScale;
-    marginLeft: number;
-    /**
-     * Overrides how a SIBLING's broadcast key resolves to one of THIS chart's own points. Only
-     * affects reading another chart's hover — this chart's own hover (via `getKey`/`xScale`) is
-     * untouched.
-     *
-     * Cross-chart sync is exact string match by default (`pointByKey.get(ctx.key)`), so two charts
-     * share a cursor only if they emit identical key strings. A chart that downsamples/folds its
-     * domain to fit a narrow viewport (e.g. ~288 buckets folded into ~97 columns at 390px) no longer
-     * owns most of the keys its unfolded siblings broadcast — the shared crosshair then appears on
-     * roughly one hover in three, with no rule a reader can infer, which is worse than no shared
-     * cursor at all. Pass `resolveKey` to map a foreign key onto whichever of this chart's own points
-     * swallowed it (e.g. the folded bucket the key falls into).
-     *
-     * Omit it and behaviour is byte-identical to today.
-     */
-    resolveKey?: (key: string) => T | null;
-}): {
-    tip: import("./useChartTooltip.js").TooltipState<T>;
-    tooltipRef: import("react").RefObject<HTMLDivElement | null>;
-    syncedPoint: T | null;
-    isDirectHover: boolean;
-    handleMouse: (event: React.MouseEvent<SVGRectElement>) => void;
-    handleLeave: () => void;
-};
-export {};
-//# sourceMappingURL=useHoverSync.d.ts.map

package/dist/charts/hooks/useHoverSync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHoverSync.d.ts","sourceRoot":"","sources":["../../../src/charts/hooks/useHoverSync.ts"],"names":[],"mappings":"AAKA,KAAK,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAC9B,IAAI,EACJ,OAAO,EACP,MAAM,EACN,MAAM,EACN,UAAU,EACV,UAAU,GACX,EAAE;IACD,IAAI,EAAE,CAAC,EAAE,CAAA;IACT,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;;;;;;;;;OAcG;IACH,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,IAAI,CAAA;CACvC;;;;;yBA6CW,KAAK,CAAC,UAAU,CAAC,cAAc,CAAC;;EAyD3C"}

package/dist/charts/hooks/useHoverSync.js

@@ -1,75 +0,0 @@
-import { localPoint } from "@visx/event";
-import { useCallback, useContext, useMemo, useRef } from "react";
-import { DEFAULT_NO_OP_SET_HOVER, HoverContext } from "../hover-context.js";
-import { useChartTooltip } from "./useChartTooltip.js";
-function useHoverSync({
-  data,
-  chartId,
-  getKey,
-  xScale,
-  marginLeft,
-  resolveKey
-}) {
-  const ctx = useContext(HoverContext);
-  const ctxRef = useRef(ctx);
-  ctxRef.current = ctx;
-  const warnedRef = useRef(false);
-  if (process.env["NODE_ENV"] !== "production" && ctx.setHover === DEFAULT_NO_OP_SET_HOVER && !warnedRef.current) {
-    warnedRef.current = true;
-    console.warn(
-      "[charts] useHoverSync used outside <HoverContext.Provider>. Cross-chart cursor sync will not work."
-    );
-  }
-  const { tip, show, hide, tooltipRef, lastDateRef } = useChartTooltip();
-  const getKeyRef = useRef(getKey);
-  getKeyRef.current = getKey;
-  const xScaleRef = useRef(xScale);
-  xScaleRef.current = xScale;
-  const pointByKey = useMemo(() => {
-    const m = /* @__PURE__ */ new Map();
-    for (const d of data) m.set(getKeyRef.current(d), d);
-    return m;
-  }, [data]);
-  const handleMouse = useCallback(
-    (event) => {
-      const point = localPoint(event);
-      if (!point || data.length === 0) return;
-      const px = point.x - marginLeft;
-      let closest = data[0];
-      let minDist = Infinity;
-      for (const d of data) {
-        const sx = xScaleRef.current(getKeyRef.current(d)) ?? 0;
-        const dist = Math.abs(sx - px);
-        if (dist < minDist) {
-          minDist = dist;
-          closest = d;
-        }
-      }
-      show(closest, event);
-      const key = getKeyRef.current(closest);
-      if (lastDateRef.current !== key) {
-        lastDateRef.current = key;
-        ctxRef.current.setHover(key, chartId);
-      }
-    },
-    [data, chartId, marginLeft, show, lastDateRef]
-  );
-  const handleLeave = useCallback(() => {
-    hide();
-    if (ctxRef.current.source === chartId) ctxRef.current.setHover(null, null);
-  }, [hide, chartId]);
-  const syncedPoint = ctx.key ? resolveKey ? resolveKey(ctx.key) : pointByKey.get(ctx.key) ?? null : tip?.data ?? null;
-  const hasProvider = ctx.setHover !== DEFAULT_NO_OP_SET_HOVER;
-  const isDirectHover = hasProvider ? ctx.source === chartId : tip !== null;
-  return {
-    tip,
-    tooltipRef,
-    syncedPoint,
-    isDirectHover,
-    handleMouse,
-    handleLeave
-  };
-}
-export {
-  useHoverSync
-};

package/dist/charts/hover-context.d.ts

@@ -1,21 +0,0 @@
-export type HoverCtx = {
-    key: string | null;
-    source: string | null;
-    setHover: (key: string | null, source: string | null) => void;
-};
-/**
- * Sentinel identity used as the default context's `setHover`. `useHoverSync` compares against it
- * (`ctx.setHover !== DEFAULT_NO_OP_SET_HOVER`) to decide whether a `ChartHoverSync` provider is
- * mounted — which is load-bearing, not just a dev warning: standalone charts (no provider) drive
- * their tooltip + crosshair from local hover, while inside a provider only the broadcast source
- * owns the tooltip. CONTRACT: a real provider MUST supply its own `setHover`, never re-use this
- * no-op (a provider that passes this sentinel would be (mis)read as "no provider").
- * Exported only for that identity check — do NOT call directly.
- */
-export declare const DEFAULT_NO_OP_SET_HOVER: HoverCtx['setHover'];
-/**
- * Shared-cursor context — charts write the hovered key (an opaque category/date string) + their
- * own chartId; other charts read and show a ghost crosshair + dot on the same key.
- */
-export declare const HoverContext: import("react").Context<HoverCtx>;
-//# sourceMappingURL=hover-context.d.ts.map

package/dist/charts/hover-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hover-context.d.ts","sourceRoot":"","sources":["../../src/charts/hover-context.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;CAC9D,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,UAAU,CAAY,CAAA;AAErE;;;GAGG;AACH,eAAO,MAAM,YAAY,mCAIvB,CAAA"}

package/dist/charts/hover-context.js

@@ -1,12 +0,0 @@
-import { createContext } from "react";
-const DEFAULT_NO_OP_SET_HOVER = () => {
-};
-const HoverContext = createContext({
-  key: null,
-  source: null,
-  setHover: DEFAULT_NO_OP_SET_HOVER
-});
-export {
-  DEFAULT_NO_OP_SET_HOVER,
-  HoverContext
-};

package/dist/charts/hover-sync.d.ts

@@ -1,14 +0,0 @@
-import type { ReactNode } from 'react';
-export type ChartHoverSyncProps = {
-    children: ReactNode;
-};
-/**
- * Activates the shared-cursor HoverContext: holds the hovered key (an opaque
- * category/date string) + source chartId in one place so every descendant
- * chart's `useHoverSync` reads and writes the same cursor. Hovering one chart
- * shows a ghost crosshair + dot on all sibling charts under this provider.
- *
- * Wrap a group of charts that should share a cursor in `<ChartHoverSync>`.
- */
-export declare function ChartHoverSync({ children }: ChartHoverSyncProps): import("react").JSX.Element;
-//# sourceMappingURL=hover-sync.d.ts.map

package/dist/charts/hover-sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hover-sync.d.ts","sourceRoot":"","sources":["../../src/charts/hover-sync.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAKtC,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA;AAOD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE,mBAAmB,+BAc/D"}

package/dist/charts/hover-sync.js

@@ -1,17 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { useCallback, useMemo, useState } from "react";
-import { HoverContext } from "./hover-context.js";
-function ChartHoverSync({ children }) {
-  const [hover, setHoverState] = useState({ key: null, source: null });
-  const setHover = useCallback((key, source) => {
-    setHoverState({ key, source });
-  }, []);
-  const value = useMemo(
-    () => ({ key: hover.key, source: hover.source, setHover }),
-    [hover.key, hover.source, setHover]
-  );
-  return /* @__PURE__ */ jsx(HoverContext.Provider, { value, children });
-}
-export {
-  ChartHoverSync
-};

package/dist/charts/primitives/ResponsiveChart.d.ts

@@ -1,45 +0,0 @@
-import type { ReactNode } from 'react';
-export type ResponsiveChartProps = {
-    /**
-     * Fixed height in pixels. Used when `aspectRatio` is not set. Default 240.
-     * Ignored when `aspectRatio` is set — height is derived from measured width.
-     */
-    height?: number;
-    /**
-     * When set, height = Math.round(width / aspectRatio) and `height` prop is ignored.
-     * E.g. `aspectRatio={16 / 9}` produces a 16:9 panel.
-     */
-    aspectRatio?: number;
-    /** ResizeObserver debounce in milliseconds. Default 0 (immediate). */
-    debounceMs?: number;
-    /**
-     * Accessible text alternative for the chart, applied as `aria-label` (+ `role="img"`) on the
-     * outer measuring container — e.g. when wrapping `Heatmap`, which measures via this primitive
-     * rather than `ChartFrame`.
-     */
-    ariaLabel?: string;
-    /** Render prop — called with the measured `{ width, height }`. */
-    children: (size: {
-        width: number;
-        height: number;
-    }) => ReactNode;
-};
-/**
- * Render-prop container that measures its own width and derives a final height
- * from `height` (default 240) or `aspectRatio`. Renders nothing until the first
- * measurement arrives (`width > 0`). Backed by `@visx/responsive`'s `useParentSize`.
- *
- * @example
- * <ResponsiveChart height={320}>
- *   {({ width, height }) => (
- *     <Bars width={width} height={height} data={data} ... />
- *   )}
- * </ResponsiveChart>
- *
- * @example aspectRatio
- * <ResponsiveChart aspectRatio={16 / 9}>
- *   {({ width, height }) => <MyChart width={width} height={height} />}
- * </ResponsiveChart>
- */
-export declare function ResponsiveChart({ height, aspectRatio, debounceMs, ariaLabel, children, }: ResponsiveChartProps): ReactNode;
-//# sourceMappingURL=ResponsiveChart.d.ts.map

package/dist/charts/primitives/ResponsiveChart.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ResponsiveChart.d.ts","sourceRoot":"","sources":["../../../src/charts/primitives/ResponsiveChart.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,kEAAkE;IAClE,QAAQ,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,SAAS,CAAA;CACjE,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,EAC9B,MAAY,EACZ,WAAW,EACX,UAAc,EACd,SAAS,EACT,QAAQ,GACT,EAAE,oBAAoB,GAAG,SAAS,CAclC"}