@morscherlab/mint-sdk 1.2.0-beta.1 → 1.2.0-beta.3

package/src/__tests__/composables/useSampleGroups.tree.test.ts

@@ -1,145 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { useSampleGroups } from '../../composables/useSampleGroups'
-import type { SampleGroup } from '../../types'
-
-/**
- * `groupTree` is the full N-layer display model behind the sample selector:
- * interior nodes are path prefixes, leaves carry the concrete `SampleGroup`
- * (whose `name` stays the full path, since every mutation keys off it).
- */
-
-function labelsAtDepth(nodes: ReturnType<typeof useSampleGroups>['groupTree']['value'], depth: number): string[] {
-  let level = nodes
-  for (let i = 0; i < depth; i++) level = level.flatMap(n => n.children)
-  return level.map(n => n.label)
-}
-
-describe('useSampleGroups groupTree', () => {
-  const threeLayer: SampleGroup[] = [
-    { name: 'Liver / High / 5min', color: '#3B82F6', samples: ['L1', 'L2'] },
-    { name: 'Liver / High / 10min', color: '#3B82F6', samples: ['L3'] },
-    { name: 'Liver / Low / 5min', color: '#3B82F6', samples: ['L4'] },
-    { name: 'Kidney / High / 5min', color: '#F43F5E', samples: ['K1'] },
-  ]
-
-  it('should build one level per name segment', () => {
-    const { groupTree } = useSampleGroups({ groups: threeLayer })
-    expect(labelsAtDepth(groupTree.value, 0)).toEqual(['Liver', 'Kidney'])
-    expect(labelsAtDepth(groupTree.value, 1)).toEqual(['High', 'Low', 'High'])
-    expect(labelsAtDepth(groupTree.value, 2)).toEqual(['5min', '10min', '5min', '5min'])
-  })
-
-  it('should label each node with its own segment rather than the full path', () => {
-    const { groupTree } = useSampleGroups({ groups: threeLayer })
-    expect(groupTree.value[0].children[0].label).toBe('High')
-  })
-
-  it('should keep the full path on the leaf group so mutations still resolve it', () => {
-    const { groupTree } = useSampleGroups({ groups: threeLayer })
-    expect(groupTree.value[0].children[0].children[0].group?.name).toBe('Liver / High / 5min')
-  })
-
-  it('should aggregate every descendant sample onto an interior node', () => {
-    const { groupTree } = useSampleGroups({ groups: threeLayer })
-    expect(groupTree.value[0].allSamples).toEqual(['L1', 'L2', 'L3', 'L4'])
-    expect(groupTree.value[0].children[0].allSamples).toEqual(['L1', 'L2', 'L3'])
-  })
-
-  it('should mark only childless nodes as leaves', () => {
-    const { groupTree } = useSampleGroups({ groups: threeLayer })
-    expect(groupTree.value[0].children).not.toHaveLength(0)
-    expect(groupTree.value[0].group).toBeUndefined()
-    expect(groupTree.value[0].children[0].children[0].children).toHaveLength(0)
-  })
-
-  it('should give every node a unique key so expansion state cannot collide', () => {
-    const { groupTree } = useSampleGroups({ groups: threeLayer })
-    const keys: string[] = []
-    const walk = (nodes: typeof groupTree.value) => {
-      for (const n of nodes) {
-        keys.push(n.key)
-        walk(n.children)
-      }
-    }
-    walk(groupTree.value)
-    expect(new Set(keys).size).toBe(keys.length)
-  })
-
-  it('should keep two-segment names at two levels', () => {
-    const { groupTree } = useSampleGroups({
-      groups: [{ name: 'Control/A', color: '#3B82F6', samples: ['S1'] }],
-    })
-    expect(labelsAtDepth(groupTree.value, 0)).toEqual(['Control'])
-    expect(labelsAtDepth(groupTree.value, 1)).toEqual(['A'])
-    expect(labelsAtDepth(groupTree.value, 2)).toEqual([])
-  })
-
-  it('should keep an unsegmented name as a single root leaf', () => {
-    const { groupTree } = useSampleGroups({
-      groups: [{ name: 'Control', color: '#3B82F6', samples: ['S1'] }],
-    })
-    expect(groupTree.value).toHaveLength(1)
-    expect(groupTree.value[0].children).toHaveLength(0)
-    expect(groupTree.value[0].group?.name).toBe('Control')
-  })
-
-  it('should nest mixed-depth siblings under the same parent', () => {
-    const { groupTree } = useSampleGroups({
-      groups: [
-        { name: 'Liver / High / 5min', color: '#3B82F6', samples: ['S1'] },
-        { name: 'Liver / Low', color: '#3B82F6', samples: ['S2'] },
-      ],
-    })
-    expect(labelsAtDepth(groupTree.value, 1)).toEqual(['High', 'Low'])
-    // "Low" is a leaf at depth 1; "High" is interior with a leaf beneath it.
-    expect(groupTree.value[0].children[1].group?.name).toBe('Liver / Low')
-    expect(groupTree.value[0].children[0].children[0].group?.name).toBe('Liver / High / 5min')
-  })
-
-  it('should expose a group whose path duplicates an interior node as its own leaf', () => {
-    // "Liver" is both a standalone group and the prefix of another: the
-    // standalone group must stay reachable as a leaf, or its samples vanish.
-    const { groupTree } = useSampleGroups({
-      groups: [
-        { name: 'Liver', color: '#3B82F6', samples: ['S1'] },
-        { name: 'Liver / High', color: '#3B82F6', samples: ['S2'] },
-      ],
-    })
-    const allLeafGroups: string[] = []
-    const walk = (nodes: typeof groupTree.value) => {
-      for (const n of nodes) {
-        if (n.group) allLeafGroups.push(n.group.name)
-        walk(n.children)
-      }
-    }
-    walk(groupTree.value)
-    expect(allLeafGroups.sort()).toEqual(['Liver', 'Liver / High'])
-  })
-
-  it('should tolerate whitespace around separators when segmenting', () => {
-    const { groupTree } = useSampleGroups({
-      groups: [{ name: 'Liver / High', color: '#3B82F6', samples: ['S1'] }],
-    })
-    expect(groupTree.value[0].label).toBe('Liver')
-    expect(groupTree.value[0].children[0].label).toBe('High')
-  })
-})
-
-describe('useSampleGroups hierarchy depth', () => {
-  it('should report the deepest layer count', () => {
-    const { maxDepth } = useSampleGroups({
-      groups: [
-        { name: 'Liver / High / 5min', color: '#3B82F6', samples: ['S1'] },
-        { name: 'Kidney / Low', color: '#F43F5E', samples: ['S2'] },
-      ],
-    })
-    expect(maxDepth.value).toBe(3)
-  })
-
-  it('should report depth 1 for flat groups', () => {
-    const { maxDepth } = useSampleGroups({
-      groups: [{ name: 'Control', color: '#3B82F6', samples: ['S1'] }],
-    })
-    expect(maxDepth.value).toBe(1)
-  })
-})

package/src/__tests__/composables/useScheduleCalendarLayout.test.ts

@@ -1,89 +0,0 @@
-import { ref } from 'vue'
-import { describe, expect, it } from 'vitest'
-import type { ScheduleEvent, ScheduleView } from '../../types/components'
-import {
-  SCHEDULE_SLOT_HEIGHT,
-  getWeekStart,
-  parseScheduleModelDate,
-  useScheduleCalendarLayout,
-} from '../../composables/useScheduleCalendarLayout'
-
-function dateKey(date: Date): string {
-  const month = String(date.getMonth() + 1).padStart(2, '0')
-  const day = String(date.getDate()).padStart(2, '0')
-  return `${date.getFullYear()}-${month}-${day}`
-}
-
-function makeLayout(overrides: Partial<Parameters<typeof useScheduleCalendarLayout>[0]> = {}) {
-  const events: ScheduleEvent[] = [
-    {
-      id: 'run-1',
-      title: 'LCMS run',
-      start: '2024-05-15T07:00:00',
-      end: '2024-05-15T08:30:00',
-      status: 'in-progress',
-    },
-  ]
-
-  return useScheduleCalendarLayout({
-    currentView: ref<ScheduleView>('week'),
-    currentDate: ref(new Date('2024-05-15T12:00:00')),
-    now: ref(new Date('2024-05-15T07:30:00')),
-    events: ref(events),
-    blockedSlots: ref([
-      {
-        start: '2024-05-15T09:00:00',
-        end: '2024-05-15T09:30:00',
-        label: 'maintenance',
-      },
-    ]),
-    dayStartHour: ref(6),
-    dayEndHour: ref(10),
-    slotDuration: ref(30),
-    weekStartsOn: ref<0 | 1>(1),
-    locale: ref('en-US'),
-    showNowIndicator: ref(true),
-    slotHeight: ref(SCHEDULE_SLOT_HEIGHT),
-    ...overrides,
-  })
-}
-
-describe('useScheduleCalendarLayout', () => {
-  it('builds week ranges and time labels from calendar settings', () => {
-    const layout = makeLayout()
-
-    expect(layout.totalSlots.value).toBe(8)
-    expect(layout.timeLabels.value.slice(0, 3)).toEqual(['06:00', '06:30', '07:00'])
-    expect(dateKey(layout.visibleDays.value[0])).toBe('2024-05-13')
-    expect(dateKey(layout.visibleDays.value[6])).toBe('2024-05-19')
-  })
-
-  it('computes timed event, blocked slot, and now indicator styles', () => {
-    const layout = makeLayout()
-    const event = layout.getEventsForDate(new Date('2024-05-15T00:00:00'))[0]
-
-    expect(layout.getEventStyle(event, new Date('2024-05-15T00:00:00'))).toEqual({
-      top: '80px',
-      height: '120px',
-    })
-    expect(layout.getBlockedStyle(layout.getBlockedForDay(new Date('2024-05-15T00:00:00'))[0])).toEqual({
-      top: '240px',
-      height: '40px',
-    })
-    expect(layout.getNowIndicatorStyle()).toEqual({ top: '120px' })
-  })
-
-  it('builds month cells and weekday labels according to the week start', () => {
-    const layout = makeLayout({ currentView: ref<ScheduleView>('month') })
-
-    expect(layout.monthDays.value).toHaveLength(42)
-    expect(dateKey(layout.monthDays.value[0].date)).toBe('2024-04-29')
-    expect(layout.monthWeekdayLabels.value[0]).toBe('Mon')
-    expect(layout.headerTitle.value).toBe('May 2024')
-  })
-
-  it('parses model dates and honors alternate week starts', () => {
-    expect(parseScheduleModelDate('2024-05-15T00:00:00').getFullYear()).toBe(2024)
-    expect(dateKey(getWeekStart(new Date('2024-05-15T00:00:00'), 0))).toBe('2024-05-12')
-  })
-})

package/src/__tests__/composables/useSelectionLimit.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { ref } from 'vue'
-import { useSelectionLimit } from '../../composables/useSelectionLimit'
-
-describe('useSelectionLimit', () => {
-  it('tracks unlimited selections', () => {
-    const count = ref(4)
-    const limit = useSelectionLimit({ count })
-
-    expect(limit.isLimited.value).toBe(false)
-    expect(limit.canAddMore.value).toBe(true)
-    expect(limit.remaining.value).toBeUndefined()
-    expect(limit.canAdd(100)).toBe(true)
-  })
-
-  it('tracks remaining capacity from reactive count and max values', () => {
-    const count = ref(1)
-    const max = ref<number | undefined>(3)
-    const limit = useSelectionLimit({ count, max })
-
-    expect(limit.isLimited.value).toBe(true)
-    expect(limit.remaining.value).toBe(2)
-    expect(limit.canAdd(2)).toBe(true)
-    expect(limit.canAdd(3)).toBe(false)
-
-    count.value = 3
-    expect(limit.canAddMore.value).toBe(false)
-    expect(limit.isAtLimit.value).toBe(true)
-
-    max.value = undefined
-    expect(limit.isLimited.value).toBe(false)
-    expect(limit.canAdd(3)).toBe(true)
-  })
-
-  it('can evaluate a candidate count without mutating the current count', () => {
-    const limit = useSelectionLimit({ count: 1, max: 3 })
-
-    expect(limit.canAdd(1, 2)).toBe(true)
-    expect(limit.canAdd(1, 3)).toBe(false)
-  })
-})

package/src/__tests__/composables/useSortedItems.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { computed, ref } from 'vue'
-import {
-  compareSortValues,
-  useSortedItems,
-  type SortDescriptor,
-} from '../../composables/useSortedItems'
-
-describe('useSortedItems', () => {
-  const items = [
-    { name: 'Lactate', score: 2, supplier: 'Cayman' },
-    { name: 'Glucose', score: undefined, supplier: 'Sigma' },
-    { name: 'Pyruvate', score: 5, supplier: 'Thermo' },
-  ]
-
-  it('sorts by a reactive descriptor and keeps empty values last', () => {
-    const sort = ref<SortDescriptor<'score'>>({ key: 'score', direction: 'asc' })
-    const sorted = useSortedItems({
-      items,
-      sort,
-      getValue: (item, key) => item[key],
-    })
-
-    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
-      'Lactate',
-      'Pyruvate',
-      'Glucose',
-    ])
-
-    sort.value = { key: 'score', direction: 'desc' }
-    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
-      'Pyruvate',
-      'Lactate',
-      'Glucose',
-    ])
-  })
-
-  it('returns all items in original order when disabled', () => {
-    const enabled = ref(false)
-    const sorted = useSortedItems({
-      items: computed(() => items),
-      sort: { key: 'name', direction: 'asc' },
-      enabled,
-      getValue: item => item.name,
-    })
-
-    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
-      'Lactate',
-      'Glucose',
-      'Pyruvate',
-    ])
-
-    enabled.value = true
-    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
-      'Glucose',
-      'Lactate',
-      'Pyruvate',
-    ])
-  })
-
-  it('supports case-insensitive string comparison', () => {
-    const sorted = useSortedItems({
-      items: [
-        { name: 'beta' },
-        { name: 'Alpha' },
-        { name: 'gamma' },
-      ],
-      sort: { key: 'name', direction: 'asc' },
-      caseSensitive: false,
-      getValue: item => item.name,
-    })
-
-    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
-      'Alpha',
-      'beta',
-      'gamma',
-    ])
-  })
-
-  it('compares dates, numbers, strings, and empty values consistently', () => {
-    expect(compareSortValues(1, 2, 'asc')).toBeLessThan(0)
-    expect(compareSortValues(1, 2, 'desc')).toBeGreaterThan(0)
-    expect(compareSortValues(new Date('2026-01-01'), new Date('2026-02-01'))).toBeLessThan(0)
-    expect(compareSortValues(undefined, 2, 'asc')).toBeGreaterThan(0)
-    expect(compareSortValues(undefined, 2, 'desc')).toBeGreaterThan(0)
-  })
-})

package/src/__tests__/composables/useTemplateCollection.test.ts

@@ -1,147 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const mockGet = vi.fn()
-const mockPut = vi.fn()
-const mockDelete = vi.fn()
-const mockUseApi = vi.fn((_options?: unknown) => ({
-  get: mockGet,
-  put: mockPut,
-  delete: mockDelete,
-}))
-
-vi.mock('../../composables/useApi', () => ({
-  useApi: (options: unknown) => mockUseApi(options),
-}))
-
-import { useTemplateCollection } from '../../composables/useTemplateCollection'
-import {
-  createPlateMapTemplate,
-  createSampleSheetTemplate,
-  createTemplateCollection,
-  createWellPlateScreenCollection,
-} from '../../templates'
-import type { PlateMapTemplate, SampleSheetTemplate } from '../../templates'
-
-function setup(options?: Parameters<typeof useTemplateCollection>[0]) {
-  return useTemplateCollection(options)
-}
-
-describe('useTemplateCollection', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockGet.mockResolvedValue({})
-    mockPut.mockResolvedValue({})
-    mockDelete.mockResolvedValue({})
-    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
-    window.history.replaceState({}, '', '/')
-  })
-
-  it('initializes from a template collection envelope', () => {
-    const plate = createPlateMapTemplate({ samples: ['Control', 'Treatment'] })
-    const { templateIds, templates, metadata, hasTemplates, getTemplate, requireTemplate } = setup({
-      initial: createTemplateCollection([plate], { preset: 'unit-test' }),
-    })
-
-    expect(templateIds.value).toEqual(['plate-map'])
-    expect(Object.keys(templates.value)).toEqual(['plate-map'])
-    expect(metadata.value).toEqual({ preset: 'unit-test' })
-    expect(hasTemplates.value).toBe(true)
-    expect(getTemplate<PlateMapTemplate>('plate-map')?.data.samples[1].id).toBe('treatment')
-    expect(requireTemplate<PlateMapTemplate>('plate-map').template_id).toBe('plate-map')
-  })
-
-  it('applies, sets, removes, and resets local templates', () => {
-    const plate = createPlateMapTemplate({ samples: ['Control'] })
-    const sampleSheet = createSampleSheetTemplate({
-      samples: [{ sampleId: 'S001', name: 'Sample 1' }],
-    })
-    const { apply, setTemplate, removeTemplate, reset, templateIds, metadata } = setup({
-      initial: [plate],
-    })
-
-    setTemplate(sampleSheet)
-    expect(templateIds.value).toEqual(['plate-map', 'sample-sheet'])
-
-    expect(removeTemplate('plate-map')).toBe(true)
-    expect(templateIds.value).toEqual(['sample-sheet'])
-    expect(removeTemplate('missing')).toBe(false)
-
-    apply(createTemplateCollection([sampleSheet], { source: 'loaded' }))
-    expect(metadata.value).toEqual({ source: 'loaded' })
-
-    reset()
-    expect(templateIds.value).toEqual(['plate-map'])
-  })
-
-  it('uses fallback metadata only when the payload has none', () => {
-    const plate = createPlateMapTemplate({ samples: ['Control'] })
-    const { apply, metadata } = setup()
-
-    apply(createTemplateCollection([plate], { source: 'payload' }), { source: 'fallback' })
-    expect(metadata.value).toEqual({ source: 'payload' })
-
-    apply([plate], { source: 'fallback' })
-    expect(metadata.value).toEqual({ source: 'fallback' })
-  })
-
-  it('saves the local collection through experiment design_data', async () => {
-    const collection = createWellPlateScreenCollection({
-      samples: ['Control', 'Treatment'],
-      compounds: { Drug: [10, 1] },
-    })
-    const { save, lastSavedAt } = setup({ pluginId: 'p1', initial: collection })
-
-    const ok = await save(42)
-
-    expect(ok).toBe(true)
-    expect(lastSavedAt.value).toBeInstanceOf(Date)
-    expect(mockPut).toHaveBeenCalledWith('/experiments/42/data', {
-      plugin_id: 'p1',
-      data: collection,
-      schema_version: '1.0',
-    })
-  })
-
-  it('loads design_data into the local collection', async () => {
-    const sampleSheet = createSampleSheetTemplate({
-      samples: [
-        { sampleId: 'S001', name: 'Sample 1' },
-        { sampleId: 'S002', name: 'Sample 2' },
-      ],
-    })
-    mockGet.mockResolvedValueOnce(createTemplateCollection([sampleSheet], { source: 'api' }))
-    const { load, templateIds, metadata, requireTemplate, lastLoadedAt } = setup()
-
-    const loaded = await load(7)
-
-    expect(mockGet).toHaveBeenCalledWith('/experiments/7/data')
-    expect(loaded?.metadata).toEqual({ source: 'api' })
-    expect(templateIds.value).toEqual(['sample-sheet'])
-    expect(requireTemplate<SampleSheetTemplate>('sample-sheet').data.samples[1].sampleId).toBe(
-      'S002',
-    )
-    expect(metadata.value).toEqual({ source: 'api' })
-    expect(lastLoadedAt.value).toBeInstanceOf(Date)
-  })
-
-  it('saves the current URL experiment without route plumbing', async () => {
-    window.history.replaceState({}, '', '/plugins/template?experimentId=88')
-    const plate = createPlateMapTemplate({ samples: ['Control'] })
-    const { currentExperimentId, hasCurrentExperiment, saveCurrent } = setup({
-      pluginId: 'p1',
-      initial: [plate],
-    })
-
-    expect(currentExperimentId.value).toBe(88)
-    expect(hasCurrentExperiment.value).toBe(true)
-
-    const ok = await saveCurrent()
-
-    expect(ok).toBe(true)
-    expect(mockPut).toHaveBeenCalledWith('/experiments/88/data', {
-      plugin_id: 'p1',
-      data: createTemplateCollection([plate]),
-      schema_version: '1.0',
-    })
-  })
-})

package/src/__tests__/composables/useTextSearch.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { computed, ref } from 'vue'
-import {
-  candidateMatchesSearch,
-  normalizeSearchQuery,
-  useTextSearch,
-} from '../../composables/useTextSearch'
-
-describe('useTextSearch', () => {
-  const items = [
-    { name: 'Glucose', catalogNumber: 'G-7528', supplier: 'Sigma' },
-    { name: 'Lactate', catalogNumber: 'L-1250', supplier: 'Cayman' },
-    { name: 'Pyruvate', catalogNumber: 'P-2256', supplier: 'Thermo' },
-  ]
-
-  it('normalizes whitespace and case', () => {
-    expect(normalizeSearchQuery('  GLU  ')).toBe('glu')
-    expect(normalizeSearchQuery(undefined)).toBe('')
-  })
-
-  it('filters by multiple candidate values', () => {
-    const query = ref('cay')
-    const search = useTextSearch({
-      items,
-      query,
-      getText: item => [item.name, item.catalogNumber, item.supplier],
-    })
-
-    expect(search.filteredItems.value.map(item => item.name)).toEqual(['Lactate'])
-
-    query.value = ' p-2256 '
-    expect(search.filteredItems.value.map(item => item.name)).toEqual(['Pyruvate'])
-  })
-
-  it('returns all items when disabled', () => {
-    const enabled = ref(false)
-    const search = useTextSearch({
-      items: computed(() => items),
-      query: 'sigma',
-      enabled,
-      getText: item => item.supplier,
-    })
-
-    expect(search.filteredItems.value).toHaveLength(3)
-
-    enabled.value = true
-    expect(search.filteredItems.value.map(item => item.name)).toEqual(['Glucose'])
-  })
-
-  it('matches empty queries and ignores nullish candidates', () => {
-    expect(candidateMatchesSearch([null, undefined, 'Alpha'], '')).toBe(true)
-    expect(candidateMatchesSearch([null, undefined, 'Alpha'], 'alp')).toBe(true)
-    expect(candidateMatchesSearch([null, undefined], 'alp')).toBe(false)
-  })
-})

package/src/__tests__/composables/useTheme.test.ts

@@ -1,91 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { nextTick } from 'vue'
-import { createPinia, setActivePinia } from 'pinia'
-import { useTheme } from '../../composables/useTheme'
-import { useSettingsStore } from '../../stores/settings'
-
-function mockMatchMedia(initialMatches = false) {
-  let matches = initialMatches
-  let changeListener: ((event: MediaQueryListEvent) => void) | undefined
-
-  const mediaQuery = {
-    get matches() {
-      return matches
-    },
-    media: '(prefers-color-scheme: dark)',
-    onchange: null,
-    addEventListener: vi.fn((_event: 'change', listener: (event: MediaQueryListEvent) => void) => {
-      changeListener = listener
-    }),
-    removeEventListener: vi.fn(),
-    addListener: vi.fn(),
-    removeListener: vi.fn(),
-    dispatchEvent: vi.fn(),
-  } as unknown as MediaQueryList
-
-  Object.defineProperty(window, 'matchMedia', {
-    configurable: true,
-    writable: true,
-    value: vi.fn(() => mediaQuery),
-  })
-
-  return {
-    mediaQuery,
-    setMatches(value: boolean) {
-      matches = value
-      changeListener?.({ matches: value } as MediaQueryListEvent)
-    },
-  }
-}
-
-describe('useTheme', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    vi.restoreAllMocks()
-    const storage: Record<string, string> = {}
-    vi.stubGlobal('localStorage', {
-      getItem: vi.fn((key: string) => storage[key] ?? null),
-      setItem: vi.fn((key: string, value: string) => { storage[key] = value }),
-      removeItem: vi.fn((key: string) => { delete storage[key] }),
-      clear: vi.fn(() => {
-        for (const key of Object.keys(storage)) delete storage[key]
-      }),
-    })
-    document.documentElement.classList.remove('dark')
-  })
-
-  it('reads system color scheme from the settings store reactively', async () => {
-    const system = mockMatchMedia(true)
-    const settings = useSettingsStore()
-    const { isDark } = useTheme()
-
-    expect(settings.theme).toBe('system')
-    expect(settings.systemPrefersDark).toBe(true)
-    expect(isDark.value).toBe(true)
-    expect(document.documentElement.classList.contains('dark')).toBe(true)
-
-    system.setMatches(false)
-    await nextTick()
-
-    expect(settings.systemPrefersDark).toBe(false)
-    expect(isDark.value).toBe(false)
-    expect(document.documentElement.classList.contains('dark')).toBe(false)
-  })
-
-  it('keeps explicit light and dark choices independent from system changes', async () => {
-    const system = mockMatchMedia(true)
-    const { isDark, setTheme } = useTheme()
-
-    setTheme('light')
-    await nextTick()
-    expect(isDark.value).toBe(false)
-
-    system.setMatches(false)
-    await nextTick()
-    expect(isDark.value).toBe(false)
-
-    setTheme('dark')
-    await nextTick()
-    expect(isDark.value).toBe(true)
-  })
-})