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

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

@@ -0,0 +1,192 @@
+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,
+    ExperimentTimeline: true,
+    PlateMapEditor: true,
+    SampleSelector: true,
+    ScheduleCalendar: 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,
+          componentBindingsById,
+          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,
+            bindingMode: componentBindingsById['dose-response:DoseCalculator'].props.mode,
+            bindingDoseMode: bindings.componentPropsById['dose-response:DoseCalculator'].mode,
+            nestedBindingMode: bindings.componentBindingsById['dose-response:DoseCalculator'].props.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',
+      bindingMode: 'serial',
+      bindingDoseMode: 'serial',
+      nestedBindingMode: 'serial',
+      hasPlateWells: true,
+      doseModeFromGetter: 'serial',
+      bindingDoseModeFromGetter: 'serial',
+      formModelMatchesSidebar: true,
+      navItems: ['design'],
+      settingsValuesMatch: true,
+    })
+    expect(wrapper.find('.mint-bio-template-renderer').exists()).toBe(false)
+  })
+
+  it('renders metabolism pack run queues as timeline and calendar previews', () => {
+    const wrapper = mount(BioTemplatePackWorkspaceView, {
+      props: {
+        pack: 'metabolism',
+      },
+      global: globalOptions,
+    })
+
+    expect(wrapper.text()).toContain('Omics assay saves the full template collection')
+    expect(wrapper.find('[data-component-binding-id="instrument-run:ExperimentTimeline"]').exists()).toBe(true)
+    expect(wrapper.find('[data-component-binding-id="instrument-run:ScheduleCalendar"]').exists()).toBe(true)
+    expect(wrapper.find('[data-template-component="ExperimentTimeline"]').exists()).toBe(true)
+    expect(wrapper.find('[data-template-component="ScheduleCalendar"]').exists()).toBe(true)
+  })
+})

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

@@ -0,0 +1,328 @@
+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.findComponent(AppSidebar).props('variant')).toBe('analysis')
+    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('passes through sidebar variant overrides', () => {
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: {
+        preset: 'wellplate-screen',
+        sidebarVariant: 'default',
+      },
+      global: {
+        stubs: {
+          DataFrame: true,
+          DoseCalculator: true,
+          PlateMapEditor: true,
+          SampleSelector: true,
+          WellPlate: true,
+        },
+      },
+    })
+
+    expect(wrapper.findComponent(AppSidebar).props('variant')).toBe('default')
+  })
+
+  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, componentBindingsById, componentPropsById, getComponentProps }) => h(
+          'pre',
+          { class: 'component-props' },
+          JSON.stringify({
+            preset: collection.metadata?.preset,
+            doseMode: componentPropsById['dose-response:DoseCalculator'].mode,
+            bindingMode: componentBindingsById['dose-response:DoseCalculator'].props.mode,
+            bindingDoseMode: bindings.componentPropsById.value['dose-response:DoseCalculator'].mode,
+            nestedBindingMode: bindings.componentBindingsById.value['dose-response:DoseCalculator'].props.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',
+      bindingMode: 'serial',
+      bindingDoseMode: 'serial',
+      nestedBindingMode: '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')
+  })
+
+  it('renders LC-MS batch timeline and calendar previews from one preset prop', () => {
+    const wrapper = mount(BioTemplatePresetWorkspaceView, {
+      props: {
+        preset: 'lcms-batch',
+      },
+      global: {
+        stubs: {
+          DataFrame: true,
+          ExperimentTimeline: true,
+          ScheduleCalendar: true,
+          SampleSelector: true,
+        },
+      },
+    })
+
+    expect(wrapper.text()).toContain('LC-MS batch preset saves')
+    expect(wrapper.find('[data-component-binding-id="instrument-run:ExperimentTimeline"]').exists()).toBe(true)
+    expect(wrapper.find('[data-component-binding-id="instrument-run:ScheduleCalendar"]').exists()).toBe(true)
+    expect(wrapper.find('[data-template-component="ExperimentTimeline"]').exists()).toBe(true)
+    expect(wrapper.find('[data-template-component="ScheduleCalendar"]').exists()).toBe(true)
+  })
+})

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

@@ -0,0 +1,96 @@
+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('renders instrument-run timelines from LC-MS template collections', () => {
+    const collection = createLcmsBatchCollection({
+      samples: ['S001', 'S002'],
+      instrument: 'LC-MS',
+    })
+    const wrapper = mount(BioTemplateRenderer, {
+      props: { target: collection },
+      global: {
+        stubs: {
+          DataFrame: true,
+          ExperimentTimeline: true,
+          SampleSelector: true,
+          ScheduleCalendar: true,
+        },
+      },
+    })
+
+    expect(wrapper.find('[data-component-binding-id="instrument-run:ScheduleCalendar"]').exists()).toBe(true)
+    expect(wrapper.find('[data-component-binding-id="instrument-run:ExperimentTimeline"]').exists()).toBe(true)
+    expect(wrapper.find('[data-component-binding-id="assay-matrix:SampleSelector"]').exists()).toBe(true)
+    expect(wrapper.find('[data-template-component="ScheduleCalendar"]').exists()).toBe(true)
+    expect(wrapper.find('[data-template-component="ExperimentTimeline"]').exists()).toBe(true)
+    expect(wrapper.find('[data-template-id="instrument-run"]').exists()).toBe(true)
+  })
+
+  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' }]])
+  })
+})