@open-mercato/ui 0.6.7-develop.6860.1.f796b22e80 → 0.6.7

package/src/backend/__tests__/CrudForm.groupInjectionColumn.test.tsx

@@ -1,98 +0,0 @@
-/** @jest-environment jsdom */
-jest.setTimeout(15000)
-
-// Regression guard for #4400: an injected group widget placed in column 1 must
-// render as a full-width row in the main stack — CrudForm must NOT switch to
-// the narrow 7fr/3fr secondary-column layout unless a widget explicitly asks
-// for column 2. The hook is mocked so the test drives the injected widgets
-// directly, following the CrudForm.fieldInjection.test.tsx pattern.
-let injectedGroupWidgets: unknown[] = []
-
-jest.mock('next/navigation', () => ({
-  useRouter: () => ({ push: () => {} }),
-  usePathname: () => '/',
-  useSearchParams: () => new URLSearchParams(),
-}))
-jest.mock('remark-gfm', () => ({ __esModule: true, default: {} }))
-jest.mock('../injection/InjectionSpot', () => ({
-  __esModule: true,
-  InjectionSpot: () => null,
-  useInjectionWidgets: () => ({ widgets: injectedGroupWidgets, loading: false, error: null }),
-  useInjectionSpotEvents: () => ({ triggerEvent: jest.fn(async () => ({ ok: true, data: {} })) }),
-}))
-jest.mock('../injection/useInjectionDataWidgets', () => ({
-  __esModule: true,
-  useInjectionDataWidgets: () => ({ widgets: [], isLoading: false, error: null }),
-}))
-
-import * as React from 'react'
-import { waitFor } from '@testing-library/react'
-import { renderWithProviders } from '@open-mercato/shared/lib/testing/renderWithProviders'
-import { CrudForm, type CrudField, type CrudFormGroup } from '../CrudForm'
-
-const fields: CrudField[] = [
-  { id: 'name', label: 'Name', type: 'text' },
-]
-
-const groups: CrudFormGroup[] = [
-  { id: 'contact', label: 'Contact', fields: ['name'] },
-]
-
-function makeGroupWidget(column: 1 | 2) {
-  return {
-    widgetId: 'customer_accounts.injection.company-users',
-    placement: { kind: 'group', column, groupLabel: 'Portal users', priority: 200 },
-    module: {
-      metadata: { title: 'Portal users', description: '' },
-      Widget: () => <div data-testid="portal-users-widget">portal users</div>,
-    },
-  }
-}
-
-function renderForm() {
-  return renderWithProviders(
-    React.createElement(CrudForm as never, {
-      title: 'Company',
-      entityId: 'customers:company',
-      fields,
-      groups,
-      onSubmit: () => {},
-    }),
-  )
-}
-
-describe('CrudForm injected group column placement (#4400)', () => {
-  afterEach(() => {
-    injectedGroupWidgets = []
-  })
-
-  it('renders a column-1 group widget as a full-width row without the secondary column', async () => {
-    injectedGroupWidgets = [makeGroupWidget(1)]
-
-    const { container } = renderForm()
-
-    await waitFor(() => {
-      expect(container.querySelector('[data-testid="portal-users-widget"]')).toBeTruthy()
-    })
-
-    expect(container.querySelector('[data-crud-injection-region]')).toBeNull()
-    const twoColumnGrid = Array.from(container.querySelectorAll('div')).find((node) =>
-      node.className.includes('7fr_3fr'),
-    )
-    expect(twoColumnGrid).toBeUndefined()
-  })
-
-  it('still supports an explicit column-2 group widget via the secondary column (sanity)', async () => {
-    injectedGroupWidgets = [makeGroupWidget(2)]
-
-    const { container } = renderForm()
-
-    await waitFor(() => {
-      expect(container.querySelector('[data-testid="portal-users-widget"]')).toBeTruthy()
-    })
-
-    const secondaryRegion = container.querySelector('[data-crud-injection-region]')
-    expect(secondaryRegion).toBeTruthy()
-    expect(secondaryRegion?.querySelector('[data-testid="portal-users-widget"]')).toBeTruthy()
-  })
-})

package/src/backend/__tests__/DataTable.metaHiddenLateColumns.test.tsx

@@ -1,105 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import * as React from 'react'
-import { render, screen, waitFor } from '@testing-library/react'
-import type { ColumnDef } from '@tanstack/react-table'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { I18nProvider } from '@open-mercato/shared/lib/i18n/context'
-import { DataTable } from '../DataTable'
-
-jest.mock('next/navigation', () => ({
-  useRouter: () => ({ push: jest.fn(), replace: jest.fn(), prefetch: jest.fn(), refresh: jest.fn() }),
-}))
-
-jest.mock('../injection/useInjectionDataWidgets', () => ({
-  useInjectionDataWidgets: () => ({ widgets: [], isLoading: false }),
-}))
-
-jest.mock('@open-mercato/shared/modules/widgets/injection-loader', () => ({
-  getInjectionRegistryVersion: () => 0,
-  subscribeToInjectionRegistryChanges: () => () => {},
-  loadInjectionWidgetsForSpot: jest.fn(async () => []),
-  loadInjectionDataWidgetsForSpot: jest.fn(async () => []),
-}))
-
-type Row = { id: string; name: string }
-
-const ROWS: Row[] = [{ id: '1', name: 'Row one' }]
-
-const BASE_COLUMNS: ColumnDef<Row>[] = [
-  { accessorKey: 'name', header: 'Name' },
-]
-
-const COLUMNS_WITH_CUSTOM_FIELDS: ColumnDef<Row>[] = [
-  ...BASE_COLUMNS,
-  { accessorKey: 'cf_archived_note', header: 'Archived note', meta: { hidden: true } },
-  { accessorKey: 'cf_active_note', header: 'Active note' },
-]
-
-function Harness({ columns, initialSettings }: { columns: ColumnDef<Row>[]; initialSettings?: unknown }) {
-  const queryClient = React.useMemo(
-    () => new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 0 } } }),
-    [],
-  )
-  return (
-    <QueryClientProvider client={queryClient}>
-      <I18nProvider locale="en" dict={{}}>
-        <DataTable
-          columns={columns as never}
-          data={ROWS as never}
-          {...(initialSettings
-            ? ({ perspective: { tableId: 'meta-hidden-late-columns', initialState: { initialSettings } } } as never)
-            : {})}
-        />
-      </I18nProvider>
-    </QueryClientProvider>
-  )
-}
-
-describe('DataTable — meta.hidden on columns that arrive after the first render', () => {
-  it('hides a meta.hidden column that only appears on a later render', async () => {
-    // The regression: the auto-hide pass used to be latched by a single boolean ref, so it
-    // ran on the first render — when no `cf_*` column existed yet — found nothing to hide,
-    // and never ran again. Custom fields declared `listVisible: false` stayed visible for
-    // the whole session after a hard page load, while a client-side navigation (definitions
-    // already in the query cache) rendered them correctly.
-    const { rerender } = render(<Harness columns={BASE_COLUMNS} />)
-    await waitFor(() => expect(screen.getByText('Name')).toBeTruthy())
-
-    rerender(<Harness columns={COLUMNS_WITH_CUSTOM_FIELDS} />)
-
-    await waitFor(() => expect(screen.queryByText('Archived note')).toBeNull())
-  })
-
-  it('leaves a late column without meta.hidden visible', async () => {
-    // Pins the other half of the contract, so the fix can never degrade into
-    // "columns that arrive late are dropped".
-    const { rerender } = render(<Harness columns={BASE_COLUMNS} />)
-    await waitFor(() => expect(screen.getByText('Name')).toBeTruthy())
-
-    rerender(<Harness columns={COLUMNS_WITH_CUSTOM_FIELDS} />)
-
-    await waitFor(() => expect(screen.getByText('Active note')).toBeTruthy())
-  })
-
-  it('hides a meta.hidden column that is present from the very first render', async () => {
-    // The behaviour the original latch was written for, which must survive the fix.
-    render(<Harness columns={COLUMNS_WITH_CUSTOM_FIELDS} />)
-
-    await waitFor(() => expect(screen.getByText('Active note')).toBeTruthy())
-    expect(screen.queryByText('Archived note')).toBeNull()
-  })
-
-  it('lets a stored perspective override the meta.hidden defaults', async () => {
-    // A saved perspective seeds columnVisibility at mount and wins outright.
-    render(
-      <Harness
-        columns={COLUMNS_WITH_CUSTOM_FIELDS}
-        initialSettings={{ columnVisibility: { cf_archived_note: true } }}
-      />,
-    )
-
-    await waitFor(() => expect(screen.getByText('Archived note')).toBeTruthy())
-  })
-})

package/src/backend/icons/__tests__/lucideRegistryGenerator.test.ts

@@ -1,177 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { Project, ScriptKind, SyntaxKind, type ObjectLiteralExpression, type SourceFile } from 'ts-morph'
-import { buildLucideRegistrySource } from '../../../../scripts/lucideRegistrySource.cjs'
-
-const packageDir = join(__dirname, '..', '..', '..', '..')
-const iconsDir = join(packageDir, 'src', 'backend', 'icons')
-
-type ResolvedIcon = { kebab: string; exportName: string }
-
-const populatedFixture: ResolvedIcon[] = [
-  { kebab: 'bell', exportName: 'Bell' },
-  { kebab: 'alert-circle', exportName: 'AlertCircle' },
-  { kebab: 'bar-chart-2', exportName: 'BarChart2' },
-]
-
-const duplicateExportFixture: ResolvedIcon[] = [
-  { kebab: 'trash', exportName: 'Trash' },
-  { kebab: 'trash-can', exportName: 'Trash' },
-]
-
-function parse(source: string): SourceFile {
-  const project = new Project({ useInMemoryFileSystem: true })
-  return project.createSourceFile('lucideRegistry.generated.tsx', source, {
-    overwrite: true,
-    scriptKind: ScriptKind.TSX,
-  })
-}
-
-function syntacticDiagnostics(source: string): string[] {
-  const sourceFile = parse(source)
-  return sourceFile
-    .getProject()
-    .getProgram()
-    .getSyntacticDiagnostics(sourceFile)
-    .map((diagnostic) => `${diagnostic.getLineNumber() ?? 0}: ${diagnostic.getMessageText()}`)
-}
-
-function registryObject(source: string): ObjectLiteralExpression {
-  const declaration = parse(source).getVariableDeclarationOrThrow('LUCIDE_ICON_REGISTRY')
-  return declaration.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression)
-}
-
-function registryEntries(source: string): Record<string, string> {
-  const entries: Record<string, string> = {}
-  for (const property of registryObject(source).getProperties()) {
-    const assignment = property.asKindOrThrow(SyntaxKind.PropertyAssignment)
-    entries[assignment.getSymbolOrThrow().getName()] = assignment.getInitializerOrThrow().getText()
-  }
-  return entries
-}
-
-function valueImportNames(source: string, moduleSpecifier: string): string[] {
-  return parse(source)
-    .getImportDeclarations()
-    .filter((declaration) => declaration.getModuleSpecifierValue() === moduleSpecifier)
-    .filter((declaration) => !declaration.isTypeOnly())
-    .flatMap((declaration) => declaration.getNamedImports().map((named) => named.getName()))
-}
-
-describe('buildLucideRegistrySource', () => {
-  it('maps every discovered kebab name to its lucide export', () => {
-    expect(registryEntries(buildLucideRegistrySource(populatedFixture))).toEqual({
-      'alert-circle': 'AlertCircle',
-      'bar-chart-2': 'BarChart2',
-      bell: 'Bell',
-    })
-  })
-
-  it('emits the registry keys sorted by kebab name', () => {
-    const keys = registryObject(buildLucideRegistrySource(populatedFixture))
-      .getProperties()
-      .map((property) => property.asKindOrThrow(SyntaxKind.PropertyAssignment).getSymbolOrThrow().getName())
-    expect(keys).toEqual(['alert-circle', 'bar-chart-2', 'bell'])
-  })
-
-  it('imports each lucide export exactly once', () => {
-    expect(valueImportNames(buildLucideRegistrySource(populatedFixture), 'lucide-react')).toEqual([
-      'AlertCircle',
-      'BarChart2',
-      'Bell',
-    ])
-  })
-
-  it('quotes keys that are not valid identifiers', () => {
-    const property = registryObject(buildLucideRegistrySource(populatedFixture))
-      .getPropertyOrThrow("'bar-chart-2'")
-      .asKindOrThrow(SyntaxKind.PropertyAssignment)
-    expect(property.getNameNode().getKind()).toBe(SyntaxKind.StringLiteral)
-  })
-
-  it('de-duplicates the value import when two names share one export', () => {
-    const source = buildLucideRegistrySource(duplicateExportFixture)
-    expect(valueImportNames(source, 'lucide-react')).toEqual(['Trash'])
-    expect(registryEntries(source)).toEqual({ trash: 'Trash', 'trash-can': 'Trash' })
-  })
-
-  it('emits a valid module with an empty registry when no icons are discovered', () => {
-    const source = buildLucideRegistrySource([])
-    expect(registryObject(source).getProperties()).toHaveLength(0)
-    expect(valueImportNames(source, 'lucide-react')).toEqual([])
-    expect(source).not.toContain("import {} from 'lucide-react'")
-  })
-
-  it('keeps the registry a plain mutable object literal', () => {
-    const source = buildLucideRegistrySource(populatedFixture)
-    const declaration = parse(source).getVariableDeclarationOrThrow('LUCIDE_ICON_REGISTRY')
-    expect(declaration.getTypeNodeOrThrow().getText()).toBe('Record<string, LucideIcon>')
-    expect(declaration.getVariableStatementOrThrow().isExported()).toBe(true)
-    expect(source).not.toContain('as const')
-    expect(source).not.toContain('Object.freeze')
-  })
-
-  it('keeps the LucideIcon import type-only', () => {
-    const typeOnly = parse(buildLucideRegistrySource(populatedFixture))
-      .getImportDeclarations()
-      .filter((declaration) => declaration.isTypeOnly())
-      .flatMap((declaration) => declaration.getNamedImports().map((named) => named.getName()))
-    expect(typeOnly).toEqual(['LucideIcon'])
-  })
-
-  it.each([
-    ['populated', populatedFixture],
-    ['empty', [] as ResolvedIcon[]],
-    ['duplicate exports', duplicateExportFixture],
-  ])('emits %s output with zero syntactic diagnostics', (_label, fixture) => {
-    expect(syntacticDiagnostics(buildLucideRegistrySource(fixture))).toEqual([])
-  })
-
-  it('fails loudly when an export name would produce an unparseable module', () => {
-    expect(() => buildLucideRegistrySource([{ kebab: 'broken', exportName: 'not a valid export' }])).toThrow(
-      /not syntactically valid/
-    )
-  })
-})
-
-describe('lucideRegistry barrel', () => {
-  it('keeps its public export list unchanged', () => {
-    const project = new Project({ useInMemoryFileSystem: true })
-    const barrel = project.createSourceFile(
-      'lucideRegistry.ts',
-      readFileSync(join(iconsDir, 'lucideRegistry.ts'), 'utf-8'),
-      { overwrite: true }
-    )
-    expect([...barrel.getExportedDeclarations().keys()].sort()).toEqual([
-      'LUCIDE_ICON_REGISTRY',
-      'registerAdditionalIcons',
-      'resolveRegisteredLucideIcon',
-      'resolveRegisteredLucideIconNode',
-    ])
-  })
-})
-
-describe('lucideRegistry.generated importers', () => {
-  it('is imported only from within src/backend/icons', () => {
-    const repoRoot = join(packageDir, '..', '..')
-    let matches: string[] = []
-    try {
-      matches = execFileSync(
-        'git',
-        ['grep', '-l', 'lucideRegistry.generated', '--', '*.ts', '*.tsx'],
-        { cwd: repoRoot, encoding: 'utf-8' }
-      )
-        .split('\n')
-        .filter(Boolean)
-    } catch (error) {
-      const status = (error as { status?: number }).status
-      if (status !== 1) throw error
-    }
-
-    const outsideIconsFolder = matches.filter(
-      (path) => !path.startsWith('packages/ui/src/backend/icons/')
-    )
-    expect(outsideIconsFolder).toEqual([])
-  })
-})

package/src/backend/icons/lucideRegistryRuntime.tsx

@@ -1,36 +0,0 @@
-import type * as React from 'react'
-import type { LucideIcon } from 'lucide-react'
-import { LUCIDE_ICON_REGISTRY } from './lucideRegistry.generated'
-
-function normalizeKebabIconName(input: string): string {
-  const trimmed = input.trim()
-  if (!trimmed) return ''
-  const withoutPrefix = trimmed.startsWith('lucide:') ? trimmed.slice('lucide:'.length) : trimmed
-  if (!withoutPrefix) return ''
-  if (!withoutPrefix.includes('-') && !withoutPrefix.includes('_') && !withoutPrefix.includes(' ') && /[A-Z]/.test(withoutPrefix)) {
-    return withoutPrefix
-      .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-      .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-      .toLowerCase()
-  }
-  return withoutPrefix
-    .replace(/[_\s]+/g, '-')
-    .replace(/-+/g, '-')
-    .toLowerCase()
-}
-
-export function resolveRegisteredLucideIcon(name: string | undefined): LucideIcon | null {
-  if (!name) return null
-  const normalized = normalizeKebabIconName(name)
-  if (!normalized) return null
-  return (LUCIDE_ICON_REGISTRY as Record<string, LucideIcon | undefined>)[normalized] ?? null
-}
-
-export function resolveRegisteredLucideIconNode(
-  name: string | undefined,
-  className: string
-): React.ReactNode | null {
-  const Icon = resolveRegisteredLucideIcon(name)
-  if (!Icon) return null
-  return <Icon className={className} />
-}

package/src/backend/injection/__tests__/spotIds.extension-points.test.ts

@@ -1,38 +0,0 @@
-import {
-  CRUD_FORM_EXTENSION_SURFACES,
-  DATA_TABLE_EXTENSION_SURFACES,
-} from '@open-mercato/shared/modules/widgets/extension-points'
-import { CrudFormInjectionSpots, DataTableInjectionSpots } from '../spotIds'
-
-describe('standard extension point spot IDs', () => {
-  it('keeps every bound DataTable suffix aligned with the runtime helper', () => {
-    const tableId = 'catalog.products.list'
-    const boundSuffixes = DATA_TABLE_EXTENSION_SURFACES
-      .filter((surface) => surface.bound && surface.suffix)
-      .map((surface) => surface.suffix)
-
-    expect(boundSuffixes).toEqual([
-      'header',
-      'footer',
-      'toolbar',
-      'search-trailing',
-      'columns',
-      'row-actions',
-      'bulk-actions',
-      'filters',
-    ])
-    expect(DataTableInjectionSpots.emptyState(tableId)).toBe('data-table:catalog.products.list:empty-state')
-  })
-
-  it('keeps bound CrudForm spots distinct from helper-only spots', () => {
-    const entityId = 'catalog.product'
-    const boundKeys = CRUD_FORM_EXTENSION_SURFACES
-      .filter((surface) => surface.bound)
-      .map((surface) => surface.key)
-
-    expect(boundKeys).toEqual(['base', 'header', 'fields', 'replacement'])
-    expect(CrudFormInjectionSpots.base(entityId)).toBe('crud-form:catalog.product')
-    expect(CrudFormInjectionSpots.header(entityId)).toBe('crud-form:catalog.product:header')
-    expect(CrudFormInjectionSpots.fields(entityId)).toBe('crud-form:catalog.product:fields')
-  })
-})

package/src/backend/perspectiveState.ts

@@ -1,44 +0,0 @@
-export const PERSPECTIVE_COOKIE_PREFIX = 'om_table_perspective'
-export const PERSPECTIVE_STORAGE_PREFIX = 'om_table_perspective_snapshot'
-
-/**
- * Purge every browser-local DataTable perspective snapshot and active-view cookie
- * across all tables in this origin. Snapshots persist the unsaved/live table state
- * (column widths, order, visibility) keyed only by `tableId`, so they are shared by
- * every account that signs in on the same browser profile. Call this at the auth
- * identity boundary so one user's unsaved layout never carries over to a different
- * user — including a different tenant — reusing the same browser tab (#4185).
- *
- * Lives here rather than in DataTable so the backend shell can call it without
- * pulling the whole table implementation into the bundle of every backend page.
- * `@open-mercato/ui/backend/DataTable` re-exports it, which is the published
- * import path and must stay stable.
- */
-export function clearAllPerspectiveState(): void {
-  if (typeof window !== 'undefined') {
-    try {
-      const storage = window.localStorage
-      const staleKeys: string[] = []
-      for (let index = 0; index < storage.length; index += 1) {
-        const key = storage.key(index)
-        if (key && key.startsWith(`${PERSPECTIVE_STORAGE_PREFIX}:`)) staleKeys.push(key)
-      }
-      for (const key of staleKeys) storage.removeItem(key)
-    } catch {
-      // private mode / quota errors are non-fatal
-    }
-  }
-  if (typeof document !== 'undefined') {
-    try {
-      const cookies = document.cookie ? document.cookie.split(';') : []
-      for (const cookie of cookies) {
-        const name = cookie.split('=')[0]?.trim()
-        if (name && name.startsWith(`${PERSPECTIVE_COOKIE_PREFIX}:`)) {
-          document.cookie = `${name}=; Path=/; Max-Age=0; SameSite=Lax`
-        }
-      }
-    } catch {
-      // ignore — cookie access can throw in sandboxed contexts
-    }
-  }
-}

package/src/backend/sidebar/__tests__/group-visibility.test.ts

@@ -1,131 +0,0 @@
-import {
-  applyGroupHidden,
-  collectGroupItemKeys,
-  resolveGroupVisibility,
-  resolveItemKey,
-  type SidebarGroup,
-} from '../customization-helpers'
-
-// Hiding a whole group used to require toggling every item in it individually — `AppShell` drops a
-// group only once *all* of its items are hidden. These cases cover the bulk toggle that does it in one
-// action, and pin the invariant that matters for compatibility: it writes the same `hiddenItemIds`
-// keys the per-item switches write, and nothing else.
-
-const group: SidebarGroup = {
-  id: 'catalog.nav.group',
-  name: 'Catalog',
-  items: [
-    { href: '/backend/catalog/products', title: 'Products' },
-    {
-      href: '/backend/catalog/categories',
-      title: 'Categories',
-      children: [
-        { href: '/backend/catalog/categories/tree', title: 'Tree' },
-        { href: '/backend/catalog/categories/import', title: 'Import' },
-      ],
-    },
-  ],
-}
-
-const ALL_KEYS = [
-  '/backend/catalog/products',
-  '/backend/catalog/categories',
-  '/backend/catalog/categories/tree',
-  '/backend/catalog/categories/import',
-]
-
-describe('collectGroupItemKeys', () => {
-  it('includes top-level items and every nested descendant', () => {
-    expect(collectGroupItemKeys(group).sort()).toEqual([...ALL_KEYS].sort())
-  })
-
-  it('returns nothing for an empty group', () => {
-    expect(collectGroupItemKeys({ id: 'empty', name: 'Empty', items: [] })).toEqual([])
-  })
-
-  it('prefers an explicit item id over the href, matching resolveItemKey', () => {
-    const withIds: SidebarGroup = {
-      id: 'g',
-      name: 'G',
-      items: [{ id: 'custom-id', href: '/backend/thing', title: 'Thing' }],
-    }
-
-    expect(collectGroupItemKeys(withIds)).toEqual([resolveItemKey(withIds.items[0])])
-  })
-})
-
-describe('resolveGroupVisibility', () => {
-  it('is visible when nothing is hidden', () => {
-    expect(resolveGroupVisibility(group, {})).toBe('visible')
-  })
-
-  it('is hidden only when every item including descendants is hidden', () => {
-    const allHidden = Object.fromEntries(ALL_KEYS.map((key) => [key, true]))
-
-    expect(resolveGroupVisibility(group, allHidden)).toBe('hidden')
-  })
-
-  it('is partial when some but not all items are hidden', () => {
-    expect(resolveGroupVisibility(group, { '/backend/catalog/products': true })).toBe('partial')
-  })
-
-  it('is partial when only a nested descendant is left visible', () => {
-    const allButOne = Object.fromEntries(
-      ALL_KEYS.filter((key) => key !== '/backend/catalog/categories/import').map((key) => [key, true]),
-    )
-
-    expect(resolveGroupVisibility(group, allButOne)).toBe('partial')
-  })
-
-  it('treats an empty group as visible rather than hidden', () => {
-    expect(resolveGroupVisibility({ id: 'empty', name: 'Empty', items: [] }, {})).toBe('visible')
-  })
-})
-
-describe('applyGroupHidden', () => {
-  it('hides every item in the group, descendants included', () => {
-    const next = applyGroupHidden({}, group, true)
-
-    expect(Object.keys(next).sort()).toEqual([...ALL_KEYS].sort())
-    expect(resolveGroupVisibility(group, next)).toBe('hidden')
-  })
-
-  it('clears every item in the group when shown', () => {
-    const hidden = applyGroupHidden({}, group, true)
-    const next = applyGroupHidden(hidden, group, false)
-
-    expect(next).toEqual({})
-    expect(resolveGroupVisibility(group, next)).toBe('visible')
-  })
-
-  it('leaves keys belonging to other groups untouched', () => {
-    const other = { '/backend/sales/orders': true }
-
-    expect(applyGroupHidden(other, group, true)['/backend/sales/orders']).toBe(true)
-    expect(applyGroupHidden(other, group, false)).toEqual(other)
-  })
-
-  it('does not mutate the input map', () => {
-    const input = { '/backend/sales/orders': true }
-    const snapshot = { ...input }
-
-    applyGroupHidden(input, group, true)
-
-    expect(input).toEqual(snapshot)
-  })
-
-  it('reaches the same state as toggling each item by hand', () => {
-    const byHand = ALL_KEYS.reduce<Record<string, boolean>>((acc, key) => {
-      acc[key] = true
-      return acc
-    }, {})
-
-    expect(applyGroupHidden({}, group, true)).toEqual(byHand)
-  })
-
-  it('is idempotent', () => {
-    const once = applyGroupHidden({}, group, true)
-
-    expect(applyGroupHidden(once, group, true)).toEqual(once)
-  })
-})