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

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

@@ -0,0 +1,161 @@
+import { mount } from '@vue/test-utils'
+import { h, nextTick } from 'vue'
+import { describe, expect, it, vi } from 'vitest'
+import BioTemplateExperimentWorkspaceView from '../../components/BioTemplateExperimentWorkspaceView.vue'
+import BioTemplatePackWorkspaceView from '../../components/BioTemplatePackWorkspaceView.vue'
+import { useBioTemplatePackWorkspace } from '../../composables/useBioTemplatePackWorkspace'
+
+const mockGet = vi.fn()
+const mockPut = vi.fn()
+const mockDelete = vi.fn()
+
+vi.mock('../../composables/useApi', () => ({
+  useApi: () => ({
+    get: mockGet,
+    put: mockPut,
+    delete: mockDelete,
+  }),
+}))
+
+const globalOptions = {
+  stubs: {
+    DataFrame: true,
+    DoseCalculator: true,
+    PlateMapEditor: true,
+    SampleSelector: true,
+    WellPlate: true,
+  },
+}
+
+describe('BioTemplatePackWorkspaceView', () => {
+  it('creates a saveable pack workspace from one pack id', () => {
+    const wrapper = mount(BioTemplatePackWorkspaceView, {
+      props: {
+        pack: 'cell culture',
+      },
+      global: globalOptions,
+    })
+
+    expect(wrapper.text()).toContain('Cell culture screen saves the full template collection')
+    expect(wrapper.text()).toContain('sample-sheet')
+    expect(wrapper.text()).toContain('dose-response')
+    expect(wrapper.find('.mint-bio-template-renderer').exists()).toBe(true)
+  })
+
+  it('forwards load, reset, and save actions to the pack workspace', async () => {
+    const workspace = useBioTemplatePackWorkspace('cell-culture-screen')
+    const loadCurrent = vi.fn()
+    const resetToDefaultCollection = vi.fn()
+    const saveCurrent = vi.fn()
+    workspace.loadCurrent = loadCurrent
+    workspace.resetToDefaultCollection = resetToDefaultCollection
+    workspace.saveCurrent = saveCurrent
+    const wrapper = mount(BioTemplatePackWorkspaceView, {
+      props: { workspace },
+      global: globalOptions,
+    })
+
+    const child = wrapper.findComponent(BioTemplateExperimentWorkspaceView)
+    const actions = child.props('actions') as {
+      load: () => unknown
+      reset: () => unknown
+      save: () => unknown
+    }
+    actions.load()
+    actions.reset()
+    actions.save()
+    await nextTick()
+
+    expect(loadCurrent).toHaveBeenCalledTimes(1)
+    expect(resetToDefaultCollection).toHaveBeenCalledTimes(1)
+    expect(saveCurrent).toHaveBeenCalledTimes(1)
+  })
+
+  it('uses external status and actions for plugin-backed persistence', async () => {
+    const workspace = useBioTemplatePackWorkspace('cell-culture-screen')
+    const load = vi.fn()
+    const reset = vi.fn()
+    const save = vi.fn()
+    const lastLoadedAt = new Date('2026-01-02T03:04:05Z')
+    const wrapper = mount(BioTemplatePackWorkspaceView, {
+      props: {
+        workspace,
+        status: {
+          loading: false,
+          error: 'Plugin request failed.',
+          hasExperiment: true,
+          currentExperimentId: 42,
+          lastLoadedAt,
+          lastSavedAt: null,
+        },
+        actions: { load, reset, save },
+      },
+      global: globalOptions,
+    })
+
+    const child = wrapper.findComponent(BioTemplateExperimentWorkspaceView)
+    expect(child.props('status')).toMatchObject({
+      loading: false,
+      error: 'Plugin request failed.',
+      hasExperiment: true,
+      currentExperimentId: 42,
+      lastLoadedAt,
+      lastSavedAt: null,
+    })
+
+    const actions = child.props('actions') as {
+      load: () => unknown
+      reset: () => unknown
+      save: () => unknown
+    }
+    actions.load()
+    actions.reset()
+    actions.save()
+    await nextTick()
+
+    expect(load).toHaveBeenCalledTimes(1)
+    expect(reset).toHaveBeenCalledTimes(1)
+    expect(save).toHaveBeenCalledTimes(1)
+  })
+
+  it('exposes pack workspace and generated component props to the default slot', () => {
+    const wrapper = mount(BioTemplatePackWorkspaceView, {
+      props: {
+        pack: 'cell-culture-screen',
+      },
+      slots: {
+        default: ({ bindings, pack, componentPropsById, form, getComponentProps, pillNav, sidebar, topBarSettings }) => h(
+          'pre',
+          { class: 'component-props' },
+          JSON.stringify({
+            pack: pack.name,
+            activeView: sidebar.activeView,
+            doseMode: componentPropsById['dose-response:DoseCalculator'].mode,
+            bindingDoseMode: bindings.componentPropsById['dose-response:DoseCalculator'].mode,
+            hasPlateWells: Boolean(componentPropsById['plate-map:WellPlate'].wells),
+            doseModeFromGetter: getComponentProps('DoseCalculator')?.mode,
+            bindingDoseModeFromGetter: bindings.getComponentProps('DoseCalculator')?.mode,
+            formModelMatchesSidebar: form.modelValue === sidebar.values,
+            navItems: pillNav.items.map((item: { id: string }) => item.id),
+            settingsValuesMatch: topBarSettings.settingsConfig.values === sidebar.values,
+          }),
+        ),
+      },
+      global: globalOptions,
+    })
+
+    expect(JSON.parse(wrapper.find('.component-props').text())).toEqual({
+      pack: 'cell-culture-screen',
+      activeView: 'design',
+      doseMode: 'serial',
+      bindingDoseMode: 'serial',
+      hasPlateWells: true,
+      doseModeFromGetter: 'serial',
+      bindingDoseModeFromGetter: 'serial',
+      formModelMatchesSidebar: true,
+      navItems: ['design'],
+      settingsValuesMatch: true,
+    })
+    expect(wrapper.find('.mint-bio-template-renderer').exists()).toBe(false)
+  })
+})

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

@@ -0,0 +1,281 @@
+import { mount } from '@vue/test-utils'
+import { h, nextTick } from 'vue'
+import { describe, expect, it, vi } from 'vitest'
+import AppSidebar from '../../components/AppSidebar.vue'
+import BioTemplatePresetWorkspaceView from '../../components/BioTemplatePresetWorkspaceView.vue'
+import { useBioTemplatePresetWorkspace } from '../../composables/useBioTemplatePresetWorkspace'
+
+vi.mock('../../composables/useApi', () => ({
+  useApi: () => ({
+    get: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+  }),
+}))
+
+describe('BioTemplatePresetWorkspaceView', () => {
+  it('renders preset controls and template previews from one workspace object', () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen')
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: { workspace },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    expect(wrapper.find('.mint-bio-template-preset-workspace').exists()).toBe(true)
+    expect(wrapper.text()).toContain('Well-plate screen preset saves')
+    expect(wrapper.find('.mint-sidebar').exists()).toBe(true)
+    expect(wrapper.find('.mint-bio-template-renderer').exists()).toBe(true)
+    expect(wrapper.text()).toContain('plate-map')
+    expect(wrapper.text()).toContain('dose-response')
+  })
+
+  it('can create the preset workspace internally from a preset id', () => {
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: {
+        preset: 'wellplate-screen',
+        workspaceOptions: {
+          initialValues: {
+            sampleNames: ['Vehicle', 'Drug'],
+            unit: 'nM',
+          },
+        },
+      },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    expect(wrapper.text()).toContain('Well-plate screen preset saves')
+    expect(wrapper.findComponent(AppSidebar).props('modelValue')).toMatchObject({
+      sampleNames: ['Vehicle', 'Drug'],
+      unit: 'nM',
+    })
+    expect(wrapper.text()).toContain('plate-map')
+    expect(wrapper.text()).toContain('dose-response')
+  })
+
+  it('updates the internally generated workspace when the preset changes after mount', async () => {
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: {
+        preset: 'wellplate-screen',
+      },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    expect(wrapper.text()).toContain('Well-plate screen preset saves')
+    expect(wrapper.findComponent(AppSidebar).props('activeView')).toBe('design')
+
+    await wrapper.setProps({ preset: 'lcms-batch' })
+
+    expect(wrapper.text()).toContain('LC-MS batch preset saves')
+    expect(wrapper.findComponent(AppSidebar).props('activeView')).toBe('run')
+    expect(wrapper.text()).toContain('instrument-run')
+    expect(wrapper.text()).toContain('assay-matrix')
+  })
+
+  it('applies workspace options that are loaded after mount', async () => {
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: {
+        preset: 'wellplate-screen',
+      },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    expect(wrapper.findComponent(AppSidebar).props('modelValue')).toMatchObject({
+      sampleNames: ['Control', 'Treatment'],
+    })
+
+    await wrapper.setProps({
+      workspaceOptions: {
+        initialValues: {
+          sampleNames: ['Vehicle', 'Drug'],
+          unit: 'nM',
+        },
+      },
+    })
+
+    expect(wrapper.findComponent(AppSidebar).props('modelValue')).toMatchObject({
+      sampleNames: ['Vehicle', 'Drug'],
+      unit: 'nM',
+    })
+  })
+
+  it('supports v-model control values for internally generated workspaces', async () => {
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: {
+        preset: 'wellplate-screen',
+        modelValue: {
+          sampleNames: ['Vehicle', 'Drug'],
+          unit: 'nM',
+        },
+      },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    expect(wrapper.findComponent(AppSidebar).props('modelValue')).toMatchObject({
+      sampleNames: ['Vehicle', 'Drug'],
+      unit: 'nM',
+    })
+
+    wrapper.findComponent(AppSidebar).vm.$emit('update:modelValue', {
+      sampleNames: ['Vehicle', 'Updated'],
+      unit: 'nM',
+    })
+    await nextTick()
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)).toEqual([
+      expect.objectContaining({
+        sampleNames: ['Vehicle', 'Updated'],
+        unit: 'nM',
+      }),
+    ])
+    expect(wrapper.emitted('update:values')?.at(-1)).toEqual([
+      expect.objectContaining({
+        sampleNames: ['Vehicle', 'Updated'],
+        unit: 'nM',
+      }),
+    ])
+
+    await wrapper.setProps({
+      modelValue: {
+        sampleNames: ['External'],
+        unit: 'pM',
+      },
+    })
+    await nextTick()
+
+    expect(wrapper.findComponent(AppSidebar).props('modelValue')).toMatchObject({
+      sampleNames: ['External'],
+      unit: 'pM',
+    })
+  })
+
+  it('exposes generated component props to the default slot', () => {
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: {
+        preset: 'wellplate-screen',
+      },
+      slots: {
+        default: ({ bindings, collection, componentPropsById, getComponentProps }) => h(
+          'pre',
+          { class: 'component-props' },
+          JSON.stringify({
+            preset: collection.metadata?.preset,
+            doseMode: componentPropsById['dose-response:DoseCalculator'].mode,
+            bindingDoseMode: bindings.componentPropsById.value['dose-response:DoseCalculator'].mode,
+            hasPlateWells: Boolean(componentPropsById['plate-map:WellPlate'].wells),
+            doseModeFromGetter: getComponentProps('DoseCalculator')?.mode,
+            bindingDoseModeFromGetter: bindings.getComponentProps('DoseCalculator')?.mode,
+          }),
+        ),
+      },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    expect(JSON.parse(wrapper.find('.component-props').text())).toEqual({
+      preset: 'wellplate-screen',
+      doseMode: 'serial',
+      bindingDoseMode: 'serial',
+      hasPlateWells: true,
+      doseModeFromGetter: 'serial',
+      bindingDoseModeFromGetter: 'serial',
+    })
+    expect(wrapper.find('.mint-bio-template-renderer').exists()).toBe(false)
+  })
+
+  it('updates workspace control values through the embedded sidebar', async () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen')
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: { workspace },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    wrapper.findComponent(AppSidebar).vm.$emit('update:modelValue', {
+      ...workspace.controlValues.value,
+      sampleNames: ['Vehicle', 'Drug'],
+    })
+    await nextTick()
+
+    expect(workspace.controlValues.value.sampleNames).toEqual(['Vehicle', 'Drug'])
+    expect(workspace.sidebar.modelValue.sampleNames).toEqual(['Vehicle', 'Drug'])
+  })
+
+  it('switches generated sidebar views for mixed-view presets', async () => {
+    const workspace = useBioTemplatePresetWorkspace('lcms-batch')
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: { workspace },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    expect(wrapper.find('.mint-pill-nav').exists()).toBe(true)
+    expect(wrapper.findComponent(AppSidebar).props('activeView')).toBe('run')
+
+    await wrapper.findAll('.mint-pill-nav__item')[1].trigger('click')
+    await nextTick()
+
+    expect(workspace.activeControlView.value).toBe('analysis')
+    expect(wrapper.findComponent(AppSidebar).props('activeView')).toBe('analysis')
+  })
+})

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

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest'
+import { mount } from '@vue/test-utils'
+import BioTemplateRenderer from '../../components/BioTemplateRenderer.vue'
+import {
+  createLcmsBatchCollection,
+  createWellPlateScreenCollection,
+} from '../../templates'
+
+describe('BioTemplateRenderer', () => {
+  it('renders SDK components for a biology template collection', () => {
+    const collection = createWellPlateScreenCollection({
+      samples: ['Control', 'Treatment'],
+      compounds: { 'Drug A': [10, 1] },
+    })
+    const wrapper = mount(BioTemplateRenderer, {
+      props: { target: collection },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    expect(wrapper.find('.mint-bio-template-renderer').exists()).toBe(true)
+    expect(wrapper.find('[data-template-component="PlateMapEditor"]').exists()).toBe(true)
+    expect(wrapper.find('[data-template-component="DoseCalculator"]').exists()).toBe(true)
+    expect(wrapper.findAll('[data-template-component="WellPlate"]')).toHaveLength(2)
+    expect(wrapper.text()).toContain('plate-map')
+    expect(wrapper.text()).toContain('dose-response')
+  })
+
+  it('filters rendered components with include and exclude lists', () => {
+    const collection = createWellPlateScreenCollection()
+    const wrapper = mount(BioTemplateRenderer, {
+      props: {
+        target: collection,
+        include: ['WellPlate', 'DataFrame'],
+        exclude: ['DataFrame'],
+      },
+      global: {
+        stubs: {
+          WellPlate: true,
+        },
+      },
+    })
+
+    const components = wrapper
+      .findAll('[data-template-component]')
+      .map(item => item.attributes('data-template-component'))
+
+    expect(components).toEqual(['WellPlate', 'WellPlate'])
+  })
+
+  it('renders an empty state when no component binding survives filtering', () => {
+    const collection = createLcmsBatchCollection()
+    const wrapper = mount(BioTemplateRenderer, {
+      props: {
+        target: collection,
+        include: ['WellPlate'],
+        emptyText: 'No preview for this preset.',
+      },
+    })
+
+    expect(wrapper.findAll('[data-template-component]')).toHaveLength(0)
+    expect(wrapper.text()).toContain('No preview for this preset.')
+  })
+})

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

@@ -0,0 +1,23 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import Breadcrumb from '../../components/Breadcrumb.vue'
+
+describe('Breadcrumb', () => {
+  it('accepts string shorthand items', async () => {
+    const wrapper = mount(Breadcrumb, {
+      props: {
+        items: ['Project', { label: 'Experiment', href: '/experiments/EXP-001' }, 'Analysis'],
+      },
+    })
+
+    expect(wrapper.findAll('.mint-breadcrumb__item').map(item => item.text())).toEqual([
+      'Project',
+      'Experiment',
+      'Analysis',
+    ])
+
+    await wrapper.find('button.mint-breadcrumb__link').trigger('click')
+
+    expect(wrapper.emitted('navigate')).toEqual([[{ label: 'Project' }]])
+  })
+})

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

@@ -0,0 +1,36 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import CalendarGridPanel from '../../components/CalendarGridPanel.vue'
+import type { CalendarGridDay } from '../../composables/useCalendarGrid'
+
+const days: CalendarGridDay[] = [
+  { date: new Date(2026, 3, 20), isCurrentMonth: true, isDisabled: false },
+  { date: new Date(2026, 3, 21), isCurrentMonth: true, isDisabled: false },
+  { date: new Date(2026, 3, 22), isCurrentMonth: true, isDisabled: true },
+]
+
+describe('CalendarGridPanel', () => {
+  it('renders calendar state and emits navigation and selection events', async () => {
+    const wrapper = mount(CalendarGridPanel, {
+      props: {
+        weekDays: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+        monthYear: 'April 2026',
+        days,
+        selectedDate: days[1].date,
+      },
+    })
+
+    expect(wrapper.text()).toContain('April 2026')
+    expect(wrapper.findAll('.mint-date-picker__weekday')).toHaveLength(7)
+    expect(wrapper.find('.mint-date-picker__day--selected').text()).toBe('21')
+
+    const buttons = wrapper.findAll('button')
+    await buttons[0].trigger('click')
+    await buttons[1].trigger('click')
+    await wrapper.findAll('.mint-date-picker__day')[0].trigger('click')
+
+    expect(wrapper.emitted('previous-month')).toHaveLength(1)
+    expect(wrapper.emitted('next-month')).toHaveLength(1)
+    expect(wrapper.emitted('select')?.[0]).toEqual([days[0]])
+  })
+})

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

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+import { mount } from '@vue/test-utils'
+import ConcentrationInput from '../../components/ConcentrationInput.vue'
+import UnitInput from '../../components/UnitInput.vue'
+
+describe('ConcentrationInput', () => {
+  it('delegates value and unit selection to UnitInput', async () => {
+    const wrapper = mount(ConcentrationInput, {
+      props: {
+        modelValue: { value: 5, unit: 'µM' },
+        allowedUnits: ['nM', 'µM'],
+        min: 0,
+        max: 10,
+        size: 'sm',
+      },
+    })
+
+    const unitInput = wrapper.findComponent(UnitInput)
+    expect(unitInput.exists()).toBe(true)
+    expect(unitInput.props('modelValue')).toBe(5)
+    expect(unitInput.props('unit')).toBe('µM')
+    expect(unitInput.props('units')).toEqual([
+      { value: 'nM', label: 'nM', group: undefined },
+      { value: 'µM', label: 'µM', group: undefined },
+    ])
+
+    await unitInput.vm.$emit('update:modelValue', 8)
+    await unitInput.vm.$emit('update:unit', 'nM')
+
+    expect(wrapper.emitted('update:modelValue')).toEqual([
+      [{ value: 8, unit: 'µM' }],
+      [{ value: 5, unit: 'nM' }],
+    ])
+  })
+
+  it('keeps concentration-specific conversion hints', () => {
+    const wrapper = mount(ConcentrationInput, {
+      props: {
+        modelValue: { value: 1000, unit: 'nM' },
+      },
+    })
+
+    expect(wrapper.text()).toContain('1 µM')
+  })
+})