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

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

@@ -1,18 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import ProgressBar from '../../components/ProgressBar.vue'
-
-describe('ProgressBar', () => {
-  it('clamps rail values and exposes an accessible label', () => {
-    const wrapper = mount(ProgressBar, {
-      props: {
-        value: 130,
-        ariaLabel: 'Connection pool usage',
-      },
-    })
-
-    const progress = wrapper.get('[role="progressbar"]')
-    expect(progress.attributes('aria-valuenow')).toBe('100')
-    expect(progress.attributes('aria-label')).toBe('Connection pool usage')
-  })
-})

package/src/__tests__/components/ProtocolStep.presentation.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-  PROTOCOL_STEP_TYPE_COLORS,
-  PROTOCOL_STEP_TYPE_ICONS,
-  formatProtocolDuration,
-} from '../../components/ProtocolStep.presentation'
-
-describe('ProtocolStep presentation helpers', () => {
-  it('formats protocol durations for editor and timeline displays', () => {
-    expect(formatProtocolDuration(undefined)).toBe('')
-    expect(formatProtocolDuration(15)).toBe('15m')
-    expect(formatProtocolDuration(60)).toBe('1h')
-    expect(formatProtocolDuration(95)).toBe('1h 35m')
-  })
-
-  it('keeps icons and colors available for every protocol step type', () => {
-    expect(Object.keys(PROTOCOL_STEP_TYPE_ICONS).sort()).toEqual([
-      'addition',
-      'centrifuge',
-      'custom',
-      'incubation',
-      'measurement',
-      'mix',
-      'transfer',
-      'wash',
-    ])
-    expect(PROTOCOL_STEP_TYPE_COLORS.measurement).toBe('#8B5CF6')
-    expect(PROTOCOL_STEP_TYPE_ICONS.custom).toContain('M10.325')
-  })
-})

package/src/__tests__/components/ProtocolStepEditor.state.test.ts

@@ -1,165 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { ProtocolStep } from '../../types'
-import type { StepTemplate } from '../../composables/useProtocolTemplates'
-import {
-  buildCustomProtocolTemplate,
-  buildProtocolPreviewParams,
-  buildProtocolStepEditorState,
-  buildProtocolStepPreview,
-  buildProtocolTemplateDefaults,
-} from '../../components/ProtocolStepEditor.state'
-
-const template: StepTemplate = {
-  id: 'builtin-incubation',
-  type: 'incubation',
-  name: 'Incubation',
-  description: 'Hold samples under controlled conditions',
-  defaultDuration: 60,
-  parameters: [
-    {
-      key: 'temperature',
-      label: 'Temperature',
-      type: 'temperature',
-      unit: 'C',
-      default: 37,
-      required: true,
-    },
-    {
-      key: 'notes',
-      label: 'Notes',
-      type: 'text',
-    },
-  ],
-  isBuiltIn: true,
-}
-
-describe('ProtocolStepEditor state helpers', () => {
-  it('builds editor defaults from template parameter defaults', () => {
-    expect(buildProtocolTemplateDefaults(template)).toEqual({
-      name: 'Incubation',
-      description: 'Hold samples under controlled conditions',
-      duration: 60,
-      parameters: {
-        temperature: 37,
-      },
-    })
-  })
-
-  it('initializes editor fields from an existing step', () => {
-    const step: ProtocolStep = {
-      id: 'step-1',
-      type: 'incubation',
-      name: 'Overnight incubation',
-      description: 'Long run',
-      duration: 720,
-      status: 'in_progress',
-      parameters: {
-        temperature: 4,
-      },
-      order: 3,
-    }
-
-    const state = buildProtocolStepEditorState(step, (type) => (
-      type === 'incubation' ? template : undefined
-    ))
-
-    expect(state).toEqual({
-      selectedTemplateId: 'builtin-incubation',
-      fields: {
-        name: 'Overnight incubation',
-        description: 'Long run',
-        duration: 720,
-        parameters: {
-          temperature: 4,
-        },
-      },
-    })
-  })
-
-  it('preserves source step metadata when building a preview', () => {
-    const preview = buildProtocolStepPreview(
-      template,
-      {
-        name: '',
-        description: 'Preview description',
-        parameters: {
-          temperature: 25,
-        },
-      },
-      {
-        id: 'step-2',
-        type: 'incubation',
-        name: 'Source',
-        status: 'completed',
-        order: 5,
-      }
-    )
-
-    expect(preview).toEqual({
-      id: 'step-2',
-      type: 'incubation',
-      name: 'Incubation',
-      description: 'Preview description',
-      duration: 60,
-      status: 'completed',
-      parameters: {
-        temperature: 25,
-      },
-      order: 5,
-    })
-  })
-
-  it('formats only populated preview parameters', () => {
-    const formatted = buildProtocolPreviewParams(
-      template,
-      {
-        temperature: 37,
-        notes: '',
-      },
-      (value, parameter) => `${parameter.label}: ${value}`
-    )
-
-    expect(formatted).toBe('Temperature: 37')
-  })
-
-  it('creates a custom template from the current editor fields', () => {
-    expect(
-      buildCustomProtocolTemplate(
-        template,
-        {
-          name: 'Cold incubation',
-          description: 'Cold room workflow',
-          duration: 120,
-          parameters: {
-            temperature: 4,
-            notes: 'keep covered',
-          },
-        },
-        'custom-fixed'
-      )
-    ).toEqual({
-      id: 'custom-fixed',
-      type: 'incubation',
-      name: 'Cold incubation',
-      description: 'Cold room workflow',
-      defaultDuration: 120,
-      parameters: [
-        {
-          key: 'temperature',
-          label: 'Temperature',
-          type: 'temperature',
-          unit: 'C',
-          default: 4,
-          required: true,
-        },
-        {
-          key: 'notes',
-          label: 'Notes',
-          type: 'text',
-          default: 'keep covered',
-        },
-      ],
-      isBuiltIn: false,
-    })
-  })
-})

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

@@ -1,33 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { afterEach, describe, expect, it } from 'vitest'
-import { nextTick } from 'vue'
-import ProtocolStepEditor from '../../components/ProtocolStepEditor.vue'
-
-describe('ProtocolStepEditor', () => {
-  afterEach(() => {
-    document.body.innerHTML = ''
-  })
-
-  it('uses shared dropdown state for the template picker', async () => {
-    const wrapper = mount(ProtocolStepEditor, {
-      attachTo: document.body,
-    })
-    await nextTick()
-
-    await wrapper.get('.mint-protocol-editor__template-btn').trigger('click')
-    expect(wrapper.find('.mint-protocol-editor__template-menu').exists()).toBe(true)
-
-    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }))
-    await nextTick()
-    expect(wrapper.find('.mint-protocol-editor__template-menu').exists()).toBe(false)
-
-    await wrapper.get('.mint-protocol-editor__template-btn').trigger('click')
-    expect(wrapper.find('.mint-protocol-editor__template-menu').exists()).toBe(true)
-
-    document.body.dispatchEvent(new MouseEvent('click', { bubbles: true }))
-    await nextTick()
-    expect(wrapper.find('.mint-protocol-editor__template-menu').exists()).toBe(false)
-
-    wrapper.unmount()
-  })
-})

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

@@ -1,44 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import ProtocolStepParameterField from '../../components/ProtocolStepParameterField.vue'
-import type { ParameterDefinition } from '../../composables/useProtocolTemplates'
-
-describe('ProtocolStepParameterField', () => {
-  it('emits numeric parameter changes with valueAsNumber', async () => {
-    const parameter: ParameterDefinition = {
-      key: 'temperature',
-      label: 'Temperature',
-      type: 'temperature',
-      unit: 'C',
-    }
-
-    const wrapper = mount(ProtocolStepParameterField, {
-      props: {
-        parameter,
-        modelValue: 37,
-      },
-    })
-
-    await wrapper.get('input').setValue('25')
-    expect(wrapper.emitted('update:modelValue')?.at(-1)).toEqual([25])
-  })
-
-  it('renders field validation errors', () => {
-    const parameter: ParameterDefinition = {
-      key: 'buffer',
-      label: 'Buffer',
-      type: 'select',
-      options: [{ value: 'PBS', label: 'PBS' }],
-    }
-
-    const wrapper = mount(ProtocolStepParameterField, {
-      props: {
-        parameter,
-        error: 'Buffer is required',
-      },
-    })
-
-    expect(wrapper.text()).toContain('Buffer is required')
-    expect(wrapper.get('select').classes()).toContain('mint-protocol-editor__input--error')
-  })
-})

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

@@ -1,125 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it, vi } from 'vitest'
-import { h, nextTick } from 'vue'
-import RackEditor from '../../components/RackEditor.vue'
-import type { Rack, WellEditData } from '../../types'
-
-function makeRacks(): Rack[] {
-  return [
-    {
-      id: 'rack-1',
-      name: 'Rack 1',
-      format: 54,
-      slot: 'R',
-      injectionVolume: 5,
-      wells: {
-        A1: {
-          id: 'A1',
-          row: 0,
-          col: 0,
-          state: 'filled',
-          sampleType: 'sample',
-          metadata: {
-            label: 'Original',
-            injectionVolume: 5,
-            injectionCount: 1,
-          },
-        },
-      },
-    },
-  ]
-}
-
-function jsonDataTransfer(data: unknown): DataTransfer {
-  return {
-    dropEffect: 'copy',
-    effectAllowed: 'copy',
-    getData: (type: string) => type === 'application/json' ? JSON.stringify(data) : '',
-    setData: vi.fn(),
-  } as unknown as DataTransfer
-}
-
-describe('RackEditor', () => {
-  it('passes rack-aware well editor slot props through to WellPlate', async () => {
-    const wrapper = mount(RackEditor, {
-      props: {
-        modelValue: makeRacks(),
-      },
-      slots: {
-        'well-editor': (slotProps) => h(
-          'button',
-          {
-            'data-test': 'custom-well-editor',
-            onClick: () => slotProps.save({
-              wellId: slotProps.wellId,
-              label: 'Custom',
-              sampleType: 'iqc',
-              injectionVolume: 7,
-              injectionCount: 3,
-              customMethod: 'C:\\Methods\\custom.meth',
-            } satisfies WellEditData),
-          },
-          `${slotProps.rackId}:${slotProps.rack?.slot}:${slotProps.wellId}:${slotProps.wellData?.metadata?.label}`,
-        ),
-      },
-    })
-
-    await wrapper.find('.mint-well-plate__well').trigger('click')
-
-    const customEditor = wrapper.get('[data-test="custom-well-editor"]')
-    expect(customEditor.text()).toBe('rack-1:R:A1:Original')
-
-    await customEditor.trigger('click')
-    await nextTick()
-
-    const emittedRacks = wrapper.emitted('update:modelValue')?.at(-1)?.[0] as Rack[]
-    expect(emittedRacks[0].wells.A1).toMatchObject({
-      sampleType: 'iqc',
-      metadata: {
-        label: 'Custom',
-        injectionVolume: 7,
-        injectionCount: 3,
-        customMethod: 'C:\\Methods\\custom.meth',
-      },
-    })
-  })
-
-  it('assigns dropped external samples when sample drop is enabled', async () => {
-    const wrapper = mount(RackEditor, {
-      props: {
-        modelValue: makeRacks(),
-        allowSampleDrop: true,
-      },
-    })
-
-    await wrapper.findAll('.mint-well-plate__well')[1].trigger('drop', {
-      dataTransfer: jsonDataTransfer({
-        type: 'sample',
-        id: 'sample-2',
-        sampleName: 'Dragged Sample',
-      }),
-      preventDefault: vi.fn(),
-    })
-    await nextTick()
-
-    const emittedRacks = wrapper.emitted('update:modelValue')?.at(-1)?.[0] as Rack[]
-    expect(emittedRacks[0].wells.A2).toMatchObject({
-      sampleType: 'sample',
-      metadata: {
-        label: 'Dragged Sample',
-        injectionVolume: 5,
-        injectionCount: 1,
-        customMethod: null,
-      },
-    })
-
-    expect(wrapper.emitted('sample-drop')?.[0]?.slice(0, 3)).toEqual([
-      'rack-1',
-      'A2',
-      expect.objectContaining({
-        id: 'sample-2',
-        sampleName: 'Dragged Sample',
-      }),
-    ])
-  })
-})

package/src/__tests__/components/ReagentList.presentation.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { Reagent } from '../../types'
-import {
-  formatReagentExpiryDate,
-  getReagentColumnValue,
-  getReagentRowClasses,
-  getReagentStockFillClass,
-  getReagentStockLevel,
-  isReagentExpired,
-  isReagentExpiringSoon,
-  isReagentLowStock,
-} from '../../components/ReagentList.presentation'
-
-describe('ReagentList presentation helpers', () => {
-  const reagent: Reagent = {
-    id: 'reagent-1',
-    name: 'Glucose',
-    catalogNumber: 'G-7528',
-    lotNumber: 'LOT-A',
-    supplier: 'Sigma',
-    expiryDate: '2026-06-01T00:00:00.000Z',
-    stockLevel: 12,
-  }
-
-  it('extracts sortable values for table columns', () => {
-    expect(getReagentColumnValue(reagent, 'name')).toBe('Glucose')
-    expect(getReagentColumnValue(reagent, 'catalog')).toBe('G-7528')
-    expect(getReagentColumnValue(reagent, 'expiry')).toBe(new Date(reagent.expiryDate!).getTime())
-    expect(getReagentColumnValue({ id: 'empty', name: 'Empty' }, 'stock')).toBeUndefined()
-  })
-
-  it('classifies expiry states relative to a supplied date', () => {
-    const now = new Date('2026-05-22T00:00:00.000Z')
-
-    expect(isReagentExpired(reagent, now)).toBe(false)
-    expect(isReagentExpiringSoon(reagent, 30, now)).toBe(true)
-    expect(isReagentExpired({ ...reagent, expiryDate: '2026-05-01T00:00:00.000Z' }, now)).toBe(true)
-  })
-
-  it('classifies low stock and stock fill tone', () => {
-    expect(isReagentLowStock(reagent, 15)).toBe(true)
-    expect(getReagentStockLevel({ id: 'missing', name: 'Missing' })).toBe(0)
-    expect(getReagentStockFillClass(70)).toBe('mint-reagent-list__stock-fill--good')
-    expect(getReagentStockFillClass(30)).toBe('mint-reagent-list__stock-fill--warning')
-    expect(getReagentStockFillClass(10)).toBe('mint-reagent-list__stock-fill--low')
-  })
-
-  it('formats missing and present expiry dates', () => {
-    expect(formatReagentExpiryDate(undefined)).toBe('-')
-    expect(formatReagentExpiryDate('2026-06-01T00:00:00.000Z')).toBe('Jun 2026')
-  })
-
-  it('builds row state classes without mixing expired and expiring-soon', () => {
-    expect(
-      getReagentRowClasses(reagent, {
-        lowStockThreshold: 15,
-        draggedId: 'reagent-1',
-        dragOverId: 'reagent-2',
-        now: new Date('2026-05-22T00:00:00.000Z'),
-      })
-    ).toEqual([
-      'mint-reagent-list__row',
-      'mint-reagent-list__row--expiring-soon',
-      'mint-reagent-list__row--low-stock',
-      'mint-reagent-list__row--dragging',
-    ])
-  })
-})

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

@@ -1,82 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import ReagentList from '../../components/ReagentList.vue'
-import type { Reagent } from '../../types'
-
-describe('ReagentList', () => {
-  const reagents: Reagent[] = [
-    {
-      id: 'reagent-1',
-      name: 'Glucose',
-      catalogNumber: 'G-7528',
-      lotNumber: 'LOT-A',
-      supplier: 'Sigma',
-    },
-    {
-      id: 'reagent-2',
-      name: 'Lactate',
-      catalogNumber: 'L-1250',
-      lotNumber: 'LOT-B',
-      supplier: 'Cayman',
-    },
-  ]
-
-  it('searches reagent metadata case-insensitively', async () => {
-    const wrapper = mount(ReagentList, {
-      props: {
-        modelValue: reagents,
-        readonly: true,
-        columns: ['name', 'catalog', 'lot', 'supplier'],
-      },
-    })
-
-    await wrapper.find('.mint-reagent-list__search-input').setValue(' cay ')
-
-    const rows = wrapper.findAll('tbody tr')
-    expect(rows).toHaveLength(1)
-    expect(rows[0].text()).toContain('Lactate')
-  })
-
-  it('treats whitespace-only search as empty', async () => {
-    const wrapper = mount(ReagentList, {
-      props: {
-        modelValue: reagents,
-        readonly: true,
-        columns: ['name', 'catalog', 'lot', 'supplier'],
-      },
-    })
-
-    await wrapper.find('.mint-reagent-list__search-input').setValue('   ')
-
-    expect(wrapper.findAll('tbody tr')).toHaveLength(2)
-  })
-
-  it('sorts reagent columns while keeping missing values last', async () => {
-    const wrapper = mount(ReagentList, {
-      props: {
-        modelValue: [
-          ...reagents,
-          { id: 'reagent-3', name: 'Pyruvate' },
-        ],
-        readonly: true,
-        columns: ['name', 'catalog'],
-      },
-    })
-
-    await wrapper.findAll('th')[1].trigger('click')
-
-    const rows = wrapper.findAll('tbody tr')
-    expect(rows.map(row => row.text())).toEqual([
-      expect.stringContaining('Glucose'),
-      expect.stringContaining('Lactate'),
-      expect.stringContaining('Pyruvate'),
-    ])
-
-    await wrapper.findAll('th')[1].trigger('click')
-    expect(wrapper.findAll('tbody tr').map(row => row.text())).toEqual([
-      expect.stringContaining('Lactate'),
-      expect.stringContaining('Glucose'),
-      expect.stringContaining('Pyruvate'),
-    ])
-  })
-})

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

@@ -1,82 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-const retiredSelectors: Record<string, readonly string[]> = {
-  'app-plugin-switcher.css': [
-    'mint-plugin-switcher__swatch',
-  ],
-  'dose-calculator.css': [
-    'mint-dose-calculator__mw-input',
-  ],
-  'experiment-popover.css': [
-    'mint-experiment-popover__check-icon',
-    'mint-experiment-popover__divider',
-    'mint-experiment-popover__footer',
-    'mint-experiment-popover__save-btn',
-    'mint-experiment-popover__save-btn--loading',
-    'mint-experiment-popover__save-btn--success',
-    'mint-experiment-popover__save-hint',
-    'mint-experiment-popover__save-icon',
-    'mint-experiment-popover__spinner',
-  ],
-  'experiment-selector-modal.css': [
-    'mint-experiment-selector__filters',
-    'mint-experiment-selector__status-filter',
-  ],
-  'protocol-step-editor.css': [
-    'mint-protocol-editor__field-row',
-  ],
-  'reagent-editor.css': [
-    'mint-reagent-editor__row',
-  ],
-  'sample-hierarchy-tree.css': [
-    'mint-sample-tree__node--selected',
-  ],
-  'sample-selector.css': [
-    'mint-popover-enter-active',
-    'mint-popover-enter-from',
-    'mint-popover-leave-active',
-    'mint-popover-leave-to',
-    'mint-sample-selector__level-badge',
-    'mint-sample-selector__level-btn',
-    'mint-sample-selector__level-desc',
-    'mint-sample-selector__level-example',
-    'mint-sample-selector__level-info',
-    'mint-sample-selector__level-title',
-    'mint-sample-selector__popover',
-    'mint-sample-selector__popover-body',
-    'mint-sample-selector__popover-header',
-  ],
-  'schedule-calendar.css': [
-    'mint-schedule__grid-line',
-  ],
-  'well-plate.css': [
-    'mint-well-plate__well--blank',
-    'mint-well-plate__well--control',
-    'mint-well-plate__well--iqc',
-    'mint-well-plate__well--qc',
-    'mint-well-plate__well--readonly',
-    'mint-well-plate__well--sample',
-  ],
-}
-
-const cases = Object.entries(retiredSelectors).flatMap(([file, selectors]) =>
-  selectors.map(selector => ({ file, selector })),
-)
-
-function classSelectorPattern(selector: string): RegExp {
-  const escaped = selector.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  return new RegExp(`\\.${escaped}(?![A-Za-z0-9_-])`)
-}
-
-describe('retired component styles', () => {
-  it.each(cases)('should omit $selector from $file', ({ file, selector }) => {
-    const styles = readFileSync(
-      resolve(process.cwd(), 'src/styles/components', file),
-      'utf8',
-    )
-
-    expect(styles).not.toMatch(classSelectorPattern(selector))
-  })
-})

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

@@ -1,14 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-
-import RuntimeUpdateNotice from '../../components/RuntimeUpdateNotice.vue'
-
-describe('RuntimeUpdateNotice', () => {
-  it('should offer one explicit reload action when an update is available', async () => {
-    const wrapper = mount(RuntimeUpdateNotice, { props: { visible: true } })
-
-    await wrapper.get('button').trigger('click')
-
-    expect(wrapper.emitted('reload')).toHaveLength(1)
-  })
-})