basalt-ui 1.26.0 → 1.28.0

package/src/router-tanstack/search-store.test.ts

@@ -1,418 +0,0 @@
-/**
- * `createSearchStore` — the resolution law, per field kind, without a router.
- *
- * The router half (what `use()` reads, when a write navigates) lives in
- * `search-store.router.test.tsx`; this file pins the parts that run outside React: the codecs,
- * the lanes, `validateSearch`/`linkSearch`/`readStored`, and the option labels.
- */
-import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
-import { field } from './field'
-import { createSearchStore } from './search-store'
-
-/** Writes the store's envelope directly — one entry per store, `{ fieldName: value }`. */
-function persist(key: string, record: Record<string, unknown>, version = 1): void {
-  localStorage.setItem(`basalt:${key}`, JSON.stringify({ v: version, value: record }))
-}
-
-let warn: ReturnType<typeof spyOn<Console, 'warn'>>
-
-beforeEach(() => {
-  localStorage.clear()
-  warn = spyOn(console, 'warn').mockImplementation(() => {})
-})
-
-afterEach(() => {
-  warn.mockRestore()
-})
-
-describe('field kinds — encode / decode / invalid → fallback', () => {
-  test('enum: a valid URL value wins, an invalid one falls through to storage, then the fallback', () => {
-    const store = createSearchStore({
-      key: 'k-enum',
-      fields: { range: field.enum(['1d', '7d', '30d'], '30d') },
-    })
-    expect(store.validateSearch({ range: '7d' })).toEqual({ range: '7d' })
-
-    persist('k-enum', { range: '1d' })
-    expect(store.validateSearch({})).toEqual({ range: '1d' })
-    expect(store.validateSearch({ range: 'bogus' })).toEqual({ range: '1d' })
-
-    localStorage.clear()
-    expect(store.validateSearch({ range: 'bogus' })).toEqual({ range: '30d' })
-  })
-
-  test('multi: allowlisted, deduped, re-sorted into declaration order — and empty IS a value', () => {
-    const store = createSearchStore({
-      key: 'k-multi',
-      fields: { tags: field.multi(['api', 'design', 'guide'], ['guide']) },
-    })
-    expect(store.validateSearch({ tags: ['design', 'api', 'api', 'nope'] })).toEqual({
-      tags: ['api', 'design'],
-    })
-    // The deprecated wrapper treats `[]` as "absent"; the new store does not — a cleared
-    // selection is a selection.
-    expect(store.validateSearch({ tags: [] })).toEqual({ tags: [] })
-    expect(store.validateSearch({ tags: 'api' })).toEqual({ tags: ['guide'] })
-    expect(store.validateSearch({})).toEqual({ tags: ['guide'] })
-  })
-
-  test('range: three params, a preset, and a custom window of two ISO dates', () => {
-    const store = createSearchStore({
-      key: 'k-range',
-      fields: { range: field.range({ presets: ['7d', '30d'], fallback: '30d', custom: true }) },
-    })
-    expect(store.validateSearch({ range: '7d' })).toEqual({
-      range: '7d',
-      from: undefined,
-      to: undefined,
-    })
-    expect(store.validateSearch({ range: 'custom', from: '2026-01-01', to: '2026-02-01' })).toEqual(
-      { range: 'custom', from: '2026-01-01', to: '2026-02-01' },
-    )
-    // custom without both dates is not a value — it falls through to the fallback.
-    expect(store.validateSearch({ range: 'custom', from: '2026-01-01' })).toEqual({
-      range: '30d',
-      from: undefined,
-      to: undefined,
-    })
-    expect(store.validateSearch({ range: 'custom', from: 'yesterday', to: 'today' })).toEqual({
-      range: '30d',
-      from: undefined,
-      to: undefined,
-    })
-  })
-
-  test('range: `custom: false` rejects the custom preset outright', () => {
-    const store = createSearchStore({
-      key: 'k-range-nocustom',
-      fields: { range: field.range({ presets: ['7d', '30d'], fallback: '7d' }) },
-    })
-    expect(store.validateSearch({ range: 'custom', from: '2026-01-01', to: '2026-02-01' })).toEqual(
-      {
-        range: '7d',
-        from: undefined,
-        to: undefined,
-      },
-    )
-  })
-
-  test('range: `params` renames all three params, so an existing deep link keeps its shape', () => {
-    const store = createSearchStore({
-      key: 'k-range-params',
-      fields: {
-        range: field.range({
-          presets: ['7d', '30d'],
-          fallback: '30d',
-          custom: true,
-          params: { preset: 'window', from: 'start', to: 'end' },
-        }),
-      },
-    })
-    expect(store.validateSearch({ window: '7d' })).toEqual({
-      window: '7d',
-      start: undefined,
-      end: undefined,
-    })
-    expect(
-      store.validateSearch({ window: 'custom', start: '2026-03-01', end: '2026-03-31' }),
-    ).toEqual({ window: 'custom', start: '2026-03-01', end: '2026-03-31' })
-  })
-
-  test('range: two range fields sharing default `from`/`to` throws at definition, not at read time', () => {
-    // Every `field.range` defaults `from`/`to` to those literal param names, so a second range
-    // field in the same store would otherwise clobber the first one's dates on every
-    // `validateSearch` — silently, since `flatten` just `Object.assign`s each entry's `toSearch`
-    // over the last. Caught once, at store definition, instead of shipping a lost custom window.
-    expect(() =>
-      createSearchStore({
-        key: 'k-range-collision',
-        fields: {
-          a: field.range({ presets: ['7d', '30d'], fallback: '30d', custom: true }),
-          b: field.range({ presets: ['7d', '30d'], fallback: '7d', custom: true }),
-        },
-      }),
-    ).toThrow(/fields 'a' and 'b' both own the URL param 'from'/)
-  })
-
-  test("range: renaming one field's `params` clears the collision", () => {
-    const store = createSearchStore({
-      key: 'k-range-no-collision',
-      fields: {
-        a: field.range({ presets: ['7d', '30d'], fallback: '30d', custom: true }),
-        b: field.range({
-          presets: ['7d', '30d'],
-          fallback: '7d',
-          custom: true,
-          params: { preset: 'bWindow', from: 'bFrom', to: 'bTo' },
-        }),
-      },
-    })
-    expect(
-      store.validateSearch({ a: 'custom', from: '2026-01-01', to: '2026-02-01', bWindow: '7d' }),
-    ).toEqual({
-      a: 'custom',
-      from: '2026-01-01',
-      to: '2026-02-01',
-      bWindow: '7d',
-      bFrom: undefined,
-      bTo: undefined,
-    })
-  })
-
-  test('number: coerces a numeric string, clamps to min/max, rejects a non-integer when int', () => {
-    const store = createSearchStore({
-      key: 'k-number',
-      fields: { min: field.number({ fallback: 10, min: 0, max: 100, int: true }) },
-    })
-    expect(store.validateSearch({ min: 42 })).toEqual({ min: 42 })
-    expect(store.validateSearch({ min: '42' })).toEqual({ min: 42 })
-    expect(store.validateSearch({ min: 500 })).toEqual({ min: 100 })
-    expect(store.validateSearch({ min: -5 })).toEqual({ min: 0 })
-    expect(store.validateSearch({ min: 4.2 })).toEqual({ min: 10 })
-    expect(store.validateSearch({ min: 'lots' })).toEqual({ min: 10 })
-  })
-
-  test("number: rejects '', whitespace, and hex rather than coercing them to a number", () => {
-    // `Number('')`/`Number(' ')` are `0` and `Number('0x10')` is `16` — none of those strings is
-    // one the codec's own `toSearch` would ever write, so a blank/hand-edited `?min=` link must
-    // fall through to the fallback instead of silently becoming `0` (or `16`).
-    const store = createSearchStore({
-      key: 'k-number-blank',
-      fields: { min: field.number({ fallback: 10 }) },
-    })
-    expect(store.validateSearch({ min: '' })).toEqual({ min: 10 })
-    expect(store.validateSearch({ min: ' ' })).toEqual({ min: 10 })
-    expect(store.validateSearch({ min: '0x10' })).toEqual({ min: 10 })
-    expect(store.validateSearch({ min: '1e3' })).toEqual({ min: 10 })
-    expect(store.validateSearch({ min: '42' })).toEqual({ min: 42 })
-  })
-
-  test('boolean: takes a real boolean and the two string forms a hand-typed URL carries', () => {
-    const store = createSearchStore({
-      key: 'k-boolean',
-      fields: { compact: field.boolean(false) },
-    })
-    expect(store.validateSearch({ compact: true })).toEqual({ compact: true })
-    expect(store.validateSearch({ compact: 'true' })).toEqual({ compact: true })
-    expect(store.validateSearch({ compact: 'false' })).toEqual({ compact: false })
-    expect(store.validateSearch({ compact: 'yes' })).toEqual({ compact: false })
-  })
-
-  test('string: truncates past `max`, rejects a non-string, keeps the empty string', () => {
-    const store = createSearchStore({
-      key: 'k-string',
-      fields: { q: field.string({ max: 4 }) },
-    })
-    expect(store.validateSearch({ q: 'abc' })).toEqual({ q: 'abc' })
-    expect(store.validateSearch({ q: 'abcdefg' })).toEqual({ q: 'abcd' })
-    expect(store.validateSearch({ q: '' })).toEqual({ q: '' })
-    expect(store.validateSearch({ q: 7 })).toEqual({ q: '' })
-  })
-
-  test('a stale envelope version discards the whole mirror', () => {
-    const store = createSearchStore({
-      key: 'k-version',
-      fields: { range: field.enum(['1d', '7d'], '7d') },
-      version: 2,
-    })
-    persist('k-version', { range: '1d' }, 1)
-    expect(store.validateSearch({})).toEqual({ range: '7d' })
-    expect(store.readStored()).toEqual({})
-  })
-})
-
-describe('lanes', () => {
-  test('a `url: false` field never appears in validateSearch or linkSearch', () => {
-    const store = createSearchStore({
-      key: 'k-lane-local',
-      fields: {
-        range: field.enum(['1d', '7d'], '7d'),
-        compact: field.boolean(false, { url: false }),
-      },
-    })
-    persist('k-lane-local', { compact: true })
-    expect(store.validateSearch({})).toEqual({ range: '7d' })
-    expect(store.linkSearch()).toEqual({ range: '7d' })
-    // …but it IS stored, and readStored covers both lanes.
-    expect(store.readStored()).toEqual({ compact: true })
-  })
-
-  test('a `persist: false` field ignores the mirror even when one exists', () => {
-    const store = createSearchStore({
-      key: 'k-lane-url',
-      fields: { page: field.number({ fallback: 1 }, { persist: false }) },
-    })
-    persist('k-lane-url', { page: 9 })
-    expect(store.validateSearch({})).toEqual({ page: 1 })
-    expect(store.linkSearch()).toEqual({ page: 1 })
-    expect(store.readStored()).toEqual({ page: 9 })
-  })
-})
-
-describe('linkSearch', () => {
-  test('is read at CALL time, so a definition held by reference never goes stale', () => {
-    const store = createSearchStore({
-      key: 'k-link',
-      fields: { range: field.enum(['1d', '7d', '30d'], '30d') },
-    })
-    expect(store.linkSearch()).toEqual({ range: '30d' })
-
-    persist('k-link', { range: '7d' })
-    expect(store.linkSearch()).toEqual({ range: '7d' })
-  })
-
-  test('is ONE function identity, so `search: store.linkSearch` in defineNav stays stable', () => {
-    const store = createSearchStore({
-      key: 'k-link-identity',
-      fields: { range: field.enum(['1d', '7d'], '7d') },
-    })
-    expect(store.linkSearch).toBe(store.linkSearch)
-    expect(store.validateSearch).toBe(store.validateSearch)
-  })
-
-  test('overlays the stored values of every URL-lane field onto the fallbacks', () => {
-    const store = createSearchStore({
-      key: 'k-link-multi',
-      fields: {
-        range: field.enum(['1d', '7d'], '7d'),
-        compare: field.enum(['none', 'previous'], 'none'),
-      },
-    })
-    persist('k-link-multi', { compare: 'previous' })
-    expect(store.linkSearch()).toEqual({ range: '7d', compare: 'previous' })
-  })
-})
-
-describe('the pinned-link warning', () => {
-  test('fires for a multi field — the fallback comparison is by CONTENT, not identity', () => {
-    const store = createSearchStore({
-      key: 'k-warn-multi',
-      fields: { tags: field.multi(['api', 'design'], ['api']) },
-    })
-    persist('k-warn-multi', { tags: ['design'] })
-
-    // `['api']` from the URL is a different array object than the fallback — `===` would miss it.
-    store.validateSearch({ tags: ['api'] })
-    expect(warn).toHaveBeenCalledTimes(1)
-    expect(String(warn.mock.calls[0]?.[0])).toContain('linkSearch')
-  })
-
-  test('fires for a range field, whose value is an object', () => {
-    const store = createSearchStore({
-      key: 'k-warn-range',
-      fields: { range: field.range({ presets: ['7d', '30d'], fallback: '30d' }) },
-    })
-    persist('k-warn-range', { range: { preset: '7d' } })
-
-    store.validateSearch({ range: '30d' })
-    expect(warn).toHaveBeenCalledTimes(1)
-    expect(String(warn.mock.calls[0]?.[0])).toContain('range=30d')
-  })
-
-  test('stays silent when the URL and the mirror agree, whatever the kind', () => {
-    const store = createSearchStore({
-      key: 'k-warn-agree',
-      fields: { tags: field.multi(['api', 'design'], ['api']) },
-    })
-    persist('k-warn-agree', { tags: ['api'] })
-
-    store.validateSearch({ tags: ['api'] })
-    expect(warn).not.toHaveBeenCalled()
-  })
-
-  test('stays silent once any reader is wired — including field.use(), the documented one', () => {
-    const store = createSearchStore({
-      key: 'k-warn-wired',
-      fields: { range: field.enum(['1d', '7d', '30d'], '30d') },
-    })
-    persist('k-warn-wired', { range: '7d' })
-
-    store.readStored()
-    store.validateSearch({ range: '30d' })
-    expect(warn).not.toHaveBeenCalled()
-  })
-})
-
-describe('labels / options', () => {
-  test('labels() returns the SAME store, so it chains at the definition site', () => {
-    const store = createSearchStore({
-      key: 'k-labels',
-      fields: { range: field.range({ presets: ['7d', '30d'], fallback: '30d', custom: true }) },
-    })
-    expect(store.labels({ range: { '7d': 'Last 7 days' } })).toBe(store)
-  })
-
-  test('options derive from the values plus the labels — including a range’s custom preset', () => {
-    const store = createSearchStore({
-      key: 'k-options',
-      fields: {
-        range: field.range({ presets: ['7d', '30d'], fallback: '30d', custom: true }),
-        tags: field.multi(['api', 'design']),
-        page: field.number({ fallback: 1 }),
-      },
-    }).labels({ range: { '7d': 'Last 7 days', custom: 'Custom range' } })
-
-    expect(store.field.range.options).toEqual([
-      { value: '7d', label: 'Last 7 days' },
-      { value: '30d', label: '30d' },
-      { value: 'custom', label: 'Custom range' },
-    ])
-    expect(store.field.tags.options).toEqual([
-      { value: 'api', label: 'api' },
-      { value: 'design', label: 'design' },
-    ])
-    expect(store.field.page.options).toEqual([])
-  })
-})
-
-describe('the handle, outside React', () => {
-  test('kind, fallback and isDefault come off the field definition', () => {
-    const store = createSearchStore({
-      key: 'k-handle',
-      fields: {
-        range: field.enum(['1d', '7d'], '7d'),
-        tags: field.multi(['api', 'design'], ['api']),
-      },
-    })
-    expect(store.field.range.kind).toBe('enum')
-    expect(store.field.range.fallback).toBe('7d')
-    expect(store.field.range.isDefault('7d')).toBe(true)
-    expect(store.field.range.isDefault('1d')).toBe(false)
-    // Multi compares by content, not by reference.
-    expect(store.field.tags.isDefault(['api'])).toBe(true)
-    expect(store.field.tags.isDefault(['design'])).toBe(false)
-  })
-
-  test('toWindow projects a preset to `{ window }` and a custom range to `{ from, to }`', () => {
-    const store = createSearchStore({
-      key: 'k-towindow',
-      fields: { range: field.range({ presets: ['7d', '30d'], fallback: '30d', custom: true }) },
-    })
-    expect(store.field.range.toWindow({ preset: '7d' })).toEqual({ window: '7d' })
-    expect(
-      store.field.range.toWindow({ preset: 'custom', from: '2026-01-01', to: '2026-02-01' }),
-    ).toEqual({ from: '2026-01-01', to: '2026-02-01' })
-    // A custom preset with no dates has nothing to project — it degrades to the preset.
-    expect(store.field.range.toWindow({ preset: 'custom' })).toEqual({ window: 'custom' })
-  })
-
-  test('toWindow exists on a range handle and on no other kind', () => {
-    const store = createSearchStore({
-      key: 'k-towindow-absent',
-      fields: { range: field.enum(['1d', '7d'], '7d') },
-    })
-    expect(store.field.range.toWindow).toBeUndefined()
-  })
-})
-
-describe('types', () => {
-  test('a fallback outside the values is a compile error, not a widened union', () => {
-    const store = createSearchStore({
-      key: 'k-types',
-      // @ts-expect-error 'c' is not one of the declared values
-      fields: { tab: field.enum(['a', 'b'] as const, 'c') },
-    })
-    // The `@ts-expect-error` above IS the assertion; this keeps the store referenced.
-    expect(store.field.tab.kind).toBe('enum')
-  })
-})

package/src/router-tanstack/use-nav.test.tsx

@@ -1,187 +0,0 @@
-/**
- * `useNav`'s active-resolution pass, under a REAL TanStack memory router — the half that cannot be
- * tested headlessly (`matchRoute`/`useRouterState` both need a live router). The fixture below
- * mirrors every collision shape the playground's own `demo/nav-model.tsx` actually has: a root `/`
- * item, a `/dashboard` parent with three children, flat siblings, a same-path duplicate
- * (`reports`/`components`, mirroring the playground's disabled-placeholder shape), and a
- * search-bearing link (mirroring `dashboardFilters.linkSearch`-style destinations).
- *
- * The harness is modeled on `controls/controls.router.test.tsx`'s `mountPage`, narrowed to a
- * headless probe: `useNav` renders no JSX itself (`./router-tanstack` is a no-JSX barrel), so the
- * probe component only reads its return value into a sink — no `MantineProvider` needed.
- */
-import { cleanup, render, waitFor } from '@testing-library/react'
-import { describe, expect, test } from 'bun:test'
-import type { ReactNode } from 'react'
-import {
-  Outlet,
-  RouterProvider,
-  createMemoryHistory,
-  createRootRoute,
-  createRoute,
-  createRouter,
-} from '@tanstack/react-router'
-import type { SidebarItem, SidebarSection } from '../nav/types'
-import type { AnyNavItem } from './nav'
-import { defineNav, navGroup } from './nav'
-import { useNav } from './use-nav'
-
-const NAV = defineNav({
-  groups: [
-    navGroup({ id: 'main', label: 'Main' }, [
-      { id: 'home', label: 'Home', link: { to: '/' } },
-      {
-        id: 'dashboard',
-        label: 'Dashboard',
-        // A store-backed destination (law C10's shape) — `search` rides the link like every
-        // other field; `matchOf` below never reads it, so it must not affect matching either.
-        link: { to: '/dashboard', search: { window: '30d' } },
-        children: [
-          { id: 'dashboard-sessions', label: 'Sessions', link: { to: '/dashboard/sessions' } },
-          { id: 'dashboard-traffic', label: 'Traffic', link: { to: '/dashboard/traffic' } },
-          { id: 'dashboard-revenue', label: 'Revenue', link: { to: '/dashboard/revenue' } },
-        ],
-      },
-      { id: 'mobile-nav-pill', label: 'Mobile nav pill', link: { to: '/mobile-nav-pill' } },
-      {
-        id: 'controls-mobile',
-        label: 'Controls (mobile)',
-        link: { to: '/controls-mobile' },
-      },
-      { id: 'components', label: 'Components', link: { to: '/components' } },
-      { id: 'charts-page', label: 'Charts', link: { to: '/charts' } },
-      // The playground's `reports` shape: a disabled placeholder that deliberately borrows an
-      // already-covered route rather than inventing one. Declared AFTER `components`, so the
-      // definition-order tie-break keeps `components` the winner at `/components`.
-      { id: 'reports', label: 'Reports', disabled: true, link: { to: '/components' } },
-    ]),
-  ],
-})
-
-const ROUTE_PATHS = [
-  '/',
-  '/dashboard',
-  '/dashboard/sessions',
-  '/dashboard/traffic',
-  '/dashboard/revenue',
-  '/mobile-nav-pill',
-  '/controls-mobile',
-  '/components',
-  '/charts',
-]
-
-type NavProbeOpts = { isActive?: (item: AnyNavItem) => boolean }
-type NavResult = { sections: SidebarSection[] }
-type Sink = { current: NavResult | null }
-
-/** Depth-first flatten of the rendered `SidebarSection[]` — the same shape every downstream reader
- * (the sidebar, the mobile bar, the breadcrumb) walks. */
-function flattenItems(sections: SidebarSection[]): SidebarItem[] {
-  const out: SidebarItem[] = []
-  const walk = (items: SidebarItem[]): void => {
-    for (const item of items) {
-      out.push(item)
-      if (item.children) walk(item.children)
-    }
-  }
-  for (const section of sections) walk(section.items)
-  return out
-}
-
-async function mountNav(entry: string, opts?: NavProbeOpts): Promise<Sink> {
-  const sink: Sink = { current: null }
-
-  function NavProbe(): ReactNode {
-    const nav = useNav(NAV, opts)
-    sink.current = { sections: nav.sections }
-    return null
-  }
-
-  const rootRoute = createRootRoute({
-    component: () => (
-      <>
-        <NavProbe />
-        <Outlet />
-      </>
-    ),
-  })
-  const children = ROUTE_PATHS.map((path) =>
-    createRoute({ getParentRoute: () => rootRoute, path, component: () => null }),
-  )
-  const router = createRouter({
-    routeTree: rootRoute.addChildren(children),
-    history: createMemoryHistory({ initialEntries: [entry] }),
-  })
-
-  render(<RouterProvider router={router} />)
-  await waitFor(() => {
-    expect(router.state.status).toBe('idle')
-  })
-  return sink
-}
-
-describe('useNav — exclusivity', () => {
-  test('exactly one row is active at every route in the definition', async () => {
-    for (const path of ROUTE_PATHS) {
-      const sink = await mountNav(path)
-      const items = flattenItems(sink.current!.sections)
-      const activeCount = items.filter((item) => item.active).length
-      expect(activeCount).toBe(1)
-      cleanup()
-    }
-  })
-
-  test('the deepest match wins — a child route does not also light its parent', async () => {
-    const sink = await mountNav('/dashboard/sessions')
-    const items = flattenItems(sink.current!.sections)
-    const dashboard = items.find((item) => item.key === 'dashboard')
-    const sessions = items.find((item) => item.key === 'dashboard-sessions')
-    expect(dashboard?.active).toBe(false)
-    expect(sessions?.active).toBe(true)
-  })
-
-  test('the parent of the active row is an ancestor, not active', async () => {
-    const sink = await mountNav('/dashboard/sessions')
-    const items = flattenItems(sink.current!.sections)
-    const dashboard = items.find((item) => item.key === 'dashboard')
-    expect(dashboard?.ancestor).toBe(true)
-    expect(dashboard?.active).toBe(false)
-  })
-
-  test('a same-path duplicate destination is neither active nor an ancestor', async () => {
-    const sink = await mountNav('/components')
-    const items = flattenItems(sink.current!.sections)
-    const components = items.find((item) => item.key === 'components')
-    const reports = items.find((item) => item.key === 'reports')
-    expect(components?.active).toBe(true)
-    expect(reports?.active).toBe(false)
-    expect(reports?.ancestor).toBeFalsy()
-  })
-
-  test("'/' stays exact — the root never lights on a nested route", async () => {
-    const sink = await mountNav('/dashboard')
-    const items = flattenItems(sink.current!.sections)
-    const home = items.find((item) => item.key === 'home')
-    expect(home?.active).toBe(false)
-    expect(home?.ancestor).toBeFalsy()
-  })
-
-  test('an item whose exact route is never visited still lights on a descendant route', async () => {
-    // `/dashboard` itself is never the visited entry in this test — only its descendant is —
-    // proving the fix kept `fuzzy: true` as the default rather than flipping every item to exact.
-    const sink = await mountNav('/dashboard/traffic')
-    const items = flattenItems(sink.current!.sections)
-    const dashboard = items.find((item) => item.key === 'dashboard')
-    expect(dashboard?.ancestor).toBe(true)
-    expect(dashboard?.active).toBe(false)
-  })
-
-  test('an isActive override cannot light two rows either', async () => {
-    const sink = await mountNav('/', {
-      isActive: (item) => item.id === 'components' || item.id === 'charts-page',
-    })
-    const items = flattenItems(sink.current!.sections)
-    const activeCount = items.filter((item) => item.active).length
-    expect(activeCount).toBe(1)
-  })
-})