basalt-ui 1.26.0 → 1.28.0

package/src/agent-chat/thread-workspace.test.tsx

@@ -1,169 +0,0 @@
-/**
- * ThreadWorkspace — hydration gating (D1).
- *
- * A store built with `createAdapterThreadsStore` starts `!hydrated` until its first `listThreads`
- * succeeds. Before this fix, `ThreadWorkspace` read only `threads.length` to decide between the
- * feed and the empty state, so a server-backed store with real threads (a database, a real API)
- * would render "no threads yet" for the whole initial round trip, then swap to the populated feed
- * once it landed — a defect invisible in the playground's demo only because that demo's in-memory
- * adapter seeds an empty Map, so there is nothing to flash to.
- *
- * These tests drive `ThreadWorkspace` directly against a hand-built `ThreadsStore` (not a real
- * `createAdapterThreadsStore` instance) so each case can assert one exact `{ hydrated, threads }`
- * combination without racing a real async adapter.
- */
-import { MantineProvider } from '@mantine/core'
-import { cleanup, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, test } from 'bun:test'
-import type { ReactElement } from 'react'
-import type { AgentThread, AgentTransport, OutcomeResolver, ThreadsStore } from '../agent'
-import { createThreadsStore } from '../agent'
-import { ThreadWorkspace } from './thread-workspace'
-
-afterEach(cleanup)
-
-// `useMediaQuery` reads `window.matchMedia` inside a mount effect RTL flushes synchronously —
-// force the wide-viewport branch so every case renders the feed pane (same idiom as
-// thread-feed.test.tsx's `withReducedMotion`).
-function withWideViewport<T>(fn: () => T): T {
-  const original = window.matchMedia
-  window.matchMedia = (query: string): MediaQueryList =>
-    ({
-      matches: false,
-      media: query,
-      onchange: null,
-      addListener: () => {},
-      removeListener: () => {},
-      addEventListener: () => {},
-      removeEventListener: () => {},
-      dispatchEvent: () => false,
-    }) as MediaQueryList
-  try {
-    return fn()
-  } finally {
-    window.matchMedia = original
-  }
-}
-
-function noop(): void {}
-
-/** A transport that never resolves — no case here calls `start()`, so `stream` is never invoked. */
-const stubTransport: AgentTransport<never, string> = {
-  stream: (): AsyncGenerator<never> => {
-    throw new Error('stubTransport.stream must not be called by these tests')
-  },
-}
-
-const stubResolveOutcome: OutcomeResolver = async (thread) => ({
-  title: thread.id,
-  summary: '',
-  status: 'done',
-})
-
-function buildThread(id: string): AgentThread {
-  return {
-    id,
-    messages: [],
-    outcome: { title: id, summary: '', status: 'done' },
-    status: 'done',
-    read: true,
-    createdAt: 0,
-    updatedAt: 0,
-  }
-}
-
-/** A minimal fixed `ThreadsStore` — every mutator is a no-op since no case here calls one. */
-function makeStore(overrides: Partial<ThreadsStore>): ThreadsStore {
-  return {
-    threads: [],
-    activeId: null,
-    hydrated: true,
-    error: undefined,
-    select: noop,
-    create: () => 'unused',
-    appendMessage: noop,
-    setOutcome: noop,
-    setStatus: noop,
-    setResumeToken: noop,
-    markRead: noop,
-    remove: noop,
-    clear: noop,
-    ...overrides,
-  }
-}
-
-function renderWorkspace(store: ThreadsStore): ReactElement {
-  return (
-    <MantineProvider>
-      <ThreadWorkspace
-        useThreads={() => store}
-        transport={stubTransport}
-        resolveOutcome={stubResolveOutcome}
-      />
-    </MantineProvider>
-  )
-}
-
-describe('ThreadWorkspace hydration gating', () => {
-  test('hydrating + empty: renders the hydrating hold, never the empty-state copy', () => {
-    withWideViewport(() => {
-      render(renderWorkspace(makeStore({ hydrated: false, threads: [] })))
-    })
-
-    expect(screen.getByTestId('thread-workspace-hydrating')).toBeDefined()
-    expect(screen.queryByText('No threads yet')).toBeNull()
-  })
-
-  test('hydrating + already-populated: renders the feed content, not the hydrating hold', () => {
-    withWideViewport(() => {
-      render(renderWorkspace(makeStore({ hydrated: false, threads: [buildThread('cached-1')] })))
-    })
-
-    expect(screen.getByText('cached-1')).toBeDefined()
-    expect(screen.queryByTestId('thread-workspace-hydrating')).toBeNull()
-  })
-
-  test('failed load: renders the error state, never the hydrating hold', () => {
-    withWideViewport(() => {
-      render(
-        renderWorkspace(
-          makeStore({ hydrated: false, error: new Error('listThreads failed'), threads: [] }),
-        ),
-      )
-    })
-
-    expect(screen.getByTestId('thread-workspace-error')).toBeDefined()
-    expect(screen.queryByTestId('thread-workspace-hydrating')).toBeNull()
-  })
-
-  test('hydrated + empty: renders the empty state (no threads really is the truth)', () => {
-    withWideViewport(() => {
-      render(renderWorkspace(makeStore({ hydrated: true, threads: [] })))
-    })
-
-    expect(screen.getByText('No threads yet')).toBeDefined()
-    expect(screen.queryByTestId('thread-workspace-hydrating')).toBeNull()
-  })
-
-  test('real synchronous createThreadsStore: never shows the hydrating hold, even on first render', () => {
-    // The real localStorage-backed store (hydrated pinned `true` — see thread.test.ts), not the
-    // hand-built stub above, so this proves the gate reads a genuine ThreadsStore correctly and
-    // does not regress the synchronous path with a permanent skeleton.
-    const useThreads = createThreadsStore({ key: 'thread-workspace-sync-empty', version: 1 })
-
-    withWideViewport(() => {
-      render(
-        <MantineProvider>
-          <ThreadWorkspace
-            useThreads={useThreads}
-            transport={stubTransport}
-            resolveOutcome={stubResolveOutcome}
-          />
-        </MantineProvider>,
-      )
-    })
-
-    expect(screen.getByText('No threads yet')).toBeDefined()
-    expect(screen.queryByTestId('thread-workspace-hydrating')).toBeNull()
-  })
-})

package/src/agent-chat/tool-chip.test.tsx

@@ -1,139 +0,0 @@
-/**
- * ToolChip — one test per wire state proving it renders without throwing, plus the
- * approve/deny-visibility contract: rendered ONLY in 'approval-requested', and only for whichever
- * of onApprove/onDeny is actually supplied.
- */
-import { MantineProvider } from '@mantine/core'
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, test } from 'bun:test'
-import { ToolChip } from './tool-chip'
-import type { ToolCallPart } from '../agent'
-
-afterEach(cleanup)
-
-function renderChip(part: ToolCallPart, extra: Partial<Parameters<typeof ToolChip>[0]> = {}) {
-  return render(
-    <MantineProvider>
-      <ToolChip part={part} defaultExpanded {...extra} />
-    </MantineProvider>,
-  )
-}
-
-const BASE = { id: 'p1', type: 'tool' as const, toolCallId: 'c1', toolName: 'search' }
-
-describe('every wire state renders without throwing', () => {
-  const CASES: { name: string; part: ToolCallPart }[] = [
-    { name: 'input-streaming', part: { ...BASE, state: 'input-streaming' } },
-    { name: 'input-available', part: { ...BASE, state: 'input-available', input: { q: 'x' } } },
-    {
-      name: 'approval-requested',
-      part: { ...BASE, state: 'approval-requested', input: { q: 'x' }, approval: { id: 'a1' } },
-    },
-    {
-      name: 'approval-responded (approved)',
-      part: {
-        ...BASE,
-        state: 'approval-responded',
-        input: { q: 'x' },
-        approval: { id: 'a1', approved: true },
-      },
-    },
-    {
-      name: 'approval-responded (declined)',
-      part: {
-        ...BASE,
-        state: 'approval-responded',
-        input: { q: 'x' },
-        approval: { id: 'a1', approved: false },
-      },
-    },
-    {
-      name: 'output-available',
-      part: { ...BASE, state: 'output-available', input: { q: 'x' }, output: { hits: 3 } },
-    },
-    {
-      name: 'output-available (preliminary)',
-      part: {
-        ...BASE,
-        state: 'output-available',
-        input: { q: 'x' },
-        output: { hits: 1 },
-        preliminary: true,
-      },
-    },
-    {
-      name: 'output-error (with rawInput)',
-      part: { ...BASE, state: 'output-error', errorText: 'boom', rawInput: { q: 'x' } },
-    },
-    {
-      name: 'output-denied (with reason)',
-      part: {
-        ...BASE,
-        state: 'output-denied',
-        input: { q: 'x' },
-        approval: { id: 'a1', approved: false, reason: 'not now' },
-      },
-    },
-  ]
-
-  for (const { name, part } of CASES) {
-    test(name, () => {
-      expect(() => renderChip(part)).not.toThrow()
-    })
-  }
-})
-
-describe('approve/deny affordances', () => {
-  const REQUESTED: ToolCallPart = {
-    ...BASE,
-    state: 'approval-requested',
-    input: { q: 'x' },
-    approval: { id: 'a1' },
-  }
-
-  test('read-only when both handlers are omitted', () => {
-    renderChip(REQUESTED)
-    expect(screen.queryByText('Approve')).toBeNull()
-    expect(screen.queryByText('Deny')).toBeNull()
-  })
-
-  test('renders only the supplied handler', () => {
-    renderChip(REQUESTED, { onApprove: () => {} })
-    expect(screen.queryByText('Approve')).not.toBeNull()
-    expect(screen.queryByText('Deny')).toBeNull()
-  })
-
-  test('calls onApprove with the approval id', () => {
-    let approvedId: string | undefined
-    renderChip(REQUESTED, { onApprove: (id) => (approvedId = id) })
-    fireEvent.click(screen.getByText('Approve'))
-    expect(approvedId).toBe('a1')
-  })
-
-  test('never renders for a non-approval-requested state even with both handlers supplied', () => {
-    renderChip(
-      { ...BASE, state: 'output-available', input: { q: 'x' }, output: {} },
-      { onApprove: () => {}, onDeny: () => {} },
-    )
-    expect(screen.queryByText('Approve')).toBeNull()
-    expect(screen.queryByText('Deny')).toBeNull()
-  })
-})
-
-// F3: a runtime value the type system believes is exhaustively handled — but isn't, once
-// persisted (localStorage, zero shape validation) or wire (edenTransport, zero validation) data
-// is involved — must render an inert 'unknown' chip, never throw via assertNever and blank the
-// transcript.
-describe('a malformed/unrecognized state never throws (F3)', () => {
-  test('state undefined (the pre-1.11.0 flat persisted shape) renders "unknown" instead of throwing', () => {
-    const malformed = { ...BASE, output: { hits: 1 } } as unknown as ToolCallPart
-    expect(() => renderChip(malformed)).not.toThrow()
-    expect(screen.getByText('unknown')).not.toBeNull()
-  })
-
-  test('an unrecognized state string renders "unknown" instead of throwing', () => {
-    const malformed = { ...BASE, state: 'bogus-future-state' } as unknown as ToolCallPart
-    expect(() => renderChip(malformed)).not.toThrow()
-    expect(screen.getByText('unknown')).not.toBeNull()
-  })
-})

package/src/agent-chat/virtualize.type-guard.test.ts

@@ -1,49 +0,0 @@
-/**
- * Compile-time proof that `VirtualizeProps` actually rejects the invalid `virtualize`/`height`
- * combinations (not just documentation).
- *
- * This mirrors the `apps/playground/src/*.type-guard.ts` convention (one `@ts-expect-error` per bad
- * line, proven by CI's `tsc --noEmit`) but lives HERE, beside the type, rather than in the
- * playground app. `VirtualizeProps` IS public now (re-exported type-only from the agent-chat barrel
- * and the root), so a playground fixture would also work — this stays put because a source-relative
- * import proves the union at its definition, before the build, and needs no rebuild to stay honest.
- * A co-located `.type-guard.ts` file under `src/` would get picked up by tsup's
- * `src/**\/*.{ts,tsx}` build glob and ship an unused fixture in the published package; naming it
- * `*.test.ts` excludes it from that glob (tsup.config.ts excludes `src/**\/*.test.{ts,tsx}`) while
- * this package's own `tsc --noEmit` (and `bun test`, which type-checks test files per the repo
- * convention) still verifies it.
- */
-import { describe, expect, test } from 'bun:test'
-import type { VirtualizeProps } from './virtualize'
-
-function accept(props: VirtualizeProps): VirtualizeProps {
-  return props
-}
-
-// ── Valid combinations — must type-check with no error ────────────────────────
-
-accept({})
-accept({ virtualize: false })
-accept({ virtualize: true, height: 400 })
-accept({ virtualize: true, height: '100%' })
-accept({ virtualize: { overscan: 3 }, height: 400 })
-accept({ virtualize: { estimateSize: 72 }, height: '50vh' })
-
-// ── Invalid combinations — each MUST be a tsc error, one directive per bad line ─
-
-// @ts-expect-error `height` is forbidden when `virtualize` is false
-accept({ virtualize: false, height: 400 })
-// @ts-expect-error `height` is required when `virtualize: true`
-accept({ virtualize: true })
-// @ts-expect-error `height` is required when `virtualize` is a VirtualizeOptions object
-accept({ virtualize: { overscan: 2 } })
-// @ts-expect-error `height` is forbidden when `virtualize` is omitted (defaults to the `false` branch)
-accept({ height: 400 })
-
-describe('VirtualizeProps (type-guard)', () => {
-  test('is a compile-time-only fixture — see the @ts-expect-error directives above', () => {
-    // No runtime behavior to assert: the proof is that this file type-checks at all. A single
-    // trivial assertion keeps this a normal bun:test file rather than an empty-suite oddity.
-    expect(true).toBe(true)
-  })
-})

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

@@ -1,151 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { buildDomainIndex, classifyDomain, 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()
-  })
-})
-
-describe("resolveCursorPoint — 'leading' resolution (bucket-keyed domains)", () => {
-  const weekly = (days: string[]) => buildDomainIndex(daily(days), (p) => p.date, 'leading')
-
-  test('resolves an exact key, same as nearest', () => {
-    const i = weekly(['01', '08', '15'])
-    expect(resolveCursorPoint(i, '2026-08-08')?.date).toBe('2026-08-08')
-  })
-
-  test("a target anywhere inside a bucket resolves to that bucket's LEADING key, not the nearest one", () => {
-    // The bug this replaces: a weekly chart keyed by the Monday of each week (step 7 days),
-    // hovered from a daily sibling landing in the back half of the bucket, used to resolve to the
-    // FOLLOWING week under nearest-match. Every back-half day must resolve to the bucket it is
-    // actually inside.
-    const i = weekly(['01', '08', '15'])
-    expect(resolveCursorPoint(i, '2026-08-02')?.date).toBe('2026-08-01')
-    expect(resolveCursorPoint(i, '2026-08-05')?.date).toBe('2026-08-01')
-    expect(resolveCursorPoint(i, '2026-08-07')?.date).toBe('2026-08-01')
-    expect(resolveCursorPoint(i, '2026-08-09')?.date).toBe('2026-08-08')
-    expect(resolveCursorPoint(i, '2026-08-14')?.date).toBe('2026-08-08')
-  })
-
-  test('a key BEFORE the first bucket resolves to null — no bucket contains it', () => {
-    // Deliberately NOT 'nearest''s one-step tolerance. The first key is the leading edge of the
-    // first bucket, so anything earlier is outside every bucket; snapping it onto the first one
-    // would paint a crosshair on a bucket that provably does not contain the hovered key.
-    const i = weekly(['02', '09', '16'])
-    expect(resolveCursorPoint(i, '2026-08-01')).toBeNull()
-    expect(resolveCursorPoint(i, '2026-08-02')?.date).toBe('2026-08-02')
-  })
-
-  test('the final bucket ends at last + step — that instant is already outside it', () => {
-    const i = weekly(['01', '08', '15']) // step = 7, so the last bucket covers [Aug 15, Aug 22)
-    expect(resolveCursorPoint(i, '2026-08-21')?.date).toBe('2026-08-15') // last day inside
-    expect(resolveCursorPoint(i, '2026-08-22')).toBeNull() // exactly last + step, exclusive
-    expect(resolveCursorPoint(i, '2026-08-23')).toBeNull()
-  })
-
-  test('returns null well beyond the domain, so unrelated charts never sync', () => {
-    const i = weekly(['01', '08', '15'])
-    expect(resolveCursorPoint(i, '2026-09-30')).toBeNull()
-  })
-
-  test('categorical domains fall back to exact match only, same as nearest', () => {
-    const points = [{ date: 'Direct' }, { date: 'Referral' }]
-    const i = buildDomainIndex(points, (p) => p.date, 'leading')
-    expect(resolveCursorPoint(i, 'Direct')?.date).toBe('Direct')
-    expect(resolveCursorPoint(i, 'Organic')).toBeNull()
-  })
-
-  test('a single-point chart resolves only its own key', () => {
-    const i = weekly(['01'])
-    expect(resolveCursorPoint(i, '2026-08-01')?.date).toBe('2026-08-01')
-    expect(resolveCursorPoint(i, '2026-08-02')).toBeNull()
-  })
-
-  test('an explicit resolution argument overrides the index-built default', () => {
-    // Built as 'nearest', resolved as 'leading' — the per-call argument wins.
-    const i = index(daily(['01', '08', '15']))
-    expect(resolveCursorPoint(i, '2026-08-05', 'leading')?.date).toBe('2026-08-01')
-  })
-})
-
-describe('classifyDomain', () => {
-  test('an ISO date domain classifies as time', () => {
-    expect(classifyDomain(['2026-08-01', '2026-08-02', '2026-08-03'])).toBe('time')
-  })
-
-  test("a bare-year domain classifies as linear, matching parseKey's numeric-first precedence", () => {
-    // "2026" passes the numeric test before it ever reaches the date fallback — same ordering
-    // `parseKey` applies to a single key, applied here across the whole domain.
-    expect(classifyDomain(['2024', '2025', '2026'])).toBe('linear')
-  })
-
-  test('a numeric bucket domain classifies as linear', () => {
-    expect(classifyDomain(['0', '1', '2', '3'])).toBe('linear')
-  })
-
-  test('a category domain classifies as band', () => {
-    expect(classifyDomain(['Visited', 'Added to cart', 'Purchased'])).toBe('band')
-  })
-
-  test('a mixed domain falls back to band', () => {
-    expect(classifyDomain(['2026-08-01', 'Direct'])).toBe('band')
-  })
-
-  test('an empty domain classifies as band', () => {
-    expect(classifyDomain([])).toBe('band')
-  })
-})

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

@@ -1,64 +0,0 @@
-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', kind: null })
-
-    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()
-  })
-
-  test('a set carrying a different kind notifies — the partition is state, not a filter on the store', () => {
-    // The store is dumb: it broadcasts whatever kind it's handed and never compares it against
-    // anything. Policing "does this kind match mine" is `useChartCursor`'s job, on read.
-    const store = createCursorStore()
-    let calls = 0
-    store.subscribe(() => {
-      calls++
-    })
-
-    store.set('2026-08-18', 'chart-a', 'time')
-    expect(calls).toBe(1)
-    expect(store.get()).toEqual({ key: '2026-08-18', source: 'chart-a', kind: 'time' })
-
-    store.set('2026-08-18', 'chart-a', 'band')
-    expect(calls).toBe(2)
-    expect(store.get()).toEqual({ key: '2026-08-18', source: 'chart-a', kind: 'band' })
-  })
-})