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

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

@@ -0,0 +1,199 @@
+import { nextTick } from 'vue'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockGet = vi.fn()
+const mockPut = vi.fn()
+const mockDelete = vi.fn()
+const mockUseApi = vi.fn((_options?: unknown) => ({
+  get: mockGet,
+  put: mockPut,
+  delete: mockDelete,
+}))
+
+vi.mock('../../composables/useApi', () => ({
+  useApi: (options: unknown) => mockUseApi(options),
+}))
+
+import { useBioTemplatePresetWorkspace } from '../../composables/useBioTemplatePresetWorkspace'
+import {
+  extractTemplateCollection,
+} from '../../templates'
+import type {
+  PlateMapTemplate,
+} from '../../templates'
+
+describe('useBioTemplatePresetWorkspace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockGet.mockResolvedValue({})
+    mockPut.mockResolvedValue({})
+    mockDelete.mockResolvedValue({})
+    window.history.replaceState({}, '', '/')
+  })
+
+  it('creates controls, renderer props, and component bindings from one preset id', () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen')
+
+    expect(workspace.presetId).toBe('wellplate-screen')
+    expect(workspace.presetInfo.value?.label).toBe('Well-plate screen')
+    expect(workspace.presetLabel.value).toBe('Well-plate screen')
+    expect(workspace.collection.value.metadata?.preset).toBe('wellplate-screen')
+    expect(workspace.controlSchema).toBe(workspace.controls.controls)
+    expect(workspace.controlValues.value.sampleNames).toEqual(['Control', 'Treatment'])
+    expect(workspace.sidebar.panels.design.map(panel => panel.id)).toContain('dose')
+    expect(workspace.form.modelValue).toBe(workspace.controlValues.value)
+    expect(workspace.sidebar.modelValue).toBe(workspace.controlValues.value)
+    expect(workspace.sidebar.values).toBe(workspace.controlValues.value)
+    expect(workspace.sidebar.activeView).toBe('design')
+    expect(workspace.pillNav.items).toEqual(workspace.controls.viewItems)
+    expect(workspace.pillNav.currentItemId).toBe('design')
+    expect(workspace.topBarSettings.settingsConfig.values).toBe(workspace.controlValues.value)
+    expect(workspace.bindings.form).toBe(workspace.form)
+    expect(workspace.bindings.sidebar).toBe(workspace.sidebar)
+    expect(workspace.bindings.topBarSettings).toBe(workspace.topBarSettings)
+    expect(workspace.bindings.pillNav).toBe(workspace.pillNav)
+    expect(workspace.bindings.topBar.value.currentPillId).toBe('design')
+    expect(workspace.bindings.topBarTabs.value.currentTabId).toBe('design')
+    expect(workspace.controlViewIds.value).toEqual(['design'])
+    expect(workspace.controlViewItems.value).toEqual([{ id: 'design', label: 'Design' }])
+    expect(workspace.activeControlView.value).toBe('design')
+    expect(workspace.renderer.value.target).toBe(workspace.collection.value)
+    expect(workspace.bindings.renderer.value.target).toBe(workspace.collection.value)
+    expect(workspace.componentBindings.value.map(binding => binding.component)).toContain('DoseCalculator')
+    expect(workspace.componentProps.value.map(binding => binding.component)).toContain('WellPlate')
+    expect(workspace.componentPropsById.value['dose-response:DoseCalculator'].mode).toBe('serial')
+    expect(workspace.bindings.componentPropsById.value['dose-response:DoseCalculator'].mode).toBe('serial')
+    expect(workspace.componentPropsByComponent.value.WellPlate).toHaveLength(2)
+    expect(workspace.getComponentProps('DoseCalculator')?.mode).toBe('serial')
+    expect(workspace.bindings.getComponentProps('DoseCalculator')?.mode).toBe('serial')
+    expect(workspace.componentUsage.value?.template).toContain('<DoseCalculator')
+  })
+
+  it('tracks active control view for mixed-view presets', () => {
+    const workspace = useBioTemplatePresetWorkspace('lcms-batch')
+
+    expect(workspace.controlViewIds.value).toEqual(['run', 'analysis'])
+    expect(workspace.controlViewItems.value).toEqual([
+      { id: 'run', label: 'Run' },
+      { id: 'analysis', label: 'Analysis' },
+    ])
+    expect(workspace.activeControlView.value).toBe('run')
+
+    workspace.setActiveControlView('analysis')
+    expect(workspace.activeControlView.value).toBe('analysis')
+    expect(workspace.sidebar.activeView).toBe('analysis')
+    expect(workspace.topBar.currentTabId).toBe('analysis')
+    expect(workspace.pillNav.currentItemId).toBe('analysis')
+
+    workspace.setActiveControlView('missing')
+    expect(workspace.activeControlView.value).toBe('analysis')
+  })
+
+  it('exposes live FormBuilder, AppSidebar, AppTopBar, and AppPillNav bindings', () => {
+    const workspace = useBioTemplatePresetWorkspace('lcms-batch')
+
+    workspace.form['onUpdate:modelValue']({
+      ...workspace.controlValues.value,
+      operator: 'Ada',
+    })
+    expect(workspace.controlValues.value.operator).toBe('Ada')
+    expect(workspace.form.modelValue).toBe(workspace.controlValues.value)
+    expect(workspace.sidebar.values).toBe(workspace.controlValues.value)
+    expect(workspace.topBarSettings.settingsConfig.values).toBe(workspace.controlValues.value)
+
+    workspace.pillNav.onSelect({ id: 'analysis', label: 'Analysis' })
+    expect(workspace.activeControlView.value).toBe('analysis')
+    expect(workspace.sidebar.activeView).toBe('analysis')
+    expect(workspace.topBar.currentTabId).toBe('analysis')
+    expect(workspace.bindings.topBar.value.currentPillId).toBe('analysis')
+    expect(workspace.bindings.topBarTabs.value.currentTabId).toBe('analysis')
+
+    workspace.topBar.onTabSelect({ id: 'run', label: 'Run' })
+    expect(workspace.activeControlView.value).toBe('run')
+    expect(workspace.pillNav.currentItemId).toBe('run')
+    expect(workspace.bindings.topBar.value.currentPillId).toBe('run')
+    expect(workspace.bindings.topBarTabs.value.currentTabId).toBe('run')
+  })
+
+  it('accepts direct initial values for generated preset controls and collection data', () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen', {
+      controlOptions: {
+        initialValues: {
+          sampleNames: ['Nested default'],
+          unit: 'uM',
+        },
+      },
+      initialValues: {
+        sampleNames: ['Vehicle', 'Drug'],
+        unit: 'nM',
+      },
+    })
+
+    const plate = extractTemplateCollection(workspace.collection.value)['plate-map'] as PlateMapTemplate
+
+    expect(workspace.controlValues.value.sampleNames).toEqual(['Vehicle', 'Drug'])
+    expect(workspace.controlValues.value.unit).toBe('nM')
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Vehicle', 'Drug'])
+  })
+
+  it('rebuilds the template collection when generated controls change', async () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen')
+
+    workspace.controlValues.value = {
+      ...workspace.controlValues.value,
+      sampleNames: ['Vehicle', 'Drug'],
+    }
+    await nextTick()
+
+    const plate = extractTemplateCollection(workspace.collection.value)['plate-map'] as PlateMapTemplate
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Vehicle', 'Drug'])
+  })
+
+  it('sets, updates, and resets generated control values without direct ref mutation', () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen')
+
+    const setCollection = workspace.setControlValues({
+      sampleNames: ['Vehicle', 'Drug'],
+      unit: 'nM',
+      replicates: 2,
+    })
+    let plate = extractTemplateCollection(setCollection)['plate-map'] as PlateMapTemplate
+
+    expect(workspace.collection.value).toBe(setCollection)
+    expect(workspace.controlValues.value).toEqual({
+      sampleNames: ['Vehicle', 'Drug'],
+      unit: 'nM',
+      replicates: 2,
+    })
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Vehicle', 'Drug'])
+
+    const updatedCollection = workspace.updateControlValues({ sampleNames: ['Updated'] })
+    plate = extractTemplateCollection(updatedCollection)['plate-map'] as PlateMapTemplate
+
+    expect(workspace.collection.value).toBe(updatedCollection)
+    expect(workspace.controlValues.value.unit).toBe('nM')
+    expect(workspace.controlValues.value.sampleNames).toEqual(['Updated'])
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Updated'])
+
+    const resetCollection = workspace.resetToDefaultCollection()
+    plate = extractTemplateCollection(resetCollection)['plate-map'] as PlateMapTemplate
+
+    expect(workspace.collection.value).toBe(resetCollection)
+    expect(workspace.controlValues.value.sampleNames).toEqual(['Control', 'Treatment'])
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Control', 'Treatment'])
+  })
+
+  it('saves the generated collection through current experiment wiring', async () => {
+    window.history.replaceState({}, '', '/experiments/42/templates')
+    const workspace = useBioTemplatePresetWorkspace('lcms-batch', { pluginId: 'p1' })
+
+    const ok = await workspace.saveCurrent()
+
+    expect(ok).toBe(true)
+    expect(mockPut).toHaveBeenCalledWith('/experiments/42/data', {
+      plugin_id: 'p1',
+      data: workspace.collection.value,
+      schema_version: '1.0',
+    })
+  })
+})

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

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest'
+import {
+  useBioTemplateWorkspace,
+} from '../../composables/useBioTemplateWorkspace'
+import {
+  createLcmsBatchCollection,
+  createWellPlateScreenCollection,
+} from '../../templates'
+
+describe('useBioTemplateWorkspace', () => {
+  it('returns AppSidebar, FormBuilder, renderer, and component bindings for a concrete collection', () => {
+    const collection = createWellPlateScreenCollection({
+      samples: ['Control', 'Treatment'],
+      compounds: { 'Drug A': [10, 1, 0.1] },
+      unit: 'uM',
+    })
+    const workspace = useBioTemplateWorkspace(collection)
+
+    expect(workspace.controlSchema).toBe(workspace.controls.controls)
+    expect(workspace.workspace.values).toBe(workspace.values)
+    expect(workspace.form).toBe(workspace.workspace.form)
+    expect(workspace.form.modelValue).toBe(workspace.values)
+    expect(workspace.sidebar).toBe(workspace.workspace.sidebar)
+    expect(workspace.sidebar.values).toBe(workspace.values)
+    expect(workspace.topBar).toBe(workspace.workspace.topBar)
+    expect(workspace.pillNav).toBe(workspace.workspace.pillNav)
+    expect(workspace.topBarSettings).toBe(workspace.workspace.topBarSettings)
+    expect(workspace.bindings.form).toBe(workspace.form)
+    expect(workspace.bindings.sidebar).toBe(workspace.sidebar)
+    expect(workspace.bindings.topBar).toBe(workspace.workspace.bindings.topBar)
+    expect(workspace.bindings.topBarSettings).toBe(workspace.topBarSettings)
+    expect(workspace.bindings.pillNav).toBe(workspace.pillNav)
+    expect(workspace.renderer).toEqual({ target: collection })
+    expect(workspace.bindings.renderer).toEqual({ target: collection })
+    expect(workspace.controls.initialValues.plateFormat).toBe(96)
+    expect(workspace.sidebar.panels.design.map(panel => panel.id)).toContain('dose')
+    expect(workspace.componentProps.map(binding => binding.component)).toContain('DoseCalculator')
+    expect(workspace.componentProps.map(binding => binding.component)).toContain('WellPlate')
+    expect(workspace.componentPropsById['plate-map:WellPlate'].wells).toBeDefined()
+    expect(workspace.bindings.componentPropsById['plate-map:WellPlate'].wells).toBeDefined()
+    expect(workspace.componentPropsById['dose-response:DoseCalculator'].mode).toBe('serial')
+    expect(workspace.componentPropsByComponent.WellPlate).toHaveLength(2)
+    expect(workspace.getComponentProps('DoseCalculator')?.mode).toBe('serial')
+    expect(workspace.bindings.getComponentProps('DoseCalculator')?.mode).toBe('serial')
+    expect(workspace.getComponentProps('WellPlate', { templateId: 'dose-response' })?.wells).toBeDefined()
+    expect(workspace.componentImports[0].statement).toContain('DoseCalculator')
+    expect(workspace.componentSnippets.map(snippet => snippet.component)).toContain('DoseCalculator')
+    expect(workspace.componentUsage?.template).toContain('<DoseCalculator')
+  })
+
+  it('returns preset controls and discoverable component metadata before concrete data exists', () => {
+    const workspace = useBioTemplateWorkspace('wellplate-screen')
+
+    expect(workspace.renderer).toBeNull()
+    expect(workspace.bindings.renderer).toBeNull()
+    expect(workspace.controlSchema.sampleNames).toBe(workspace.controls.controls.sampleNames)
+    expect(workspace.values.sampleNames).toEqual(['Control', 'Treatment'])
+    expect(workspace.activeView.value).toBe('design')
+    expect(workspace.topBar.tabs.map(tab => tab.id)).toContain('design')
+    expect(workspace.pillNav.items.map(item => item.id)).toContain('design')
+    expect(workspace.controls.initialValues.sampleNames).toEqual(['Control', 'Treatment'])
+    expect(workspace.sidebar.panels.design.map(panel => panel.id)).toContain('layout')
+    expect(workspace.componentBindings.map(binding => binding.component)).toContain('PlateMapEditor')
+    expect(workspace.componentImports[0].statement).toContain('WellPlate')
+    expect(workspace.componentProps).toEqual([])
+    expect(workspace.componentPropsById).toEqual({})
+    expect(workspace.bindings.componentPropsById).toEqual({})
+    expect(workspace.componentPropsByComponent).toEqual({})
+    expect(workspace.getComponentProps('WellPlate')).toBeUndefined()
+    expect(workspace.componentUsage).toBeNull()
+  })
+
+  it('accepts direct initial values for generated preset controls', () => {
+    const workspace = useBioTemplateWorkspace('wellplate-screen', {
+      initialValues: {
+        sampleNames: ['Vehicle', 'Drug'],
+        unit: 'nM',
+      },
+    })
+
+    expect(workspace.controls.initialValues.sampleNames).toEqual(['Vehicle', 'Drug'])
+    expect(workspace.controls.initialValues.unit).toBe('nM')
+    expect(workspace.values.sampleNames).toEqual(['Vehicle', 'Drug'])
+    expect(workspace.form.modelValue.sampleNames).toEqual(['Vehicle', 'Drug'])
+  })
+
+  it('supports mixed-view presets for AppSidebar panels', () => {
+    const collection = createLcmsBatchCollection({
+      samples: ['S001', 'S002'],
+      features: ['Glucose', 'Lactate'],
+    })
+    const workspace = useBioTemplateWorkspace(collection)
+
+    expect(Object.keys(workspace.sidebar.panels)).toEqual(['run', 'analysis'])
+    expect(workspace.form.schema.sections.map(section => section.id)).toContain('acquisition')
+    expect(workspace.renderer?.target).toBe(collection)
+    expect(workspace.componentProps.map(binding => binding.component)).toContain('DataFrame')
+  })
+})

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

@@ -0,0 +1,38 @@
+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', () => {
+    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.monthYear.value).toBe('May 2026')
+    expect(calendar.calendarDays.value).toHaveLength(42)
+    expect(calendar.calendarDays.value[0].date.getMonth()).toBe(3)
+    expect(calendar.calendarDays.value.some(day => day.isCurrentMonth && day.date.getDate() === 7)).toBe(true)
+  })
+
+  it('applies min and max date bounds at day precision', () => {
+    const calendar = useCalendarGrid({
+      min: () => '2026-05-05T14:00:00',
+      max: () => '2026-05-10T09:00:00',
+    })
+
+    expect(calendar.isDateDisabled(new Date('2026-05-04T23:59:00'))).toBe(true)
+    expect(calendar.isDateDisabled(new Date('2026-05-05T00:00:00'))).toBe(false)
+    expect(calendar.isDateDisabled(new Date('2026-05-10T23:59:00'))).toBe(false)
+    expect(calendar.isDateDisabled(new Date('2026-05-11T00:00:00'))).toBe(true)
+  })
+
+  it('formats dates and advances months', () => {
+    const calendar = useCalendarGrid()
+    calendar.setCurrentMonthFromDate(new Date('2026-01-15T00:00:00'))
+
+    expect(calendar.formatDateValue(new Date('2026-01-05T13:00:00'))).toBe('2026-01-05')
+    calendar.nextMonth()
+    expect(calendar.monthYear.value).toBe('February 2026')
+    calendar.prevMonth()
+    expect(calendar.monthYear.value).toBe('January 2026')
+  })
+})