basalt-ui 1.27.0 → 1.29.0

package/src/query/error-message.test.ts

@@ -1,67 +0,0 @@
-/**
- * `toErrorMessage`'s job is to never hand a human a string that says nothing. The decode ladder
- * was already right; what was missing is the floor under it — an opaque envelope decoded to the
- * literal `"{}"`, and `toErrorMessage(undefined)` returned `JSON.stringify(undefined)`, which is
- * not a string at all despite the `string` return type. Both are the shape a page renders straight
- * into an Alert, so both are asserted here.
- */
-import { describe, expect, test } from 'bun:test'
-import { errorStatus, toErrorMessage } from './error-message'
-
-describe('toErrorMessage — decode ladder', () => {
-  test('Error instance → message', () => {
-    expect(toErrorMessage(new Error('slug already in use'))).toBe('slug already in use')
-  })
-
-  test('{ message } → message', () => {
-    expect(toErrorMessage({ message: 'recursive is rejected' })).toBe('recursive is rejected')
-  })
-
-  test('Eden { status, value } envelope → one level down', () => {
-    expect(toErrorMessage({ status: 409, value: { message: 'slug taken' } })).toBe('slug taken')
-  })
-
-  test('plain string → itself', () => {
-    expect(toErrorMessage('boom')).toBe('boom')
-  })
-})
-
-describe('toErrorMessage — the unusable floor', () => {
-  test('an opaque object falls back instead of rendering "{}"', () => {
-    expect(toErrorMessage({}, 'Could not create share')).toBe('Could not create share')
-  })
-
-  test('undefined returns a real string, not the undefined value', () => {
-    const message = toErrorMessage(undefined)
-    expect(typeof message).toBe('string')
-    expect(message).toBe('The request failed.')
-  })
-
-  test('an opaque envelope WITH a status folds the status into the fallback', () => {
-    expect(toErrorMessage({ status: 502, value: {} }, 'Could not load images')).toBe(
-      'Could not load images (HTTP 502)',
-    )
-  })
-
-  test('a readable body wins over the status — the server message is never replaced', () => {
-    expect(toErrorMessage({ status: 403, value: { message: 'forbidden' } }, 'Nope')).toBe(
-      'forbidden',
-    )
-  })
-
-  test('whitespace-only decodes as unusable', () => {
-    expect(toErrorMessage({ message: '   ' }, 'Fallback')).toBe('Fallback')
-  })
-})
-
-describe('errorStatus', () => {
-  test('reads a numeric status off an envelope', () => {
-    expect(errorStatus({ status: 404, value: null })).toBe(404)
-  })
-
-  test('is undefined for anything else', () => {
-    expect(errorStatus(new Error('x'))).toBeUndefined()
-    expect(errorStatus(null)).toBeUndefined()
-    expect(errorStatus({ status: '404' })).toBeUndefined()
-  })
-})

package/src/query/error-message.ts

@@ -1,70 +0,0 @@
-/**
- * Transport-agnostic error decoding. Deliberately a standalone module with NO
- * `@tanstack/react-query` import — `dashboard/query-state.tsx` renders server messages and must
- * not drag the query peer into the root barrel's graph to do it.
- */
-
-/**
- * The HTTP status behind a thrown envelope (Eden Treaty's `{ status, value }`, a `Response`-shaped
- * throw), when there is one. Use it to BRANCH — 404 → "not found" copy — rather than to build a
- * message; `toErrorMessage` already folds the status into its text when the body says nothing.
- *
- * @example
- * if (errorStatus(err) === 404) return <EmptyState title="Gone" />
- */
-export function errorStatus(err: unknown): number | undefined {
-  if (err === null || typeof err !== 'object') return undefined
-  const status = (err as { status?: unknown }).status
-  return typeof status === 'number' ? status : undefined
-}
-
-/** Strings that technically decoded but tell a reader nothing. `JSON.stringify` produces most. */
-const UNUSABLE = new Set(['', '{}', '[]', 'null', 'undefined', '[object Object]'])
-
-function decode(err: unknown): string {
-  if (err instanceof Error) return err.message
-  if (typeof err === 'string') return err
-  if (typeof err === 'object' && err !== null) {
-    const obj = err as Record<string, unknown>
-    if (typeof obj['message'] === 'string') return obj['message']
-    // Eden-style { value: ... } or { status, value } envelopes — unwrap one level.
-    if ('value' in obj) return decode(obj['value'])
-  }
-  try {
-    return JSON.stringify(err) ?? ''
-  } catch {
-    return String(err)
-  }
-}
-
-/**
- * Extract a human-readable message from an unknown thrown value (e.g. the raw Eden envelope
- * thrown by `unwrap`). Removes the 8-line three-branch boilerplate consumers duplicate.
- *
- * Resolution order:
- *   1. `Error` instance       → err.message
- *   2. `{ message: string }`  → message (Eden / Elysia error shape)
- *   3. `{ value: ... }`       → recursively (Eden nested value envelope)
- *   4. plain string           → itself
- *   5. anything else          → `JSON.stringify`
- *
- * **If that yields nothing a human can read** (`''`, `'{}'`, `'[]'`, `'null'`, `'undefined'`,
- * `'[object Object]'` — the shapes `JSON.stringify` produces for an opaque envelope) the `fallback`
- * is returned instead, with `(HTTP <status>)` appended when the envelope carries one. Without that
- * guard the caller renders a literal `{}` at the user, or — for `toErrorMessage(undefined)` —
- * the actual value `undefined`, since `JSON.stringify(undefined)` is not a string at all.
- *
- * @example
- * try {
- *   await unwrap(api.resource.post({ body }))
- * } catch (e) {
- *   toast(toErrorMessage(e, 'Could not create share'))   // → "slug already in use"
- *                                                        // → "Could not create share (HTTP 502)"
- * }
- */
-export function toErrorMessage(err: unknown, fallback = 'The request failed.'): string {
-  const message = decode(err).trim()
-  if (!UNUSABLE.has(message)) return message
-  const status = errorStatus(err)
-  return status === undefined ? fallback : `${fallback} (HTTP ${status})`
-}

package/src/query/index.ts

@@ -1,97 +0,0 @@
-/**
- * ./query — thin TanStack Query adapter + transport-agnostic Eden unwrap.
- * Optional peer: @tanstack/react-query.
- */
-import { QueryClient } from '@tanstack/react-query'
-import type { QueryClientConfig } from '@tanstack/react-query'
-
-// ── createBasaltQueryClient ───────────────────────────────────────────────────────────────────────
-
-const BASALT_QUERY_DEFAULTS = {
-  staleTime: 30_000,
-  gcTime: 5 * 60 * 1000,
-  retry: 2,
-  refetchOnWindowFocus: false,
-} as const
-
-/**
- * Wraps QueryClient with basalt dashboard defaults. All options are mergeable — consumer
- * overrides win per-query, framework defaults are the fallback.
- *
- * @example
- * import { createBasaltQueryClient, QueryClientProvider } from 'basalt-ui/query'
- * import { useState } from 'react'
- *
- * function Root({ children }: { children: React.ReactNode }) {
- *   const [client] = useState(() => createBasaltQueryClient())
- *   return <QueryClientProvider client={client}>{children}</QueryClientProvider>
- * }
- */
-export function createBasaltQueryClient(config?: QueryClientConfig): QueryClient {
-  return new QueryClient({
-    ...config,
-    defaultOptions: {
-      ...config?.defaultOptions,
-      queries: { ...BASALT_QUERY_DEFAULTS, ...config?.defaultOptions?.queries },
-    },
-  })
-}
-
-// ── unwrap ────────────────────────────────────────────────────────────────────────────────────────
-
-/**
- * Transport-agnostic unwrap for any `{ data, error }` envelope (Eden Treaty, raw fetch wrappers,
- * etc.). TData is inferred from the data field. Throws on the error branch so failures surface
- * to the nearest error boundary or TanStack Query's error state.
- *
- * Null guard: if `error` is falsy but `data` is `null`, unwrap throws with a descriptive message.
- * This catches 204 No Content responses and silent transport failures that return `{ data: null,
- * error: null }` — both signal an unexpected absence of data and should not silently resolve.
- *
- * @example
- * import { unwrap } from 'basalt-ui/query'
- *
- * queryFn: () => unwrap(api.users.get({ query: params }))
- * // mutation:
- * mutationFn: (body) => unwrap(api.resource.post({ body }))
- * // manual:
- * const rows = await unwrap(api.users.get())
- */
-export async function unwrap<TData>(
-  response: Promise<{ data: TData | null; error: unknown }>,
-): Promise<TData> {
-  const { data, error } = await response
-  if (error) throw error
-  if (data === null)
-    throw new Error(
-      'unwrap: null data with no error — check for a 204 response or a transport failure',
-    )
-  return data as TData
-}
-
-// ── Error decoding ────────────────────────────────────────────────────────────────────────────────
-
-export { toErrorMessage, errorStatus } from './error-message'
-
-// ── Re-exports from @tanstack/react-query ────────────────────────────────────────────────────────
-
-// Provider + boundary helpers
-export {
-  QueryClientProvider,
-  QueryErrorResetBoundary,
-  useQueryErrorResetBoundary,
-} from '@tanstack/react-query'
-
-// Primary fetch hooks — import from basalt-ui/query rather than dual-importing @tanstack/react-query
-export {
-  useQuery,
-  useSuspenseQuery,
-  useMutation,
-  useQueryClient,
-  useInfiniteQuery,
-  queryOptions,
-} from '@tanstack/react-query'
-
-// ── Re-export devtools helper ─────────────────────────────────────────────────────────────────────
-
-export { BasaltQueryDevtools } from './devtools'

package/src/router-tanstack/field.ts

@@ -1,35 +0,0 @@
-/**
- * `field.*` — the field vocabulary `createSearchStore` takes, re-exported at the surface a consumer
- * imports it from (`basalt-ui/router-tanstack`, beside the store factory).
- *
- * The builders and their codecs LIVE in `../state` on purpose: a field is declarative data with no
- * router in it, and `createLocalStore` — the router-free lane, published on `basalt-ui/state` —
- * has to build the same fields without pulling in `@tanstack/react-router`. One definition, two
- * surfaces, no second description of the same param.
- *
- * Full field reference: the JSDoc on `field` itself, and `docs/CONTROLS-SPEC.md` §4.
- */
-export { field } from '../state'
-export type {
-  AnyField,
-  BooleanField,
-  EnumField,
-  FieldFallback,
-  FieldHandle,
-  FieldLane,
-  FieldOption,
-  FieldSetOptions,
-  FieldValue,
-  MultiField,
-  NumberField,
-  RangeField,
-  RangeParams,
-  RangePresets,
-  RangeWindow,
-  RangeWindows,
-  RangeValue,
-  ResolvedLane,
-  SearchValues,
-  StoredValues,
-  StringField,
-} from '../state'

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

@@ -1,124 +0,0 @@
-/**
- * The deprecated multi wrapper's contract, unchanged across the rewrite onto
- * `createSearchStore` — plus the storage path two of these tests used to claim was unreachable.
- *
- * `bun test` runs under happy-dom (root `bunfig.toml` preload), so `localStorage` has always been
- * REAL here: "no localStorage in this environment" was false, and it meant the fallback-to-storage
- * half of `validateSearch` — the entire reason the store exists — was asserted only in the
- * single-value store's tests (D12).
- */
-import { beforeEach, describe, expect, test } from 'bun:test'
-import { createMultiSearchParamStore } from './multi-search-param-store'
-
-const VALUES = ['api', 'design', 'guide'] as const
-
-/** Writes the wrapper's single-value envelope — the layout it has used since 1.0.0. */
-function persist(key: string, value: readonly string[], version = 1): void {
-  localStorage.setItem(`basalt:${key}`, JSON.stringify({ v: version, value }))
-}
-
-beforeEach(() => {
-  localStorage.clear()
-})
-
-describe('createMultiSearchParamStore', () => {
-  describe('validateSearch', () => {
-    test('URL value wins when it decodes to a non-empty array', () => {
-      const store = createMultiSearchParamStore({ key: 'tags-a', param: 'tags', values: VALUES })
-      expect(store.validateSearch({ tags: ['api'] })).toEqual({ tags: ['api'] })
-    })
-
-    test('an allowlist rejects unknown/tampered values', () => {
-      const store = createMultiSearchParamStore({ key: 'tags-b', param: 'tags', values: VALUES })
-      expect(store.validateSearch({ tags: ['api', 'not-a-real-tag'] })).toEqual({ tags: ['api'] })
-    })
-
-    test('dedupes repeated entries', () => {
-      const store = createMultiSearchParamStore({ key: 'tags-c', param: 'tags', values: VALUES })
-      expect(store.validateSearch({ tags: ['api', 'api', 'design'] })).toEqual({
-        tags: ['api', 'design'],
-      })
-    })
-
-    test('canonically re-orders into the values declaration order', () => {
-      const store = createMultiSearchParamStore({ key: 'tags-d', param: 'tags', values: VALUES })
-      const a = store.validateSearch({ tags: ['design', 'api'] })
-      const b = store.validateSearch({ tags: ['api', 'design'] })
-      expect(a).toEqual(b)
-      expect(a.tags).toEqual(['api', 'design'])
-    })
-
-    test('a non-array URL value falls through to storage, then to the fallback', () => {
-      const store = createMultiSearchParamStore({ key: 'tags-e', param: 'tags', values: VALUES })
-      expect(store.validateSearch({ tags: 'api' })).toEqual({ tags: [] })
-      expect(store.validateSearch({})).toEqual({ tags: [] })
-
-      persist('tags-e', ['guide', 'api'])
-      // Storage is read, and normalized on the way out like any other source.
-      expect(store.validateSearch({ tags: 'api' })).toEqual({ tags: ['api', 'guide'] })
-      expect(store.validateSearch({})).toEqual({ tags: ['api', 'guide'] })
-      // A valid URL array still wins over it.
-      expect(store.validateSearch({ tags: ['design'] })).toEqual({ tags: ['design'] })
-    })
-
-    test('an empty URL array falls through to the fallback', () => {
-      const store = createMultiSearchParamStore({
-        key: 'tags-f',
-        param: 'tags',
-        values: VALUES,
-        fallback: ['guide'],
-      })
-      expect(store.validateSearch({ tags: [] })).toEqual({ tags: ['guide'] })
-    })
-  })
-
-  describe('readStored', () => {
-    test('returns null when nothing is persisted', () => {
-      const store = createMultiSearchParamStore({ key: 'tags-g', param: 'tags', values: VALUES })
-      expect(store.readStored()).toBeNull()
-    })
-
-    test('returns the normalized stored selection, and null for a stale envelope version', () => {
-      const store = createMultiSearchParamStore({ key: 'tags-h', param: 'tags', values: VALUES })
-      persist('tags-h', ['guide', 'nope', 'api'])
-      expect(store.readStored()).toEqual(['api', 'guide'])
-
-      const versioned = createMultiSearchParamStore({
-        key: 'tags-i',
-        param: 'tags',
-        values: VALUES,
-        version: 1,
-      })
-      persist('tags-i', ['api'], 2)
-      expect(versioned.readStored()).toBeNull()
-    })
-
-    test('a stored EMPTY selection reads back as empty — a cleared filter stays cleared', () => {
-      // `{ v: 1, value: [] }` is exactly what `useStore()`'s setter writes when a user clears every
-      // filter. The empty-array-means-absent rule is a URL rule; applying it to storage too would
-      // resurrect the fallback on upgrade, which is not what "byte-compatible" means.
-      const store = createMultiSearchParamStore({
-        key: 'tags-empty',
-        param: 'tags',
-        values: VALUES,
-        fallback: ['guide'],
-      })
-      persist('tags-empty', [])
-
-      expect(store.readStored()).toEqual([])
-      expect(store.validateSearch({})).toEqual({ tags: [] })
-      expect(store.linkSearch()).toEqual({ tags: [] })
-      // …while an empty URL array still falls through to storage, as it always has.
-      persist('tags-empty', ['api'])
-      expect(store.validateSearch({ tags: [] })).toEqual({ tags: ['api'] })
-    })
-
-    test('linkSearch carries the stored selection at CALL time', () => {
-      const store = createMultiSearchParamStore({ key: 'tags-j', param: 'tags', values: VALUES })
-      expect(store.linkSearch()).toEqual({ tags: [] })
-
-      persist('tags-j', ['design'])
-      expect(store.linkSearch()).toEqual({ tags: ['design'] })
-    })
-  })
-})

package/src/router-tanstack/multi-search-param-store.ts

@@ -1,106 +0,0 @@
-/**
- * @deprecated `createMultiSearchParamStore` is a thin wrapper over `createSearchStore`
- * and is removed in 1.29.0. Replace it with `field.multi`:
- *
- *     const store = createSearchStore({
- *       key: 'article-tags',
- *       fields: { tags: field.multi(['api', 'design', 'guide'], []) },
- *     })
- *
- * Two differences to know when you migrate:
- *
- * - **An empty URL array is a VALUE in the new store**, not "absent". This wrapper keeps the old
- *   rule (`?tags=[]` falls through to localStorage, then to `fallback`) so an existing consumer's
- *   links behave identically; `field.multi` treats a cleared selection as a cleared selection.
- * - `useStore` is localStorage-only. `store.field.tags.use()` reads the URL first (A8).
- *
- * Encoding is unchanged and array-native: TanStack Router's default
- * `stringifySearchWith(JSON.stringify, JSON.parse)` round-trips `{ tags: ['a', 'b'] }` losslessly,
- * so there is no CSV step to intercept — a consumer wanting `?tags=a,b` configures router-global
- * `parseSearch`/`stringifySearch` and this store keeps working untouched, because it hands the
- * router an array rather than an encoding.
- *
- * Decoding is unchanged too: array-only input, allowlist-filtered, deduped, then re-sorted into
- * `values` DECLARATION order — so `['api', 'design']` and `['design', 'api']` normalize to the same
- * array, and one logical selection has one URL.
- *
- * The four returned members (`validateSearch`, `useStore`, `readStored`, `linkSearch`), their
- * signatures and the single-value localStorage envelope are preserved byte-for-byte.
- */
-import { createPersistedState, field } from '../state'
-import { buildSearchStore } from './search-store'
-
-// ── Types ──────────────────────────────────────────────────────────────────
-
-export type MultiSearchParamStoreOptions<T extends string, P extends string = string> = {
-  /** localStorage key (namespaced `basalt:<key>` automatically). */
-  key: string
-  /** URL search-param name (e.g. `"tags"`, `"categories"`). */
-  param: P
-  /** Allowed values — `as const` for best type inference. Also the canonical sort order. */
-  values: readonly T[]
-  /** Factory default when nothing is in the URL or localStorage. Default `[]` (unfiltered). */
-  fallback?: readonly T[]
-  /** Envelope version — bump when `values` change to discard stale localStorage. */
-  version?: number
-}
-
-export type MultiSearchParamStore<T extends string, P extends string = string> = {
-  /**
-   * validateSearch — pass directly to `createFileRoute({ validateSearch })`.
-   * Falls back to localStorage, then to `fallback`.
-   */
-  validateSearch: (search: Record<string, unknown>) => { [K in P]: readonly T[] }
-  /**
-   * React hook: `const [current, persist] = store.useStore()`.
-   * localStorage only — it does NOT read or write the URL.
-   */
-  useStore: () => readonly [readonly T[], (next: readonly T[]) => void]
-  /** Plain read — for use outside React (tests, guards, fallback reads). */
-  readStored: () => readonly T[] | null
-  /**
-   * The click-time `search:` thunk for a nav link — `() => ({ [param]: readStored() ?? fallback })`.
-   * Pass it BY REFERENCE (`search: store.linkSearch`), never call it; see `createSearchParamStore`
-   * for why a module-scope literal silently defeats the store.
-   *
-   * No dev warning rides on this one, unlike the single-value store: an empty array in the URL is
-   * indistinguishable from an absent param here, so a link declaring `{ tags: [] }` restores
-   * correctly and there is no broken state to detect.
-   */
-  linkSearch: () => { [K in P]: readonly T[] }
-}
-
-// ── Implementation ─────────────────────────────────────────────────────────
-
-/** @deprecated Use `createSearchStore` + `field.multi`. Removed in 1.29.0. */
-export function createMultiSearchParamStore<const T extends string, const P extends string>(
-  opts: MultiSearchParamStoreOptions<T, P>,
-): MultiSearchParamStore<T, P> {
-  const version = opts.version ?? 1
-  const fallback = opts.fallback ?? []
-  const store = buildSearchStore({
-    key: opts.key,
-    version,
-    fields: { [opts.param]: field.multi(opts.values, fallback) },
-    legacyValueField: opts.param,
-  })
-
-  const persisted = createPersistedState<readonly T[]>({
-    key: opts.key,
-    version,
-    initial: fallback,
-  })
-  // A reader, like the single-value wrapper's — see the note there.
-  const useStore = (): readonly [readonly T[], (next: readonly T[]) => void] => {
-    store.markReaderWired()
-    return persisted()
-  }
-
-  return {
-    validateSearch: (search) => store.validateSearch(search) as { [K in P]: readonly T[] },
-    useStore,
-    readStored: () =>
-      (store.readStored() as Record<string, readonly T[] | undefined>)[opts.param] ?? null,
-    linkSearch: () => store.linkSearch() as { [K in P]: readonly T[] },
-  }
-}

package/src/router-tanstack/nav.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { defineNav, flattenNav, navGroup, navTarget } from './nav'
-
-/**
- * The definition below is deliberately built with the real builders (not object literals) so the
- * runtime-identity assertions below prove the builders are erased at runtime — every bit of value
- * they add is compile-time. The type-level half of the contract lives in the playground's
- * `nav.type-guard.ts` fixture, which is where a registered router exists to validate `to` against.
- */
-const NAV = defineNav({
-  groups: [
-    navGroup({ id: 'main', label: 'Main' }, [
-      { id: 'dash', label: 'Dashboard', short: 'Home', mobile: 'tab', link: { to: '/dashboard' } },
-      {
-        id: 'reports',
-        label: 'Reports',
-        link: { to: '/reports' },
-        children: [
-          { id: 'reports-daily', label: 'Daily', link: { to: '/reports/daily' } },
-          { id: 'reports-weekly', label: 'Weekly', link: { to: '/reports/weekly' } },
-        ],
-      },
-    ]),
-    navGroup({ id: 'system', label: 'System', collapsible: true }, [
-      { id: 'usage', label: 'Usage', disabled: true, link: { to: '/usage', search: { r: '30d' } } },
-    ]),
-  ],
-})
-
-describe('defineNav / navGroup', () => {
-  test('defineNav is runtime identity — it returns the very object it was given', () => {
-    const config = { groups: [] } as const
-    expect(defineNav(config)).toBe(config)
-  })
-
-  test('navGroup merges meta and items into one plain object, preserving item order', () => {
-    const group = navGroup({ id: 'g', label: 'G', collapsible: true }, [
-      { id: 'a', label: 'A', link: { to: '/a' } },
-      { id: 'b', label: 'B', link: { to: '/b' } },
-    ])
-    expect(group).toEqual({
-      id: 'g',
-      label: 'G',
-      collapsible: true,
-      items: [
-        { id: 'a', label: 'A', link: { to: '/a' } },
-        { id: 'b', label: 'B', link: { to: '/b' } },
-      ],
-    })
-  })
-
-  test('navGroup does not mutate the meta object it was handed', () => {
-    const meta = { id: 'g', label: 'G' }
-    navGroup(meta, [{ id: 'a', label: 'A', link: { to: '/a' } }])
-    expect(meta).toEqual({ id: 'g', label: 'G' })
-  })
-})
-
-describe('flattenNav', () => {
-  test('walks depth-first — parent immediately before its own children', () => {
-    expect(flattenNav(NAV).map((d) => d.id)).toEqual([
-      'dash',
-      'reports',
-      'reports-daily',
-      'reports-weekly',
-      'usage',
-    ])
-  })
-
-  test('tags every destination — including nested children — with its declaring group', () => {
-    const byId = new Map(flattenNav(NAV).map((d) => [d.id, d]))
-    expect(byId.get('dash')).toMatchObject({ groupId: 'main', groupLabel: 'Main' })
-    expect(byId.get('reports-weekly')).toMatchObject({ groupId: 'main', groupLabel: 'Main' })
-    expect(byId.get('usage')).toMatchObject({ groupId: 'system', groupLabel: 'System' })
-  })
-
-  test('carries the authored metadata through untouched', () => {
-    const dash = flattenNav(NAV)[0]
-    expect(dash).toMatchObject({
-      label: 'Dashboard',
-      short: 'Home',
-      mobile: 'tab',
-      link: { to: '/dashboard' },
-    })
-  })
-
-  test('an empty definition flattens to an empty list', () => {
-    expect(flattenNav({ groups: [] })).toEqual([])
-  })
-})
-
-describe('navTarget', () => {
-  test('returns the destination link options by id', () => {
-    expect(navTarget(NAV, 'dash')).toEqual({ to: '/dashboard' })
-    expect(navTarget(NAV, 'usage')).toEqual({ to: '/usage', search: { r: '30d' } })
-  })
-
-  test('returns the SAME object the definition holds — spreadable with no copy', () => {
-    expect(navTarget(NAV, 'dash')).toBe(NAV.groups[0].items[0].link)
-  })
-
-  test('resolves ids nested under a parent destination', () => {
-    expect(navTarget(NAV, 'reports-weekly')).toEqual({ to: '/reports/weekly' })
-  })
-
-  test('throws a named error on an unknown id', () => {
-    // The id union makes this a compile error for a consumer; the throw is the runtime backstop
-    // for the untyped edge (a dynamic id, or an unregistered router degrading `NavItemId` away).
-    expect(() => navTarget(NAV, 'zzz' as 'dash')).toThrow('navTarget: no nav item with id "zzz"')
-  })
-})