@morscherlab/mint-sdk 1.4.0-beta.8 → 1.4.0

package/src/__tests__/components/SampleSelector.test.ts

@@ -97,7 +97,7 @@ describe('SampleSelector', () => {
       },
     })
 
-    expect(wrapper.find('.mint-sample-selector__select-all-count').text()).toBe('0 / 2')
+    expect(wrapper.find('.mint-sample-selector__select-all-count').text()).toBe('0/2')
     expect(wrapper.findAll('.mint-sample-selector__flat-name').map(item => item.text())).toEqual(['S1', 'S2'])
   })
 
@@ -115,9 +115,9 @@ describe('SampleSelector', () => {
       },
     })
 
-    const labels = wrapper.findAll('.mint-sample-selector__actions-row .mint-sample-selector__action-label')
-    expect(labels.map(label => label.text())).toEqual(['Grouping'])
-    expect(wrapper.findAll('.mint-sample-selector__actions-row > .mint-sample-selector__action-btn')).toHaveLength(2)
+    const buttons = wrapper.findAll('.mint-sample-selector__header-actions > .mint-sample-selector__action-btn')
+    expect(buttons.map(button => button.text())).toEqual(['Smart group'])
+    expect(wrapper.find('.mint-sample-selector__header').text()).toContain('Samples0 selected')
 
     await wrapper.findAllComponents({ name: 'BaseButton' })[0].trigger('click')
 
@@ -125,6 +125,26 @@ describe('SampleSelector', () => {
     expect(modal.props('initialMode')).toBe('auto')
   })
 
+  it.each([
+    [true, 'Smart group'],
+    [false, 'Group'],
+  ])('should keep the grouping label as accessible name and tooltip when smart group is %s', (enableSmartGroup, label) => {
+    const wrapper = mount(SampleSelector, {
+      props: { samples: ['S1', 'S2'], modelValue: ['S1'], groups: [], enableSmartGroup },
+      global: { stubs: { AutoGroupModalInternal: true } },
+    })
+    const button = wrapper.get('.mint-sample-selector__header-actions > .mint-sample-selector__action-btn')
+    const count = wrapper.get('.mint-sample-selector__selected')
+
+    expect({
+      name: button.text(),
+      title: button.attributes('title'),
+      full: count.get('.mint-sample-selector__selected-full').text(),
+      short: count.get('.mint-sample-selector__selected-short').text(),
+      shortHidden: count.get('.mint-sample-selector__selected-short').attributes('aria-hidden'),
+    }).toEqual({ name: label, title: label, full: '1 selected', short: '1 sel.', shortHidden: 'true' })
+  })
+
   it('opens the grouping modal in manual mode', async () => {
     const wrapper = mount(SampleSelector, {
       props: {
@@ -140,8 +160,8 @@ describe('SampleSelector', () => {
       },
     })
 
-    const labels = wrapper.findAll('.mint-sample-selector__actions-row .mint-sample-selector__action-label')
-    expect(labels.map(label => label.text())).toEqual(['Grouping'])
+    const buttons = wrapper.findAll('.mint-sample-selector__header-actions > .mint-sample-selector__action-btn')
+    expect(buttons.map(button => button.text())).toEqual(['Group'])
 
     await wrapper.findAllComponents({ name: 'BaseButton' })[0].trigger('click')
 
@@ -472,9 +492,14 @@ describe('SampleSelector checkboxes (7c)', () => {
   }
   const stubs = { global: { stubs: { AutoGroupModalInternal: true } } }
 
-  it('should show the mono selected / total count when some samples are selected', () => {
+  it('should show the mono selected/total count when some samples are selected', () => {
     const wrapper = mount(SampleSelector, { props: grouped, ...stubs })
-    expect(wrapper.find('.mint-sample-selector__select-all-count').text()).toBe('1 / 3')
+    expect(wrapper.find('.mint-sample-selector__select-all-count').text()).toBe('1/3')
+  })
+
+  it('should offer clear-all-groups in the header when groups exist', () => {
+    const wrapper = mount(SampleSelector, { props: { ...grouped, enableGrouping: true }, ...stubs })
+    expect(wrapper.find('.mint-sample-selector__header-actions [aria-label="Clear all groups"]').exists()).toBe(true)
   })
 
   it('should mark the select-all checkbox mixed when some samples are selected', () => {

package/src/__tests__/components/SequenceProgressBar.test.ts

@@ -36,4 +36,16 @@ describe('SequenceProgressBar', () => {
     expect(wrapper.get('.mint-sequence-progress__label').text()).toBe('2 / 4 injections')
     expect(wrapper.find('.mint-sequence-progress__footer').exists()).toBe(false)
   })
+
+  it.each([
+    [0, null],
+    [2, '2 failed'],
+  ])('should show the failed count when %i injections failed', (failed, expected) => {
+    const wrapper = mount(SequenceProgressBar, {
+      props: { failed, progress: { current_sample: 3, total_samples: 6 } },
+    })
+
+    const node = wrapper.find('.mint-sequence-progress__failed')
+    expect(node.exists() ? node.text() : null).toBe(expected)
+  })
 })

package/src/__tests__/components/SettingsModal.test.ts

@@ -728,10 +728,17 @@ describe('SettingsModal', () => {
       expect(useSettingsStore(pinia).theme).toBe('dark')
     })
 
-    it('should render a swatch strip for each palette when appearance is shown', () => {
+    it('should preview each palette with its own tokens when appearance is shown', () => {
       const wrapper = mountSettingsModal({ showAppearance: true })
 
-      expect(wrapper.findAll('.mint-settings-modal__palette')).toHaveLength(Object.keys(colorPalettes).length)
+      const strips = wrapper.findAll('.mint-settings-modal__swatches')
+      expect(strips.map((strip) => strip.attributes('data-palette'))).toEqual(Object.keys(colorPalettes))
+      expect(strips[0].findAll('.mint-settings-modal__swatch').map((swatch) => swatch.attributes('style'))).toEqual([
+        'background-color: var(--color-primary);',
+        'background-color: var(--color-primary-hover);',
+        'background-color: var(--color-primary-soft);',
+        'background-color: var(--color-primary-border);',
+      ])
     })
 
     it('should resize the density preview when the density changes', async () => {

package/src/__tests__/components/StepWizard.test.ts

@@ -73,3 +73,14 @@ describe('StepWizard navigation (2c)', () => {
     expect(wrapper.find('.mint-wizard__counter').text()).toBe('2 / 2')
   })
 })
+
+describe('StepWizard orientation', () => {
+  it.each([
+    ['horizontal', false],
+    ['vertical', true],
+  ] as const)('should toggle the vertical modifier when orientation is %s', (orientation, vertical) => {
+    const wrapper = mount(StepWizard, { props: { steps, orientation } })
+
+    expect(wrapper.classes('mint-wizard--vertical')).toBe(vertical)
+  })
+})

package/src/__tests__/components/WellPlate.decoration.test.ts

@@ -28,15 +28,22 @@ describe('WellPlate per-well decoration', () => {
       .toEqual(['2px', 'solid', 'var(--mint-warning)'])
   })
 
-  it('should render no glyph when a QC well has no label or id', () => {
+  it.each([
+    ['qc', {}, 'Q'],
+    ['iqc', {}, 'i'],
+    ['sample', {}, ''],
+    ['qc', { showWellIds: true }, 'A1'],
+  ] as const)('should render the %s glyph when the well has no label (spec %o)', (sampleType, spec, text) => {
     const wrapper = mount(WellPlate, {
       props: {
-        spec: { format: 6 },
-        wells: { A1: { id: 'A1', row: 0, col: 0, state: 'filled', sampleType: 'qc' } },
+        spec: { format: 6, ...spec },
+        wells: { A1: { id: 'A1', row: 0, col: 0, state: 'filled', sampleType } },
       },
     })
 
-    expect(wrapper.findAll('.mint-well-plate__well')[0].text()).toBe('')
+    const well = wrapper.findAll('.mint-well-plate__well')[0]
+    expect(well.text()).toBe(text)
+    expect(well.find('.mint-well-plate__indicator').exists()).toBe(text === 'Q' || text === 'i')
   })
 
   it('should draw plain legend swatches when the legend is shown', () => {

package/src/__tests__/components/deprecationTags.test.ts

@@ -68,7 +68,7 @@ describe('root exports outside L1 and L2', () => {
 
     expect(values.sort()).toEqual([
       'defineControlModel', 'defineDataFrame', 'definePluginWorkspaceView', 'downloadBlob',
-      'resolvePluginFrontendBase', 'useExperiment', 'usePlatform', 'useRequest', 'useTheme', 'useToast',
+      'providePluginIdentity', 'resolvePluginFrontendBase', 'useExperiment', 'usePlatform', 'useRequest', 'useTheme', 'useToast',
     ])
   })
 

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

@@ -490,6 +490,20 @@ describe('useAppExperiment', () => {
       expect(state.saveLoading.value).toBe(false)
     })
 
+    it('should show the refetched update time after a successful save', async () => {
+      const store = useExperimentStore()
+      useAppExperiment({ onSave: vi.fn().mockResolvedValue('Saved') })
+      const state = getState()
+      store.select(makeExperiment({ updated_at: '2025-01-01T00:00:00Z' }))
+
+      const fetch = stubExperimentFetch()
+      const saving = state.handleSave()
+      fetch.resolveWith(makeExperiment({ updated_at: '2026-10-28T09:30:00Z' }))
+      await saving
+
+      expect(state.popover.value.experimentUpdatedAt).toBe('2026-10-28T09:30:00Z')
+    })
+
     it('should not set saveSuccessMessage when onSave returns null', async () => {
       const onSave = vi.fn().mockResolvedValue(null)
       useAppExperiment({ onSave })
@@ -716,8 +730,9 @@ describe('useAppExperiment', () => {
     it('exposes live ExperimentPopover props from the provided state', async () => {
       const saveDisabled = ref(false)
       const saveDisabledMessage = ref<string | undefined>('Ready to save')
+      const dirty = ref(false)
       const onSave = vi.fn().mockResolvedValue('Saved')
-      useAppExperiment({ onSave, saveDisabled, saveDisabledMessage })
+      useAppExperiment({ onSave, saveDisabled, saveDisabledMessage, dirty })
       const state = getState()
 
       useExperimentStore().select(makeExperiment({
@@ -725,26 +740,37 @@ describe('useAppExperiment', () => {
         name: 'Dose response',
         status: 'ongoing',
         experiment_code: 'EXP-012',
+        project: 'legacy-project',
+        project_name: 'Hypoxia atlas',
+        created_by_user: { id: 3, username: 'jdoe', first_name: 'Jane', last_name: 'Doe' },
+        updated_at: '2026-10-28T10:00:00Z',
       }))
 
       expect(state.popover.value).toMatchObject({
         experimentName: 'Dose response',
         experimentCode: 'EXP-012',
         experimentStatus: 'ongoing',
+        experimentId: 12,
+        experimentProject: 'Hypoxia atlas',
+        experimentOwner: 'Jane Doe',
+        experimentUpdatedAt: '2026-10-28T10:00:00Z',
         isResolving: false,
         showSave: true,
         showDetach: true,
         saveDisabled: false,
         saveDisabledMessage: 'Ready to save',
         saveLoading: false,
+        dirty: false,
       })
       expect(state.popover.value.error).toBeUndefined()
 
       saveDisabled.value = true
       saveDisabledMessage.value = 'Locked'
+      dirty.value = true
 
       expect(state.popover.value.saveDisabled).toBe(true)
       expect(state.popover.value.saveDisabledMessage).toBe('Locked')
+      expect(state.popover.value.dirty).toBe(true)
 
       await state.handleSave()
 

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

@@ -2,14 +2,16 @@ import { describe, expect, it } from 'vitest'
 import { useCalendarGrid } from '../../composables/useCalendarGrid'
 
 describe('useCalendarGrid', () => {
-  it('builds a stable 42-day month grid with previous and next month padding', () => {
+  it('builds a stable Monday-first 42-day month grid with previous and next month padding', () => {
     const calendar = useCalendarGrid()
     calendar.setCurrentMonthFromDate(new Date('2026-05-07T12:00:00'))
 
-    expect(calendar.weekDays).toEqual(['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'])
+    expect(calendar.weekDays).toEqual(['Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su'])
     expect(calendar.monthYear.value).toBe('May 2026')
     expect(calendar.calendarDays.value).toHaveLength(42)
     expect(calendar.calendarDays.value[0].date.getMonth()).toBe(3)
+    expect(calendar.calendarDays.value[0].date.getDate()).toBe(27)
+    expect(calendar.calendarDays.value[0].date.getDay()).toBe(1)
     expect(calendar.calendarDays.value.some(day => day.isCurrentMonth && day.date.getDate() === 7)).toBe(true)
   })
 

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

@@ -194,6 +194,117 @@ describe('useExperimentSelector', () => {
     ])
   })
 
+  it('should send the scope filters but not status to the stats route when counting', async () => {
+    fakeResponse = { total: 3, by_status: { planned: 1, ongoing: 2, completed: 0, cancelled: 0 } } as never
+    const hook = useExperimentSelector()
+    Object.assign(hook.filters, { search: 'glu', project: 'Screen', mine: true, status: 'planned' })
+
+    await hook.fetchStatusCounts()
+
+    const url = new URL(recordedUrls[0], 'http://mint.test')
+    expect(url.pathname).toBe('/experiments/stats')
+    expect(Object.fromEntries(url.searchParams)).toEqual({ search: 'glu', project: 'Screen', mine: 'true' })
+    expect(hook.statusCounts.value).toEqual({ planned: 1, ongoing: 2, completed: 0, cancelled: 0 })
+  })
+
+  it('should send mine=true on the list request when the mine filter is set', async () => {
+    const hook = useExperimentSelector()
+    hook.filters.mine = true
+
+    await hook.fetch()
+
+    expect(recordedUrls[0]).toContain('mine=true')
+  })
+
+  it('should sum the per-type stats when several experiment types are allowed', async () => {
+    vi.spyOn(useApi().client, 'get').mockImplementation(async (url: string) => {
+      recordedUrls.push(url)
+      const type = new URL(url, 'http://mint.test').searchParams.get('experiment_type')
+      return { data: { total: 2, by_status: { planned: type === 'drug-response' ? 2 : 0, ongoing: type === 'metabolomics' ? 2 : 0 } } }
+    })
+    const hook = useExperimentSelector({ allowedExperimentTypes: ['drug-response', 'metabolomics'] })
+
+    await hook.fetchStatusCounts()
+
+    expect(recordedUrls).toHaveLength(2)
+    expect(hook.statusCounts.value).toEqual({ planned: 2, ongoing: 2 })
+  })
+
+  it('should not query the stats route when the selected type is not allowed', async () => {
+    const hook = useExperimentSelector({ experimentType: 'proteomics', allowedExperimentTypes: ['drug-response'] })
+
+    await hook.fetchStatusCounts()
+
+    expect(recordedUrls).toEqual([])
+    expect(hook.statusCounts.value).toEqual({})
+  })
+
+  it('should refetch status counts with the list when a filter or the search changes and counts are on', async () => {
+    vi.useFakeTimers()
+    const hook = useExperimentSelector({ withStatusCounts: true })
+    const statsUrls = () => recordedUrls.filter(url => url.includes('/experiments/stats'))
+
+    hook.filters.project = 'Screen'
+    await nextTick()
+
+    expect(statsUrls()).toHaveLength(1)
+    expect(recordedUrls.filter(url => url.includes('/experiments?'))).toHaveLength(1)
+
+    hook.filters.search = 'glu'
+    await vi.advanceTimersByTimeAsync(300)
+
+    expect(statsUrls()).toHaveLength(2)
+    expect(statsUrls()[1]).toContain('search=glu')
+  })
+
+  it.each([
+    ['status', (hook: ReturnType<typeof useExperimentSelector>) => { hook.filters.status = 'planned' }, 1],
+    ['sort', (hook: ReturnType<typeof useExperimentSelector>) => { hook.sortKey.value = 'name:asc' }, 1],
+    ['project', (hook: ReturnType<typeof useExperimentSelector>) => { hook.filters.project = 'Screen' }, 2],
+  ] as const)('should refetch status counts on a %s change only when it changes the counts', async (_name, change, statsCalls) => {
+    // One body that serves both routes, so the first stats request succeeds.
+    fakeResponse = { ...fakeResponse, by_status: { planned: 1 } } as never
+    const hook = useExperimentSelector({ withStatusCounts: true })
+    await hook.fetchStatusCounts()
+
+    change(hook)
+    await nextTick()
+
+    expect(recordedUrls.filter(url => url.includes('/experiments/stats'))).toHaveLength(statsCalls)
+  })
+
+  it('should refetch status counts on a status change when the previous stats request failed', async () => {
+    const stats = vi.fn()
+      .mockRejectedValueOnce(new Error('offline'))
+      .mockResolvedValue({ data: { total: 1, by_status: { planned: 1 } } })
+    vi.spyOn(useApi().client, 'get').mockImplementation(async (url: string) =>
+      url.includes('/experiments/stats') ? stats() : { data: fakeResponse })
+    const hook = useExperimentSelector({ withStatusCounts: true })
+    await hook.fetchStatusCounts()
+    expect(hook.statusCounts.value).toEqual({})
+
+    hook.filters.status = 'planned'
+    await nextTick()
+
+    expect(stats).toHaveBeenCalledTimes(2)
+    await vi.waitFor(() => expect(hook.statusCounts.value).toEqual({ planned: 1 }))
+  })
+
+  it('should refetch status counts when a status change flushes a pending search', async () => {
+    vi.useFakeTimers()
+    const hook = useExperimentSelector({ withStatusCounts: true })
+    await hook.fetchStatusCounts()
+    const statsUrls = () => recordedUrls.filter(url => url.includes('/experiments/stats'))
+
+    hook.filters.search = 'glu'
+    await nextTick()
+    hook.filters.status = 'planned'
+    await nextTick()
+
+    expect(statsUrls()).toHaveLength(2)
+    expect(statsUrls()[1]).toContain('search=glu')
+  })
+
   it('loadMore appends the next page', async () => {
     const hook = useExperimentSelector({ limit: 1 })
 

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

@@ -1,12 +1,21 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 import { describe, expect, it } from 'vitest'
 
 import {
   detectDelimiter,
   parseDelimitedText,
+  readTableFileAsCsv,
   useFileImport,
   validateImportFile,
 } from '../../composables/useFileImport'
 
+const SAMPLES_CSV = [
+  'Sample Name,Treatment,Inj Vol,Date',
+  'S1,Vehicle,5,2026-10-01',
+  'S2,"Drug ""A"", 10 uM",2.5,2026-10-02',
+].join('\n')
+
 describe('file import helpers', () => {
   it('parses quoted CSV fields', () => {
     const parsed = parseDelimitedText('name,notes\nSample A,"hello, world"\n')
@@ -41,4 +50,31 @@ describe('file import helpers', () => {
     expect(result.rows).toEqual([{ name: 'A' }])
     expect(importer.loading.value).toBe(false)
   })
+
+  it.each([
+    ['samples.csv', SAMPLES_CSV],
+    ['samples.tsv', 'Sample Name\tTreatment\tInj Vol\tDate\nS1\tVehicle\t5\t2026-10-01\nS2\t"Drug ""A"", 10 uM"\t2.5\t2026-10-02'],
+    ['samples.xlsx', readFileSync(resolve(__dirname, '../fixtures/table-import/samples.xlsx'))],
+  ])('should read the first table as CSV text when the upload is %s', async (name, content) => {
+    const file = new File([content], name)
+
+    expect(await readTableFileAsCsv(file)).toBe(SAMPLES_CSV)
+  })
+
+  it('should keep a quote inside a field as text when the quote does not open the field', () => {
+    expect(parseDelimitedText('S1\t5" vial\nS2\tok', { hasHeaderRow: false }).rawRows)
+      .toEqual([['S1', '5" vial'], ['S2', 'ok']])
+  })
+
+  it('should keep the stored cell text when the upload is .xlsx', async () => {
+    const file = new File([readFileSync(resolve(__dirname, '../fixtures/table-import/cells.xlsx'))], 'cells.xlsx')
+
+    expect(await readTableFileAsCsv(file)).toBe('2026-10-01T13:45:00,08:30:00,TRUE\n  S1  ,9007199254740993,0.1')
+  })
+
+  it('should reject a file that is not a workbook when the name ends in .xlsx', async () => {
+    const file = new File(['Sample Name\nS1\n'], 'renamed.xlsx')
+
+    await expect(readTableFileAsCsv(file)).rejects.toThrow('not a valid .xlsx workbook')
+  })
 })

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

@@ -0,0 +1,68 @@
+import { mount } from '@vue/test-utils'
+import { defineComponent, nextTick, ref } from 'vue'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { computePosition } from '@floating-ui/dom'
+import { useFloatingPanel } from '../../composables/useFloatingPanel'
+
+const cleanup = vi.fn()
+vi.mock('@floating-ui/dom', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@floating-ui/dom')>()),
+  autoUpdate: vi.fn((_reference: unknown, _floating: unknown, update: () => void) => {
+    update()
+    return cleanup
+  }),
+  computePosition: vi.fn(async () => ({ x: 10, y: 20, placement: 'bottom-start', strategy: 'fixed', middlewareData: {} })),
+}))
+
+/** A trigger and the panel placed next to it. */
+const Panel = defineComponent({
+  setup() {
+    const trigger = ref<HTMLElement | null>(null)
+    const panel = ref<HTMLElement | null>(null)
+    const isOpen = ref(true)
+    const { style } = useFloatingPanel(trigger, panel, isOpen)
+    return { trigger, panel, isOpen, style }
+  },
+  template: '<div><button ref="trigger">Open</button><div v-if="isOpen" ref="panel" class="panel" :style="style" /></div>',
+})
+
+async function settle() {
+  for (let i = 0; i < 3; i++) await nextTick()
+}
+
+describe('useFloatingPanel', () => {
+  afterEach(() => {
+    cleanup.mockClear()
+    document.body.innerHTML = ''
+  })
+
+  it.each([
+    ['closes', (wrapper: ReturnType<typeof mount>) => { (wrapper.vm as unknown as { isOpen: boolean }).isOpen = false }],
+    ['unmounts', (wrapper: ReturnType<typeof mount>) => wrapper.unmount()],
+  ])('should stop autoUpdate when the panel %s', async (_, end) => {
+    const wrapper = mount(Panel, { attachTo: document.body })
+    await settle()
+    expect(cleanup).not.toHaveBeenCalled()
+
+    end(wrapper)
+    await settle()
+
+    expect(cleanup).toHaveBeenCalledTimes(1)
+  })
+
+  it.each([
+    [false, ''],
+    [true, 'hidden'],
+  ])('should set the panel visibility to %j when referenceHidden is %s', async (referenceHidden, visibility) => {
+    vi.mocked(computePosition).mockResolvedValueOnce({
+      x: 10, y: 20, placement: 'bottom-start', strategy: 'fixed', middlewareData: { hide: { referenceHidden } },
+    })
+    mount(Panel, { attachTo: document.body })
+    await settle()
+
+    const panel = document.querySelector<HTMLElement>('.panel')!
+    expect(panel.style.position).toBe('fixed')
+    expect(panel.style.top).toBe('20px')
+    expect(panel.style.visibility).toBe(visibility)
+  })
+})