@morscherlab/mint-sdk 1.3.11 → 1.4.0-beta.10

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

@@ -1,183 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { createPinia } from 'pinia'
-import { computed, defineComponent, h, ref, nextTick } from 'vue'
-import { describe, expect, it, vi } from 'vitest'
-import AppLayout from '../../components/AppLayout.vue'
-import AppSidebar from '../../components/AppSidebar.vue'
-import DoseDesignWorkspaceView from '../../components/DoseDesignWorkspaceView.vue'
-
-vi.mock('../../composables/usePlatformContext', () => ({
-  usePlatformContext: vi.fn(() => ({
-    isIntegrated: computed(() => false),
-    context: ref({ isIntegrated: false, theme: 'system' }),
-    plugin: computed(() => undefined),
-    user: computed(() => undefined),
-    theme: computed(() => 'system' as const),
-    features: computed(() => undefined),
-    navigate: vi.fn(),
-    notify: vi.fn(),
-    sendToPlatform: vi.fn(),
-  })),
-}))
-
-vi.mock('../../composables/useTheme', () => ({
-  useTheme: vi.fn(() => ({
-    isDark: ref(false),
-    theme: ref('light'),
-    toggleTheme: vi.fn(),
-  })),
-}))
-
-const WellPlateStub = defineComponent({
-  name: 'WellPlate',
-  props: {
-    modelValue: { type: Array, default: () => [] },
-    format: { type: Number, default: 96 },
-    wells: { type: Object, default: undefined },
-    disabled: { type: Boolean, default: false },
-    size: { type: String, default: undefined },
-    selectionMode: { type: String, default: undefined },
-    heatmap: { type: Object, default: undefined },
-  },
-  emits: ['update:modelValue'],
-  template: '<button data-test="well-plate" @click="$emit(\'update:modelValue\', [\'B1\', \'B2\'])" />',
-})
-
-const DoseCalculatorStub = defineComponent({
-  name: 'DoseCalculator',
-  props: {
-    mode: { type: String, default: 'auto' },
-    targetWells: { type: Array, default: () => [] },
-    disabled: { type: Boolean, default: false },
-    molecularWeight: { type: Number, default: undefined },
-  },
-  template: '<div data-test="dose-calculator" />',
-})
-
-function mountWorkspace(
-  props: Record<string, unknown> = {},
-  slots: Record<string, unknown> = {},
-) {
-  return mount(DoseDesignWorkspaceView, {
-    props,
-    slots: slots as never,
-    global: {
-      plugins: [createPinia()],
-      stubs: {
-        WellPlate: WellPlateStub,
-        DoseCalculator: DoseCalculatorStub,
-        'router-link': {
-          template: '<a><slot /></a>',
-        },
-        BaseModal: {
-          template: '<div><slot /></div>',
-        },
-      },
-    },
-  })
-}
-
-describe('DoseDesignWorkspaceView', () => {
-  it('renders WellPlate and DoseCalculator from one dose-design model', async () => {
-    const wrapper = mountWorkspace({
-      modelValue: {
-        selectedWells: ['A1'],
-        plateFormat: 384,
-        doseMode: 'serial',
-        disabled: false,
-      },
-      doseDesignOptions: {
-        includeMolecularWeight: true,
-      },
-      wellPlateProps: {
-        size: 'lg',
-        selectionMode: 'single',
-        heatmap: { enabled: true },
-      },
-      doseCalculatorProps: {
-        disabled: true,
-      },
-    })
-
-    const wellPlate = wrapper.findComponent(WellPlateStub)
-    const doseCalculator = wrapper.findComponent(DoseCalculatorStub)
-
-    expect(wellPlate.props()).toMatchObject({
-      modelValue: ['A1'],
-      format: 384,
-      size: 'lg',
-      selectionMode: 'single',
-      heatmap: { enabled: true },
-    })
-    expect(doseCalculator.props()).toMatchObject({
-      mode: 'serial',
-      targetWells: ['A1'],
-      disabled: true,
-      molecularWeight: 300,
-    })
-
-    await wellPlate.trigger('click')
-    await nextTick()
-
-    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toMatchObject({
-      selectedWells: ['B1', 'B2'],
-    })
-  })
-
-  it('uses custom generated component prop ids from doseDesignOptions', () => {
-    const wrapper = mountWorkspace({
-      doseDesignOptions: {
-        selectedWells: ['C1'],
-        componentProps: {
-          plateId: 'plateView',
-          doseId: 'doseTool',
-        },
-      },
-    })
-
-    expect(wrapper.findComponent(WellPlateStub).props('modelValue')).toEqual(['C1'])
-    expect(wrapper.findComponent(DoseCalculatorStub).props('targetWells')).toEqual(['C1'])
-  })
-
-  it('passes through sidebar chrome overrides', () => {
-    const wrapper = mountWorkspace({
-      sidebarVariant: 'default',
-      responsiveSidebar: false,
-      sidebarTitle: 'Dose Controls',
-      sidebarSubtitle: 'Plate setup',
-      sidebarBadge: 'ready',
-    })
-
-    expect(wrapper.findComponent(AppLayout).props('responsiveSidebar')).toBe(false)
-    expect(wrapper.findComponent(AppSidebar).props('title')).toBe('Dose Controls')
-    expect(wrapper.findComponent(AppSidebar).props('subtitle')).toBe('Plate setup')
-    expect(wrapper.findComponent(AppSidebar).props('badge')).toBe('ready')
-  })
-
-  it('exposes merged component props to the default slot', () => {
-    const wrapper = mountWorkspace(
-      {
-        doseDesignOptions: {
-          selectedWells: ['D1'],
-        },
-      },
-      {
-        default: (rawProps: unknown) => {
-          const props = rawProps as {
-            wellPlateProps: Record<string, unknown>
-            doseCalculatorProps: Record<string, unknown>
-          }
-          return h('pre', { class: 'slot-props' }, JSON.stringify({
-            plate: props.wellPlateProps.modelValue,
-            dose: props.doseCalculatorProps.targetWells,
-          }))
-        },
-      },
-    )
-
-    expect(JSON.parse(wrapper.find('.slot-props').text())).toEqual({
-      plate: ['D1'],
-      dose: ['D1'],
-    })
-  })
-})

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

@@ -1,108 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import ExperimentTimeline from '../../components/ExperimentTimeline.vue'
-import type { ProtocolStep } from '../../types'
-
-function makeSteps(): ProtocolStep[] {
-  return [
-    { id: 's1', name: 'Thaw', type: 'incubation', status: 'pending', order: 0 },
-    { id: 's2', name: 'Quench', type: 'incubation', status: 'pending', order: 1 },
-    { id: 's3', name: 'Extract', type: 'incubation', status: 'pending', order: 2 },
-  ]
-}
-
-describe('ExperimentTimeline', () => {
-  it('renders steps in order', () => {
-    const wrapper = mount(ExperimentTimeline, { props: { modelValue: makeSteps() } })
-
-    expect(wrapper.findAll('.mint-timeline__title').map(title => title.text()))
-      .toEqual(['Thaw', 'Quench', 'Extract'])
-  })
-
-  it('reorders a step with Alt and the arrow keys while editable', async () => {
-    const wrapper = mount(ExperimentTimeline, {
-      props: { modelValue: makeSteps(), editable: true },
-    })
-
-    const first = wrapper.findAll('.mint-timeline__step')[0]
-    expect(first.attributes('tabindex')).toBe('0')
-    expect(first.attributes('aria-label')).toContain('Press Alt with the arrow keys')
-
-    await first.trigger('keydown', { key: 'ArrowDown', altKey: true })
-
-    expect(wrapper.emitted('step-reorder')?.[0]).toEqual(['s1', 1])
-    const steps = wrapper.emitted('update:modelValue')?.[0]?.[0] as ProtocolStep[]
-    expect(steps.map(step => step.id)).toEqual(['s2', 's1', 's3'])
-    expect(steps.map(step => step.order)).toEqual([0, 1, 2])
-  })
-
-  it('announces the move politely', async () => {
-    const wrapper = mount(ExperimentTimeline, {
-      props: { modelValue: makeSteps(), editable: true },
-    })
-
-    await wrapper.findAll('.mint-timeline__step')[2]
-      .trigger('keydown', { key: 'ArrowUp', altKey: true })
-    await wrapper.vm.$nextTick()
-
-    const liveRegion = wrapper.get('[role="status"]')
-    expect(liveRegion.attributes('aria-live')).toBe('polite')
-    expect(liveRegion.text()).toBe('Extract moved to position 2 of 3.')
-  })
-
-  it('is not keyboard reorderable when not editable', async () => {
-    const wrapper = mount(ExperimentTimeline, { props: { modelValue: makeSteps() } })
-
-    const first = wrapper.findAll('.mint-timeline__step')[0]
-    expect(first.attributes('tabindex')).toBeUndefined()
-
-    await first.trigger('keydown', { key: 'ArrowDown', altKey: true })
-
-    expect(wrapper.emitted('step-reorder')).toBeUndefined()
-  })
-
-  describe('step progress (3d)', () => {
-    function mountWith(step: Partial<ProtocolStep>) {
-      const steps: ProtocolStep[] = [
-        { id: 'run', name: 'LC-MS', type: 'incubation', status: 'in_progress', order: 0, ...step },
-      ]
-      return mount(ExperimentTimeline, { props: { modelValue: steps } })
-    }
-
-    it('should render a progress bar when the in-progress step has progress', () => {
-      expect(mountWith({ progress: 35 }).find('[role="progressbar"]').exists()).toBe(true)
-    })
-
-    it('should expose the value on the progress bar when the step has progress', () => {
-      expect(mountWith({ progress: 35 }).find('[role="progressbar"]').attributes('aria-valuenow')).toBe('35')
-    })
-
-    it('should size the fill to the percent when the step has progress', () => {
-      expect(mountWith({ progress: 35 }).find('.mint-timeline__progress-fill').attributes('style')).toContain('width: 35%')
-    })
-
-    it('should show the percent as text when the step has progress', () => {
-      expect(mountWith({ progress: 35 }).find('.mint-timeline__progress-value').text()).toBe('35%')
-    })
-
-    it('should round the percent text when progress is fractional', () => {
-      expect(mountWith({ progress: 34.6 }).find('.mint-timeline__progress-value').text()).toBe('35%')
-    })
-
-    it('should clamp the percent when progress exceeds 100', () => {
-      expect(mountWith({ progress: 140 }).find('.mint-timeline__progress-value').text()).toBe('100%')
-    })
-
-    it('should clamp the percent when progress is negative', () => {
-      expect(mountWith({ progress: -5 }).find('.mint-timeline__progress-value').text()).toBe('0%')
-    })
-
-    it('should render no progress bar when the in-progress step has no progress', () => {
-      expect(mountWith({}).find('[role="progressbar"]').exists()).toBe(false)
-    })
-
-    it('should render no progress bar when the step is not in progress', () => {
-      expect(mountWith({ status: 'completed', progress: 100 }).find('[role="progressbar"]').exists()).toBe(false)
-    })
-  })
-})

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

@@ -1,96 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import FitPanel from '../../components/FitPanel.vue'
-import type { FitResultSummary, FitSeries } from '../../types'
-
-const results: FitResultSummary[] = [
-  { label: 'IC50 (nM)', value: '42.7' },
-  { label: 'Hill slope', value: '-1.12', variant: 'success' },
-  { label: 'R²', value: '0.982', variant: 'success', verdict: true },
-]
-
-function mountCompleted() {
-  return mount(FitPanel, { props: { state: 'completed', results } })
-}
-
-describe('FitPanel', () => {
-  it('should list results as table rows when they carry no verdict, even with a variant', () => {
-    expect(mountCompleted().findAll('.mint-fit-panel__result-row').map(row => row.text()))
-      .toEqual(['IC50 (nM)42.7', 'Hill slope-1.12'])
-  })
-
-  it('should move a result into the check row when it is marked as a verdict', () => {
-    expect(mountCompleted().get('.mint-fit-panel__check--success').text()).toBe('R² 0.982')
-  })
-})
-
-const parameters: FitResultSummary[] = [
-  { label: 'IC50', unit: 'nM', value: '631', ci: '512 – 778' },
-  { label: 'Hill slope', value: '1.10', ci: '0.94 – 1.26' },
-]
-
-const series: FitSeries[] = [
-  { label: 'Control', results: parameters },
-  { label: 'Treatment A', color: 'var(--mint-sample-4)', results: [{ label: 'IC50', unit: 'nM', value: '39.8' }] },
-]
-
-describe('FitPanel parameter table (9b)', () => {
-  it('should render the unit in its own element when a result has a unit', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', results: parameters } })
-    expect(wrapper.get('.mint-fit-panel__result-unit').text()).toBe('nM')
-  })
-
-  it('should render a header row when results are shown', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', results: parameters } })
-    expect(wrapper.get('.mint-fit-panel__result-head').text()).toBe('ParameterValue95% CI')
-  })
-
-  it('should render the confidence interval when a result has one', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', results: parameters } })
-    expect(wrapper.get('.mint-fit-panel__result-ci').text()).toBe('512 – 778')
-  })
-
-  it('should omit the CI column when no result has a confidence interval', () => {
-    expect(mountCompleted().get('.mint-fit-panel__result-head').text()).toBe('ParameterValue')
-  })
-
-  it('should use custom column labels when columnLabels is set', () => {
-    const wrapper = mount(FitPanel, {
-      props: { state: 'completed', results: parameters, columnLabels: { parameter: '参数', value: '值' } },
-    })
-    expect(wrapper.get('.mint-fit-panel__result-head').text()).toBe('参数值95% CI')
-  })
-})
-
-describe('FitPanel series switch (9b)', () => {
-  it('should show the first series when series are given', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series } })
-    expect(wrapper.findAll('.mint-fit-panel__result-row')).toHaveLength(2)
-  })
-
-  it('should show another series when its segment is selected', async () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series } })
-    await wrapper.findAll('[role="radio"]')[1].trigger('click')
-    expect(wrapper.findAll('.mint-fit-panel__result-row')).toHaveLength(1)
-  })
-
-  it('should emit the selected series index when a segment is selected', async () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series } })
-    await wrapper.findAll('[role="radio"]')[1].trigger('click')
-    expect(wrapper.emitted('update:activeSeries')?.[0]).toEqual([1])
-  })
-
-  it('should color a series segment with the group palette when the series has no color', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series } })
-    expect(wrapper.get('.mint-segmented-control__swatch').attributes('style')).toContain('var(--mint-sample-1)')
-  })
-
-  it('should render no series switch when series are not given', () => {
-    expect(mountCompleted().find('.mint-fit-panel__series').exists()).toBe(false)
-  })
-
-  it('should keep the series switch when the active series has no results', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series: [{ label: 'Empty', results: [] }, ...series] } })
-    expect(wrapper.find('.mint-fit-panel__series').exists()).toBe(true)
-  })
-})

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

@@ -1,101 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import GroupAssigner from '../../components/GroupAssigner.vue'
-import type { GroupItem } from '../../types'
-
-const groups: GroupItem[] = [
-  { name: 'control-a', color: '#3B82F6', count: 3 },
-  { name: 'treatment-a', color: '#F43F5E', count: 4 },
-]
-
-describe('GroupAssigner', () => {
-  it('uses shared assignment state for counts, validation, and emitted updates', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: {
-        groups,
-        group1: ['control-a'],
-        group2: [],
-        minPerGroup: 1,
-      },
-    })
-
-    expect(wrapper.text()).toContain('3 samples')
-    expect(wrapper.text()).toContain('0 samples')
-    expect(wrapper.text()).toContain('Add 1 more to Treatment')
-
-    await wrapper.find('.mint-group-assigner__pill-remove').trigger('click')
-    expect(wrapper.emitted('update:group1')?.[0]).toEqual([[]])
-    expect(wrapper.emitted('update:group2')).toBeUndefined()
-  })
-
-  it('does not throw when drag events omit dataTransfer', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: {
-        groups,
-        group1: [],
-        group2: [],
-      },
-    })
-
-    await expect(
-      wrapper.find('.mint-group-assigner__pill--unassigned').trigger('dragstart', { dataTransfer: null }),
-    ).resolves.toBeUndefined()
-
-    await expect(
-      wrapper.find('.mint-group-assigner__zone').trigger('dragover', { dataTransfer: null }),
-    ).resolves.toBeUndefined()
-  })
-
-  it('assigns and unassigns groups with Alt and the arrow keys', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: { groups, group1: [], group2: [] },
-    })
-
-    const pill = wrapper.get('.mint-group-assigner__pill--unassigned')
-    expect(pill.attributes('tabindex')).toBe('0')
-    expect(pill.attributes('aria-label')).toContain('Available Groups')
-
-    await pill.trigger('keydown', { key: 'ArrowLeft', altKey: true })
-    expect(wrapper.emitted('update:group1')?.[0]).toEqual([['control-a']])
-
-    await wrapper.get('.mint-group-assigner__pill--unassigned')
-      .trigger('keydown', { key: 'ArrowRight', altKey: true })
-    expect(wrapper.emitted('update:group2')?.at(-1)).toEqual([['control-a']])
-  })
-
-  it('moves an assigned group back to the unassigned pool', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: { groups, group1: ['control-a'], group2: [] },
-    })
-
-    await wrapper.get('.mint-group-assigner__zone--1 .mint-group-assigner__pill')
-      .trigger('keydown', { key: 'ArrowRight', altKey: true })
-
-    expect(wrapper.emitted('update:group1')?.[0]).toEqual([[]])
-  })
-
-  it('announces keyboard assignments politely', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: { groups, group1: [], group2: [] },
-    })
-
-    await wrapper.get('.mint-group-assigner__pill--unassigned')
-      .trigger('keydown', { key: 'ArrowLeft', altKey: true })
-    await wrapper.vm.$nextTick()
-
-    const liveRegion = wrapper.get('[role="status"]')
-    expect(liveRegion.attributes('aria-live')).toBe('polite')
-    expect(liveRegion.text()).toBe('control-a moved to Control.')
-  })
-
-  it('ignores arrow keys without Alt', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: { groups, group1: [], group2: [] },
-    })
-
-    await wrapper.get('.mint-group-assigner__pill--unassigned')
-      .trigger('keydown', { key: 'ArrowLeft' })
-
-    expect(wrapper.emitted('update:group1')).toBeUndefined()
-  })
-})

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

@@ -1,120 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { nextTick } from 'vue'
-import MobileSupportGate from '../../components/MobileSupportGate.vue'
-
-function mockMatchMedia(initialMatches: boolean) {
-  const listeners = new Set<(event: MediaQueryListEvent) => void>()
-  const queryList = {
-    matches: initialMatches,
-    media: '',
-    onchange: null,
-    addEventListener: vi.fn((_event: string, listener: (event: MediaQueryListEvent) => void) => {
-      listeners.add(listener)
-    }),
-    removeEventListener: vi.fn((_event: string, listener: (event: MediaQueryListEvent) => void) => {
-      listeners.delete(listener)
-    }),
-    addListener: vi.fn((listener: (event: MediaQueryListEvent) => void) => {
-      listeners.add(listener)
-    }),
-    removeListener: vi.fn((listener: (event: MediaQueryListEvent) => void) => {
-      listeners.delete(listener)
-    }),
-    dispatchEvent: vi.fn(),
-  } as unknown as MediaQueryList
-
-  Object.defineProperty(window, 'matchMedia', {
-    configurable: true,
-    value: vi.fn(() => queryList),
-  })
-
-  return {
-    setMatches(matches: boolean) {
-      Object.defineProperty(queryList, 'matches', {
-        configurable: true,
-        value: matches,
-      })
-      listeners.forEach(listener => listener({ matches } as MediaQueryListEvent))
-    },
-  }
-}
-
-describe('MobileSupportGate', () => {
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('shows the unsupported message on mobile when the route is unsupported', async () => {
-    mockMatchMedia(true)
-
-    const wrapper = mount(MobileSupportGate, {
-      props: {
-        supported: false,
-      },
-      slots: {
-        default: '<div data-testid="content">Workspace content</div>',
-      },
-    })
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="mobile-unsupported"]').exists()).toBe(true)
-    expect(wrapper.text()).toContain('Desktop workspace recommended')
-    expect(wrapper.find('[data-testid="content"]').exists()).toBe(false)
-  })
-
-  it('renders content on desktop even when the route is mobile-unsupported', async () => {
-    mockMatchMedia(false)
-
-    const wrapper = mount(MobileSupportGate, {
-      props: {
-        supported: false,
-      },
-      slots: {
-        default: '<div data-testid="content">Workspace content</div>',
-      },
-    })
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="mobile-unsupported"]').exists()).toBe(false)
-    expect(wrapper.find('[data-testid="content"]').exists()).toBe(true)
-  })
-
-  it('renders content on mobile when the route is supported', async () => {
-    mockMatchMedia(true)
-
-    const wrapper = mount(MobileSupportGate, {
-      props: {
-        supported: true,
-      },
-      slots: {
-        default: '<div data-testid="content">Workspace content</div>',
-      },
-    })
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="mobile-unsupported"]').exists()).toBe(false)
-    expect(wrapper.find('[data-testid="content"]').exists()).toBe(true)
-  })
-
-  it('reacts when the viewport moves into the mobile query', async () => {
-    const media = mockMatchMedia(false)
-
-    const wrapper = mount(MobileSupportGate, {
-      props: {
-        supported: false,
-      },
-      slots: {
-        default: '<div data-testid="content">Workspace content</div>',
-      },
-    })
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="content"]').exists()).toBe(true)
-
-    media.setMatches(true)
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="mobile-unsupported"]').exists()).toBe(true)
-  })
-})

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

@@ -1,54 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import MultiSelect from '../../components/MultiSelect.vue'
-
-const options = [
-  { value: 'a', label: 'A' },
-  { value: 'b', label: 'B' },
-  { value: 'c', label: 'C' },
-]
-
-describe('MultiSelect', () => {
-  it('accepts string and number shorthand options', async () => {
-    const wrapper = mount(MultiSelect, {
-      props: {
-        modelValue: ['glucose', 2],
-        options: ['glucose', 2, { value: 'dox', label: 'Doxorubicin' }],
-      },
-    })
-
-    expect(wrapper.findAll('button').map(button => button.text())).toEqual([
-      'glucose',
-      '2',
-      'Doxorubicin',
-    ])
-    expect(wrapper.find('.mint-multi-select__summary').text()).toBe('glucose, 2')
-
-    await wrapper.findAll('button')[2].trigger('click')
-
-    expect(wrapper.emitted('update:modelValue')?.[0]).toEqual([
-      ['glucose', 2, 'dox'],
-    ])
-  })
-
-  it('uses the shared selection limit for maxSelections', async () => {
-    const wrapper = mount(MultiSelect, {
-      props: {
-        modelValue: ['a'],
-        options,
-        maxSelections: 1,
-      },
-    })
-
-    await wrapper.findAll('button')[1].trigger('click')
-
-    expect(wrapper.emitted('update:modelValue')).toBeUndefined()
-    expect(wrapper.findAll('button')[1].attributes('disabled')).toBeDefined()
-  })
-
-  it('should reserve the check slot on every chip when only one is selected', () => {
-    const wrapper = mount(MultiSelect, { props: { modelValue: ['a'], options } })
-
-    expect(wrapper.findAll('.mint-multi-select__chip-check')).toHaveLength(3)
-  })
-})