basalt-ui 1.27.0 → 1.28.0

package/src/charts/primitives/ChartCard.test.tsx

@@ -1,66 +0,0 @@
-/**
- * `ChartCard`'s header — the `''`-as-hidden-header sentinel is gone (docs/CONTROLS-SPEC.md §2.2):
- * the header now renders only when at least one of title/info/value/actions/icon/count is set.
- * Mantine-free (`src/charts/**`), so no `MantineProvider` wrapper is needed — mirrors
- * `ChartFrame.test.tsx`'s rationale.
- */
-import { render, screen } from '@testing-library/react'
-import { describe, expect, test } from 'bun:test'
-import { ChartCard } from './ChartCard'
-
-describe('the header renders only when it has something to show', () => {
-  test('nothing set — no heading at all', () => {
-    render(
-      <ChartCard>
-        <svg />
-      </ChartCard>,
-    )
-    expect(screen.queryByRole('heading')).toBeNull()
-  })
-
-  test('title alone renders the h3', () => {
-    render(
-      <ChartCard title="Revenue over time">
-        <svg />
-      </ChartCard>,
-    )
-    expect(screen.getByRole('heading', { level: 3, name: 'Revenue over time' })).toBeDefined()
-  })
-
-  test('count alone (no title) still renders the header, with an empty title', () => {
-    render(
-      <ChartCard count={4}>
-        <svg />
-      </ChartCard>,
-    )
-    expect(screen.getByText('4')).toBeDefined()
-  })
-
-  test('value alone renders the header', () => {
-    render(
-      <ChartCard value="$12,483">
-        <svg />
-      </ChartCard>,
-    )
-    expect(screen.getByText('$12,483')).toBeDefined()
-  })
-
-  test('actions alone renders the header, carrying data-basalt-tier="widget"', () => {
-    const { container } = render(
-      <ChartCard actions={<button type="button">Export</button>}>
-        <svg />
-      </ChartCard>,
-    )
-    expect(screen.getByRole('button', { name: 'Export' })).toBeDefined()
-    expect(container.querySelector('[data-basalt-tier="widget"]')).not.toBeNull()
-  })
-
-  test('subtitle alone does NOT render the header', () => {
-    render(
-      <ChartCard subtitle="Net revenue per day">
-        <svg />
-      </ChartCard>,
-    )
-    expect(screen.queryByText('Net revenue per day')).toBeNull()
-  })
-})

package/src/charts/primitives/ChartFrame.test.tsx

@@ -1,142 +0,0 @@
-/**
- * `ChartFrame`'s `isPending` invariant — the one behavior here that regresses silently. A pending
- * chart that quietly fell back to rendering its legend + body would put a densified "not measured"
- * shape back on screen exactly where `ChartPending` is supposed to reserve a static, contentless
- * placeholder (see `ChartPending`'s JSDoc for the three-state "nothing to draw" rationale).
- *
- * A DOM harness now exists (`tests/setup/dom.ts`, preloaded via the root `bunfig.toml`; see
- * `theme/use-basalt-spacing.test.tsx`'s doc) — `renderToStaticMarkup` is used deliberately here
- * instead: `ChartFrame`/`ChartPending` live in `src/charts/**`, which is Mantine-free, so no
- * `MantineProvider` wrapper is needed either. `useChartSize` never measures under SSR (no
- * `ResizeObserver`), so the plot rect falls back to `minWidth` × the resolved fixed height —
- * non-zero, which is what lets `children`/`ChartPending` render at all in this harness. Converting
- * to the DOM harness would only be worth it if a future assertion here needed a real measured size
- * (a live `ResizeObserver` reading) rather than this SSR fallback rect.
- */
-import { render } from '@testing-library/react'
-import { describe, expect, test } from 'bun:test'
-import { renderToStaticMarkup } from 'react-dom/server'
-import { ChartFrame } from './ChartFrame'
-import { HoverOverlay } from './HoverOverlay'
-import type { SeriesStyle } from '../series'
-
-const series: SeriesStyle[] = [{ key: 'a', label: 'Series A', color: '#000', mark: 'line' }]
-
-const CHART_BODY_MARKER = 'CHART_BODY_MARKER'
-
-function renderFrame(isPending: boolean): string {
-  return renderToStaticMarkup(
-    <ChartFrame series={series} legend={{}} isPending={isPending}>
-      {() => <svg>{CHART_BODY_MARKER}</svg>}
-    </ChartFrame>,
-  )
-}
-
-describe('a pending ChartFrame renders neither the legend nor the chart body', () => {
-  const markup = renderFrame(true)
-
-  test('the legend is absent — no series label anywhere in the markup', () => {
-    expect(markup).not.toContain('Series A')
-  })
-
-  test('the chart body (children) never runs', () => {
-    expect(markup).not.toContain(CHART_BODY_MARKER)
-  })
-
-  test('the outer container is marked aria-busy', () => {
-    expect(markup).toContain('aria-busy="true"')
-  })
-
-  test('the placeholder label renders in its place', () => {
-    expect(markup).toContain('Loading…')
-  })
-})
-
-describe('a non-pending ChartFrame is unaffected — the legend and body both render', () => {
-  const markup = renderFrame(false)
-
-  test('the legend renders the series label', () => {
-    expect(markup).toContain('Series A')
-  })
-
-  test('the chart body renders', () => {
-    expect(markup).toContain(CHART_BODY_MARKER)
-  })
-
-  test('no aria-busy attribute is present', () => {
-    expect(markup).not.toContain('aria-busy')
-  })
-})
-
-describe('ariaLabel: the label is announced WITHOUT swallowing the interactive slider', () => {
-  // The regression this guards: `role="img"` marks every descendant presentational per the ARIA
-  // spec, so a screen reader would announce the label and then never expose `HoverOverlay`'s
-  // `role="slider"` at all — the keyboard-scrubbable affordance becomes unreachable with no error
-  // anywhere. `role="group"` announces the same label while keeping descendants in the tree.
-  test('the outer container is role="group" with the label, never role="img"', () => {
-    const { container } = render(
-      <ChartFrame series={series} ariaLabel="Revenue over time" legend={false}>
-        {() => <svg />}
-      </ChartFrame>,
-    )
-    const outer = container.firstElementChild as HTMLElement
-    expect(outer.getAttribute('role')).toBe('group')
-    expect(outer.getAttribute('aria-label')).toBe('Revenue over time')
-    expect(container.querySelector('[role="img"]')).toBeNull()
-  })
-
-  test('the slider stays a reachable descendant of the labeled container', () => {
-    const { container } = render(
-      <ChartFrame series={series} ariaLabel="Revenue over time" legend={false}>
-        {() => (
-          <svg>
-            <HoverOverlay
-              width={100}
-              height={100}
-              onMove={() => {}}
-              onLeave={() => {}}
-              onKeyDown={() => {}}
-            />
-          </svg>
-        )}
-      </ChartFrame>,
-    )
-    const outer = container.firstElementChild as HTMLElement
-    expect(outer.getAttribute('role')).toBe('group')
-    const slider = outer.querySelector('[role="slider"]')
-    expect(slider).not.toBeNull()
-  })
-})
-
-const twoSeries: SeriesStyle[] = [
-  { key: 'a', label: 'Series A', color: '#000', mark: 'line' },
-  { key: 'b', label: 'Series B', color: '#111', mark: 'bar' },
-]
-
-describe('legend toggling', () => {
-  test('a multi-series legend is interactive by default', () => {
-    const markup = renderToStaticMarkup(<ChartFrame series={twoSeries}>{() => <svg />}</ChartFrame>)
-    expect(markup).toContain('aria-pressed="true"')
-  })
-
-  test('a single-series legend is not — hiding the only series a chart draws is never useful', () => {
-    const markup = renderToStaticMarkup(<ChartFrame series={series}>{() => <svg />}</ChartFrame>)
-    expect(markup).not.toContain('aria-pressed')
-  })
-
-  test('`toggle: false` opts out even with several series', () => {
-    const markup = renderToStaticMarkup(
-      <ChartFrame series={twoSeries} legend={{ toggle: false }}>
-        {() => <svg />}
-      </ChartFrame>,
-    )
-    expect(markup).not.toContain('aria-pressed')
-  })
-
-  test('the child receives the (initially empty) hidden set', () => {
-    const markup = renderToStaticMarkup(
-      <ChartFrame series={twoSeries}>{({ hidden }) => <svg>size:{hidden.size}</svg>}</ChartFrame>,
-    )
-    expect(markup).toContain('size:0')
-  })
-})

package/src/charts/primitives/ChartLegend.test.tsx

@@ -1,78 +0,0 @@
-/**
- * `ChartLegend` — the `note` qualifier. Same SSR harness as `ChartFrame.test.tsx`:
- * `src/charts/**` is Mantine-free, so `renderToStaticMarkup` needs no provider wrapper.
- */
-import { describe, expect, test } from 'bun:test'
-import { renderToStaticMarkup } from 'react-dom/server'
-import { ChartLegend } from './ChartLegend'
-import type { LegendEntry } from './ChartLegend'
-
-const BASE: LegendEntry = { key: 'cloud-low', label: 'Low cloud', color: 'var(--vx-fill-1)' }
-
-const render = (items: LegendEntry[]): string => renderToStaticMarkup(<ChartLegend items={items} />)
-
-describe('ChartLegend note', () => {
-  test('renders after the label when set', () => {
-    const markup = render([{ ...BASE, note: '0% all night' }])
-    expect(markup).toContain('Low cloud')
-    expect(markup).toContain('0% all night')
-  })
-
-  test('is absent when unset', () => {
-    expect(render([BASE])).not.toContain('<span style="opacity:0.75">')
-  })
-
-  test('an empty note renders no span (truthiness, not !== undefined)', () => {
-    expect(render([{ ...BASE, note: '' }])).not.toContain('<span style="opacity:0.75">')
-  })
-
-  test('reaches the accessible name — the explicit aria-label would otherwise replace it', () => {
-    const markup = render([{ ...BASE, note: '0% all night' }])
-    expect(markup).toContain('aria-label="Low cloud — 0% all night"')
-  })
-
-  test('aria-label stays the bare label when there is no note', () => {
-    expect(render([BASE])).toContain('aria-label="Low cloud"')
-  })
-
-  test('a folded companion carries its own note', () => {
-    const markup = render([
-      {
-        ...BASE,
-        children: [{ key: 'ma', label: '7d MA', color: 'var(--vx-fill-2)', note: 'est.' }],
-      },
-    ])
-    expect(markup).toContain('7d MA')
-    expect(markup).toContain('est.')
-  })
-})
-
-describe('ChartLegend strokeOpacity — the swatch cannot lie about a dimmed line', () => {
-  test('a line swatch honors a fractional strokeOpacity', () => {
-    const markup = render([{ ...BASE, shape: 'line', strokeOpacity: 0.4 }])
-    expect(markup).toContain('stroke-opacity="0.4"')
-  })
-
-  test('defaults to full opacity when unset', () => {
-    const markup = render([{ ...BASE, shape: 'line' }])
-    expect(markup).toContain('stroke-opacity="1"')
-  })
-
-  test('a folded MA-companion child swatch honors it too', () => {
-    const markup = render([
-      {
-        ...BASE,
-        children: [
-          {
-            key: 'ma',
-            label: '7d MA',
-            color: 'var(--vx-fill-2)',
-            shape: 'line',
-            strokeOpacity: 0.4,
-          },
-        ],
-      },
-    ])
-    expect(markup).toContain('stroke-opacity="0.4"')
-  })
-})

package/src/charts/primitives/ChartTooltip.test.tsx

@@ -1,44 +0,0 @@
-/**
- * `TooltipHeader` — the `format` seam that lets a caller override `fmtTooltipDate`. Added because
- * `fmtTooltipDate` regexes `YYYY-MM-DD` out of the key and builds a LOCAL `Date`, so a UTC ISO
- * domain key names the wrong day next to `formatX`/the tooltip badge, which both resolve locally.
- */
-import { render, screen } from '@testing-library/react'
-import { describe, expect, test } from 'bun:test'
-import { renderToStaticMarkup } from 'react-dom/server'
-import { ChartTooltipFloat, TooltipHeader } from './ChartTooltip'
-
-describe('TooltipHeader — format prop', () => {
-  test('defaults to fmtTooltipDate when omitted', () => {
-    const html = renderToStaticMarkup(<TooltipHeader date="2026-04-21" />)
-    expect(html).toContain('Tue Apr 21 2026')
-  })
-
-  test('a custom format overrides fmtTooltipDate entirely', () => {
-    const html = renderToStaticMarkup(
-      <TooltipHeader date="2026-04-21" format={(d) => `custom:${d}`} />,
-    )
-    expect(html).toContain('custom:2026-04-21')
-    expect(html).not.toContain('Tue Apr 21 2026')
-  })
-})
-
-describe('ChartTooltipFloat — ariaLive', () => {
-  test('defaults to an aria-live="polite" region', () => {
-    render(
-      <ChartTooltipFloat anchor={{ x: 10, y: 10 }}>
-        <span>content</span>
-      </ChartTooltipFloat>,
-    )
-    expect(screen.getByRole('tooltip').getAttribute('aria-live')).toBe('polite')
-  })
-
-  test('ariaLive: false drops the live-region attribute entirely — a follower is visual only', () => {
-    render(
-      <ChartTooltipFloat anchor={{ x: 10, y: 10 }} ariaLive={false}>
-        <span>content</span>
-      </ChartTooltipFloat>,
-    )
-    expect(screen.getByRole('tooltip').hasAttribute('aria-live')).toBe(false)
-  })
-})

package/src/charts/primitives/XZoneRects.test.tsx

@@ -1,123 +0,0 @@
-/**
- * `XZoneRects` — the x-analog of `ZoneRects`. Same SSR harness as `ChartFrame.test.tsx`:
- * `src/charts/**` is Mantine-free, so `renderToStaticMarkup` needs no provider wrapper.
- */
-import { scalePoint } from '@visx/scale'
-import { describe, expect, test } from 'bun:test'
-import { renderToStaticMarkup } from 'react-dom/server'
-import { XZoneRects } from './XZoneRects'
-import type { XZoneSpec } from './XZoneRects'
-
-const DOMAIN = ['a', 'b', 'c', 'd']
-const xScale = scalePoint<string>({ domain: DOMAIN, range: [0, 100], padding: 0.3 })
-
-function render(zones: XZoneSpec[]): string {
-  return renderToStaticMarkup(<XZoneRects zones={zones} height={50} xScale={xScale} />)
-}
-
-describe('XZoneRects', () => {
-  test('both bounds present -> rect spans center-to-center', () => {
-    const from = xScale('b') as number
-    const to = xScale('c') as number
-    const markup = render([{ from: 'b', to: 'c', fill: 'red' }])
-    expect(markup).toContain(`x="${from}"`)
-    expect(markup).toContain(`width="${to - from}"`)
-    expect(markup).toContain('height="50"')
-    expect(markup).toContain('fill="red"')
-  })
-
-  test('omitted from -> resolves to the plot left edge (0)', () => {
-    const to = xScale('b') as number
-    const [rangeStart] = xScale.range() as [number, number]
-    const markup = render([{ to: 'b', fill: 'red' }])
-    expect(markup).toContain(`x="${rangeStart}"`)
-    expect(markup).toContain(`width="${to - rangeStart}"`)
-  })
-
-  test('omitted to -> resolves to the plot right edge (xScale.range()[1])', () => {
-    const from = xScale('c') as number
-    const [, rangeEnd] = xScale.range() as [number, number]
-    const markup = render([{ from: 'c', fill: 'red' }])
-    expect(markup).toContain(`x="${from}"`)
-    expect(markup).toContain(`width="${rangeEnd - from}"`)
-  })
-
-  test('an unknown key skips the band entirely — no rect, no clamping to a plot edge', () => {
-    const markup = render([{ from: 'not-in-domain', to: 'c', fill: 'red' }])
-    expect(markup).not.toContain('<rect')
-  })
-
-  test('an inverted range (to before from) renders no rect', () => {
-    const markup = render([{ from: 'c', to: 'a', fill: 'red' }])
-    expect(markup).not.toContain('<rect')
-  })
-
-  test('a degenerate zero-width range (from === to) renders no rect', () => {
-    const markup = render([{ from: 'b', to: 'b', fill: 'red' }])
-    expect(markup).not.toContain('<rect')
-  })
-
-  test('an empty zones array renders no rects', () => {
-    expect(render([])).not.toContain('<rect')
-  })
-
-  // Mirrors XZoneRects' own bound resolution exactly (same clamp + sign math), so expectations
-  // never drift from the implementation's floating-point arithmetic.
-  function edgeBound(key: string, sign: 1 | -1): number {
-    const step = xScale.step()
-    const [rangeStart, rangeEnd] = xScale.range() as [number, number]
-    const rangeMin = Math.min(rangeStart, rangeEnd)
-    const rangeMax = Math.max(rangeStart, rangeEnd)
-    const center = xScale(key) as number
-    return Math.min(Math.max(center + sign * (step / 2), rangeMin), rangeMax)
-  }
-
-  test('align: "edge" widens a two-key band by exactly one step over center mode', () => {
-    const step = xScale.step()
-    const centerFrom = xScale('b') as number
-    const centerTo = xScale('c') as number
-    const centerMarkup = render([{ from: 'b', to: 'c', fill: 'red' }])
-    const edgeMarkup = render([{ from: 'b', to: 'c', fill: 'red', align: 'edge' }])
-    expect(centerMarkup).toContain(`width="${centerTo - centerFrom}"`)
-    const edgeFrom = edgeBound('b', -1)
-    const edgeTo = edgeBound('c', 1)
-    expect(edgeMarkup).toContain(`x="${edgeFrom}"`)
-    expect(edgeMarkup).toContain(`width="${edgeTo - edgeFrom}"`)
-    expect(edgeTo - edgeFrom).toBeCloseTo(centerTo - centerFrom + step, 10)
-  })
-
-  test('align: "edge" with from === to renders exactly one step wide, where center renders nothing', () => {
-    const step = xScale.step()
-    const centerMarkup = render([{ from: 'b', to: 'b', fill: 'red' }])
-    const edgeMarkup = render([{ from: 'b', to: 'b', fill: 'red', align: 'edge' }])
-    expect(centerMarkup).not.toContain('<rect')
-    const edgeFrom = edgeBound('b', -1)
-    const edgeTo = edgeBound('b', 1)
-    expect(edgeMarkup).toContain(`x="${edgeFrom}"`)
-    expect(edgeMarkup).toContain(`width="${edgeTo - edgeFrom}"`)
-    expect(edgeTo - edgeFrom).toBeCloseTo(step, 10)
-  })
-
-  test('an unknown key is skipped in both align modes', () => {
-    const centerMarkup = render([{ from: 'not-in-domain', to: 'c', fill: 'red' }])
-    const edgeMarkup = render([{ from: 'not-in-domain', to: 'c', fill: 'red', align: 'edge' }])
-    expect(centerMarkup).not.toContain('<rect')
-    expect(edgeMarkup).not.toContain('<rect')
-  })
-
-  test('align: "edge" clamps the widened left edge at the first sample into the plot range', () => {
-    const [rangeStart] = xScale.range() as [number, number]
-    const markup = render([{ from: 'a', to: 'a', fill: 'red', align: 'edge' }])
-    const edgeTo = edgeBound('a', 1)
-    expect(markup).toContain(`x="${rangeStart}"`)
-    expect(markup).toContain(`width="${edgeTo - rangeStart}"`)
-  })
-
-  test('align: "edge" clamps the widened right edge at the last sample into the plot range', () => {
-    const [, rangeEnd] = xScale.range() as [number, number]
-    const markup = render([{ from: 'd', to: 'd', fill: 'red', align: 'edge' }])
-    const edgeFrom = edgeBound('d', -1)
-    expect(markup).toContain(`x="${edgeFrom}"`)
-    expect(markup).toContain(`width="${rangeEnd - edgeFrom}"`)
-  })
-})

package/src/charts/series.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { deriveLegend, deriveTooltipRows } from './series'
-import type { SeriesStyle } from './series'
-
-const baseSeries: SeriesStyle = {
-  key: 'low-cloud',
-  label: 'Low cloud',
-  color: '#000',
-  mark: 'line',
-}
-
-describe('deriveLegend note passthrough', () => {
-  test('carries note through when set', () => {
-    const [entry] = deriveLegend([{ ...baseSeries, note: '0% all night' }])
-    expect(entry?.note).toBe('0% all night')
-  })
-
-  test('omits the note key entirely when unset', () => {
-    const [entry] = deriveLegend([baseSeries])
-    expect(entry).not.toHaveProperty('note')
-  })
-})
-
-describe('deriveTooltipRows', () => {
-  type Row = { v: number }
-  const base = { color: '#000', mark: 'bar' as const, getValue: (d: Row) => d.v }
-  const fmt = (v: number) => String(v)
-
-  test('a `tooltip: false` series is drawn and legended but produces no row', () => {
-    const rows = deriveTooltipRows(
-      [
-        { ...base, key: 'shown', label: 'Shown' },
-        { ...base, key: 'quiet', label: 'Quiet', tooltip: false },
-      ],
-      { v: 1 },
-      fmt,
-    )
-    expect(rows.map((r) => r.key)).toEqual(['shown'])
-    expect(deriveLegend([{ ...base, key: 'quiet', label: 'Quiet', tooltip: false }])).toHaveLength(
-      1,
-    )
-  })
-
-  test('a null value still skips its row', () => {
-    const rows = deriveTooltipRows(
-      [{ ...base, key: 'gap', label: 'Gap', getValue: () => null }],
-      { v: 1 },
-      fmt,
-    )
-    expect(rows).toHaveLength(0)
-  })
-
-  test('a per-series formatValue wins over the shared fallback', () => {
-    const rows = deriveTooltipRows(
-      [{ ...base, key: 'a', label: 'A', formatValue: (v) => `${v}%` }],
-      { v: 42 },
-      fmt,
-    )
-    expect(rows[0]?.value).toBe('42%')
-  })
-
-  test('formatValue receives the hovered datum alongside the value', () => {
-    type Set = { v: number; reps: number }
-    const rows = deriveTooltipRows(
-      [
-        {
-          key: 'set',
-          label: 'Set',
-          color: '#000',
-          mark: 'bar' as const,
-          getValue: (d: Set) => d.v,
-          formatValue: (v: number, d: Set) => `${v} kg (${d.reps} reps)`,
-        },
-      ],
-      { v: 97.5, reps: 3 },
-      fmt,
-    )
-    expect(rows[0]?.value).toBe('97.5 kg (3 reps)')
-  })
-
-  test('the fallback formatter (single-arg) still works once formatValue is 2-arg typed', () => {
-    const rows = deriveTooltipRows([{ ...base, key: 'a', label: 'A' }], { v: 5 }, fmt)
-    expect(rows[0]?.value).toBe('5')
-  })
-})
-
-describe('strokeOpacity — a mark property, not a tooltip property', () => {
-  test('reaches the derived legend entry', () => {
-    const [entry] = deriveLegend([{ ...baseSeries, strokeOpacity: 0.4 }])
-    expect(entry?.strokeOpacity).toBe(0.4)
-  })
-
-  test('is absent from the legend entry when unset', () => {
-    const [entry] = deriveLegend([baseSeries])
-    expect(entry).not.toHaveProperty('strokeOpacity')
-  })
-
-  test('never reaches TooltipRowData — the row is a 12px value chip, not a dimmed mark', () => {
-    const rows = deriveTooltipRows(
-      [
-        {
-          ...baseSeries,
-          strokeOpacity: 0.4,
-          getValue: () => 10,
-        },
-      ],
-      {},
-      (v) => String(v),
-    )
-    expect(rows[0]).not.toHaveProperty('strokeOpacity')
-  })
-})

package/src/charts/utils/domain.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { padAutoLower, padAutoUpper } from './domain'
-
-describe('padAutoLower', () => {
-  test('stays at 0 for the default zero-baseline case (never goes negative)', () => {
-    // yAutoMinCeil default 0, positive-only data (e.g. dataMin=78) -> candidate = min(78, 0) = 0.
-    expect(padAutoLower(0, 1.1)).toBe(0)
-  })
-
-  test('pads DOWN below a positive candidate (yAutoMinCeil=Infinity, no forced zero baseline)', () => {
-    // Body-weight case: min=78, max=84, default pad 1.1. candidate = min(78, Infinity) = 78.
-    expect(padAutoLower(78, 1.1)).toBeCloseTo(70.909, 3)
-  })
-
-  test('pads further negative for a negative candidate (unchanged prior behavior)', () => {
-    expect(padAutoLower(-5, 1.1)).toBeCloseTo(-5.5, 5)
-  })
-
-  test('lower never lands above the candidate it was derived from', () => {
-    for (const candidate of [-10, -0.5, 0, 0.5, 10, 78]) {
-      expect(padAutoLower(candidate, 1.1)).toBeLessThanOrEqual(candidate)
-    }
-  })
-})
-
-describe('padAutoUpper', () => {
-  test('stays at 0 (never pushed positive)', () => {
-    expect(padAutoUpper(0, 1.1)).toBe(0)
-  })
-
-  test('pads UP above a positive candidate', () => {
-    expect(padAutoUpper(78, 1.1)).toBeCloseTo(85.8, 5)
-  })
-
-  test('pads further up (toward and past zero) for a negative candidate', () => {
-    expect(padAutoUpper(-5, 1.1)).toBeCloseTo(-4.5454, 3)
-  })
-
-  test('upper never lands below the candidate it was derived from', () => {
-    for (const candidate of [-10, -0.5, 0, 0.5, 10, 78]) {
-      expect(padAutoUpper(candidate, 1.1)).toBeGreaterThanOrEqual(candidate)
-    }
-  })
-
-  test('the autoMaxFloor case: dataMax 3.2, pad 1.1, floor 6 -> 6.6', () => {
-    expect(padAutoUpper(Math.max(3.2, 6), 1.1)).toBeCloseTo(6.6, 5)
-  })
-
-  test('is the exact mirror of padAutoLower — same magnitude, opposite direction', () => {
-    for (const candidate of [-10, -0.5, 0.5, 10, 78]) {
-      expect(padAutoUpper(candidate, 1.1)).toBeCloseTo(-padAutoLower(-candidate, 1.1), 5)
-    }
-  })
-})

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

@@ -1,36 +0,0 @@
-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))
-  })
-})