@morscherlab/mint-sdk 1.0.0-rc.1 → 1.0.0-rc.4

package/dist/utils/rack.d.ts

@@ -0,0 +1,47 @@
+import { Rack, SlotPosition, WellEditData, WellPlateFormat } from '../types';
+export type LcmsPlateType = '96well' | '54vial';
+export type LcmsControlSampleType = 'blank' | 'qc' | 'iqc';
+export interface LcmsPlateCell {
+    row: string;
+    column: number;
+    sample_name: string;
+    sample_type?: string | null;
+    injection_volume?: number | null;
+    injection_count?: number | null;
+    custom_method?: string | null;
+    slot?: SlotPosition | null;
+}
+export interface LcmsPlateCellsToRackOptions {
+    rackId?: string;
+    rackName?: string;
+    format?: WellPlateFormat;
+    plateType?: LcmsPlateType;
+    slot?: SlotPosition;
+    injectionVolume?: number;
+}
+export interface LcmsPlateCellsToRacksOptions extends Omit<LcmsPlateCellsToRackOptions, 'rackId' | 'rackName' | 'slot'> {
+    defaultSlot?: SlotPosition;
+    rackId?: (slot: SlotPosition, index: number) => string;
+    rackName?: (slot: SlotPosition, index: number) => string;
+}
+export declare const LCMS_DEFAULT_CONTROL_POSITIONS: Record<LcmsPlateType, Record<LcmsControlSampleType, {
+    row: string;
+    column: number;
+}>>;
+export declare function lcmsPlateTypeToRackFormat(plateType: LcmsPlateType): WellPlateFormat;
+export declare function rackFormatToLcmsPlateType(format: WellPlateFormat): LcmsPlateType;
+export declare function lcmsWellId(row: string, column: number): string;
+export declare function parseLcmsWellId(wellId: string): {
+    row: string;
+    column: number;
+};
+export declare function lcmsPlateCellsToRack(cells: LcmsPlateCell[], options?: LcmsPlateCellsToRackOptions): Rack;
+export declare function lcmsPlateCellsToRacks(cells: LcmsPlateCell[], options?: LcmsPlateCellsToRacksOptions): Rack[];
+export declare function rackToLcmsPlateCells(rack: Rack): LcmsPlateCell[];
+export declare function racksToLcmsPlateCells(racks: Rack[]): LcmsPlateCell[];
+export declare function getLcmsDefaultControlWellId(plateType: LcmsPlateType, sampleType: LcmsControlSampleType): string;
+export declare function createLcmsControlWellEditData(sampleType: LcmsControlSampleType, options?: {
+    wellId?: string;
+    plateType?: LcmsPlateType;
+    injectionVolume?: number;
+}): WellEditData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morscherlab/mint-sdk",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.4",
   "description": "MINT Platform SDK — Vue 3 components, composables, and types for plugin development. MINT = Mass-spec INtegrated Toolkit.",
   "type": "module",
   "main": "./dist/index.js",

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

@@ -367,6 +367,21 @@ describe('AppTopBar', () => {
       expect(settingsModal.props('showAppearance')).toBe(false)
     })
 
+    it('should pass settings userType to SettingsModal', () => {
+      const settingsConfig: TopBarSettingsConfig = {
+        userType: 'admin',
+      }
+
+      const wrapper = createWrapper({
+        title: 'Test App',
+        showSettings: true,
+        settingsConfig,
+      })
+
+      const settingsModal = wrapper.findComponent(SettingsModal)
+      expect(settingsModal.props('userType')).toBe('admin')
+    })
+
     it('should default showAppearance to true when not specified', () => {
       const wrapper = createWrapper({
         title: 'Test App',

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

@@ -22,4 +22,19 @@ describe('BaseTabs', () => {
 
     expect(wrapper.emitted('update:modelValue')).toEqual([['Results']])
   })
+
+  it('renders svg path icons', () => {
+    const wrapper = mount(BaseTabs, {
+      props: {
+        modelValue: 'users',
+        tabs: [
+          { id: 'users', label: 'Users', icon: 'M12 4h8M12 12h8M12 20h8' },
+          { id: 'logs', label: 'Logs', icon: ['M4 4h16v16H4z', 'M8 8h8'] },
+        ],
+      },
+    })
+
+    expect(wrapper.findAll('svg.mint-tab__icon--svg')).toHaveLength(2)
+    expect(wrapper.findAll('path')).toHaveLength(3)
+  })
 })

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

@@ -0,0 +1,57 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import LcmsSequenceTable from '../../components/LcmsSequenceTable.vue'
+import type { LcmsSequenceItem } from '../../lcms'
+
+function makeItems(): LcmsSequenceItem[] {
+  return [
+    {
+      sample_type: 'Unknown',
+      file_name: 'Batch_NEG_S1_001',
+      sample_id: 'R:A1',
+      path: '',
+      instrument_method: 'C:\\Methods\\neg.meth',
+      position: 'R:A1',
+      injection_volume: 5,
+    },
+    {
+      sample_type: 'Blank',
+      file_name: 'Batch_NEG_Blank_002',
+      sample_id: 'R:F9',
+      path: '',
+      instrument_method: 'C:\\Methods\\blank.meth',
+      position: 'R:F9',
+      injection_volume: 5,
+    },
+  ]
+}
+
+describe('LcmsSequenceTable', () => {
+  it('renders Xcalibur sequence rows with method basenames', () => {
+    const wrapper = mount(LcmsSequenceTable, {
+      props: {
+        items: makeItems(),
+      },
+    })
+
+    expect(wrapper.text()).toContain('Batch_NEG_S1_001')
+    expect(wrapper.text()).toContain('neg.meth')
+    expect(wrapper.text()).toContain('Blank')
+  })
+
+  it('emits editable row actions', async () => {
+    const wrapper = mount(LcmsSequenceTable, {
+      props: {
+        items: makeItems(),
+        editable: true,
+      },
+    })
+
+    const actions = wrapper.findAll('.mint-lcms-sequence-table__action')
+    await actions[0].trigger('click')
+    await actions[1].trigger('click')
+
+    expect(wrapper.emitted('duplicate')?.[0]).toEqual([0])
+    expect(wrapper.emitted('remove')?.[0]).toEqual([0])
+  })
+})

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

@@ -0,0 +1,18 @@
+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/RackEditor.test.ts

@@ -0,0 +1,125 @@
+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/SampleSelector.test.ts

@@ -57,4 +57,29 @@ describe('SampleSelector', () => {
 
     expect(wrapper.find('.mint-sample-selector__sample-name').exists()).toBe(false)
   })
+
+  it('can derive samples directly from experiment design data', () => {
+    const wrapper = mount(SampleSelector, {
+      props: {
+        modelValue: [],
+        designData: {
+          samples: [
+            { sample_name: 'S1', sample_type: 'sample' },
+            { sample_name: 'Blank', sample_type: 'blank' },
+            { sample_name: 'S2', sample_type: 'sample' },
+          ],
+        },
+        enableGrouping: false,
+        enableSmartGroup: false,
+      },
+      global: {
+        stubs: {
+          AutoGroupModal: true,
+        },
+      },
+    })
+
+    expect(wrapper.find('.mint-sample-selector__select-all-count').text()).toBe('2 samples')
+    expect(wrapper.findAll('.mint-sample-selector__flat-name').map(item => item.text())).toEqual(['S1', 'S2'])
+  })
 })

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

@@ -21,4 +21,49 @@ describe('SegmentedControl', () => {
 
     expect(wrapper.emitted('update:modelValue')?.[0]).toEqual([96])
   })
+
+  it('renders option-level disabled tabs without allowing selection', async () => {
+    const wrapper = mount(SegmentedControl, {
+      props: {
+        modelValue: 'active',
+        options: [
+          { value: 'active', label: 'Active' },
+          { value: 'archived', label: 'Archived', disabled: true },
+        ],
+      },
+    })
+
+    const buttons = wrapper.findAll('button')
+
+    expect(buttons).toHaveLength(2)
+    expect(buttons[1].attributes('disabled')).toBeDefined()
+    expect(buttons[1].classes()).toContain('mint-segmented-control__option--disabled')
+
+    await buttons[1].trigger('click')
+
+    expect(wrapper.emitted('update:modelValue')).toBeUndefined()
+  })
+
+  it('can disable tabs by value while keeping them visible', async () => {
+    const wrapper = mount(SegmentedControl, {
+      props: {
+        modelValue: 'table',
+        options: [
+          { value: 'table', label: 'Table' },
+          { value: 'chart', label: 'Chart' },
+        ],
+        disabledValues: ['chart'],
+      },
+    })
+
+    const buttons = wrapper.findAll('button')
+
+    expect(buttons.map(button => button.text())).toEqual(['Table', 'Chart'])
+    expect(buttons[1].attributes('disabled')).toBeDefined()
+
+    await buttons[1].trigger('keydown.enter')
+    await buttons[1].trigger('click')
+
+    expect(wrapper.emitted('update:modelValue')).toBeUndefined()
+  })
 })

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

@@ -0,0 +1,39 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import SequenceProgressBar from '../../components/SequenceProgressBar.vue'
+
+describe('SequenceProgressBar', () => {
+  it('renders sequence progress and remaining time', () => {
+    const wrapper = mount(SequenceProgressBar, {
+      props: {
+        progress: {
+          current_sample: 3,
+          total_samples: 6,
+          elapsed_seconds: 180,
+          sample_durations: [50, 70, 60],
+        },
+      },
+    })
+
+    expect(wrapper.get('.mint-sequence-progress__label').text()).toBe('3 / 6 samples')
+    expect(wrapper.get('.mint-sequence-progress__percent').text()).toBe('50%')
+    expect(wrapper.text()).toContain('~3m left')
+  })
+
+  it('supports compact rendering without footer labels', () => {
+    const wrapper = mount(SequenceProgressBar, {
+      props: {
+        compact: true,
+        label: 'injections',
+        progress: {
+          current_sample: 2,
+          total_samples: 4,
+          estimated_remaining_seconds: 120,
+        },
+      },
+    })
+
+    expect(wrapper.get('.mint-sequence-progress__label').text()).toBe('2 / 4 injections')
+    expect(wrapper.find('.mint-sequence-progress__footer').exists()).toBe(false)
+  })
+})

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

@@ -3,10 +3,11 @@ import { createPinia } from 'pinia'
 import { describe, expect, it } from 'vitest'
 import SettingsModal from '../../components/SettingsModal.vue'
 import { defineControlModel, type ControlSchema } from '../../composables/useControlSchema'
+import { useAuthStore } from '../../stores/auth'
 import type { SettingsModalSchema } from '../../types'
 
 describe('SettingsModal', () => {
-  function mountSettingsModal(props = {}, slots = {}) {
+  function mountSettingsModal(props = {}, slots = {}, pinia = createPinia()) {
     return mount(SettingsModal, {
       props: {
         modelValue: true,
@@ -15,7 +16,7 @@ describe('SettingsModal', () => {
       },
       slots,
       global: {
-        plugins: [createPinia()],
+        plugins: [pinia],
         stubs: {
           teleport: true,
         },
@@ -293,4 +294,84 @@ describe('SettingsModal', () => {
       threshold: 0.25,
     })
   })
+
+  it('filters schema groups and fields by explicit user type', async () => {
+    const schema: SettingsModalSchema = {
+      groups: [
+        {
+          id: 'general',
+          label: 'General',
+          fields: [
+            { name: 'common', label: 'Common', type: 'text', defaultValue: 'shared' },
+            { name: 'adminSecret', label: 'Admin Secret', type: 'text', visibleFor: 'admin' },
+            { name: 'userNote', label: 'User Note', type: 'text', visibleFor: 'user' },
+          ],
+        },
+        {
+          id: 'admin',
+          label: 'Admin',
+          visibleFor: 'admin',
+          fields: [
+            { name: 'adminOnly', label: 'Admin Only', type: 'text' },
+          ],
+        },
+      ],
+    }
+
+    const userWrapper = mountSettingsModal({ schema, userType: 'user' })
+
+    expect(userWrapper.text()).toContain('Common')
+    expect(userWrapper.text()).toContain('User Note')
+    expect(userWrapper.text()).not.toContain('Admin Secret')
+    expect(userWrapper.text()).not.toContain('Admin Only')
+
+    const adminWrapper = mountSettingsModal({ schema, userType: 'admin' })
+
+    expect(adminWrapper.findAll('.mint-settings-modal__tab').map(tab => tab.text())).toEqual([
+      'General',
+      'Admin',
+    ])
+    expect(adminWrapper.text()).toContain('Common')
+    expect(adminWrapper.text()).toContain('Admin Secret')
+    expect(adminWrapper.text()).not.toContain('User Note')
+
+    await adminWrapper.findAll('.mint-settings-modal__tab')[1].trigger('click')
+
+    expect(adminWrapper.text()).toContain('Admin Only')
+  })
+
+  it('uses SDK auth permissions when no user type override is passed', () => {
+    const pinia = createPinia()
+    const auth = useAuthStore(pinia)
+    auth.setUserInfo({
+      id: '1',
+      username: 'admin',
+      shortname: null,
+      email: null,
+      role: 'member',
+      roleObj: {
+        slug: 'member',
+        permissions: ['plugins.configure'],
+      },
+      isActive: true,
+    })
+    const schema: SettingsModalSchema = {
+      groups: [
+        {
+          id: 'plugins',
+          label: 'Plugins',
+          permissions: ['plugins.configure'],
+          fields: [
+            { name: 'registry', label: 'Registry', type: 'text' },
+            { name: 'danger', label: 'Danger Zone', type: 'text', requiresAdmin: true },
+          ],
+        },
+      ],
+    }
+
+    const wrapper = mountSettingsModal({ schema }, {}, pinia)
+
+    expect(wrapper.text()).toContain('Registry')
+    expect(wrapper.text()).not.toContain('Danger Zone')
+  })
 })

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

@@ -478,6 +478,8 @@ describe('useControlSchema', () => {
           icon: '<svg viewBox="0 0 24 24"></svg>',
           columns: 2,
           condition,
+          visibleFor: 'admin',
+          permissions: ['plugins.configure'],
         },
       },
     })
@@ -490,6 +492,8 @@ describe('useControlSchema', () => {
       icon: '<svg viewBox="0 0 24 24"></svg>',
       columns: 2,
       condition,
+      visibleFor: 'admin',
+      permissions: ['plugins.configure'],
     })
     expect(schema.groups[0].fields.map(field => field.name)).toEqual(['threshold', 'method'])
     expect(schema.groups[1].label).toBe('Output')

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

@@ -70,6 +70,29 @@ describe('useExperimentData', () => {
     expect(hook2.treeData.value).toEqual([{ id: '2' }])
   })
 
+  it('unwraps platform design-data responses and exposes sample helpers', async () => {
+    const response = {
+      experiment_id: 42,
+      plugin_id: 'ms-designer',
+      schema_version: '1.0',
+      data: {
+        tree_data: [{ id: 'design' }],
+        samples: [
+          { sample_name: 'S1', sample_type: 'sample', conditions: { group: 'A' } },
+          { sample_name: 'Blank', sample_type: 'blank', conditions: { group: 'QC' } },
+        ],
+      },
+    }
+    fakeResponse = response
+    const hook = useExperimentData()
+    await hook.fetch(42)
+
+    expect(hook.designData.value).toEqual(response.data)
+    expect(hook.treeData.value).toEqual([{ id: 'design' }])
+    expect(hook.sampleNames.value).toEqual(['S1'])
+    expect(hook.sampleOptions.value).toEqual([{ value: 'S1', label: 'S1' }])
+  })
+
   it('tableData falls back to empty array when absent', async () => {
     fakeResponse = {}
     const hook = useExperimentData()

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

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import axios, { type AxiosRequestConfig } from 'axios'
+
+import { useExperimentSamples } from '../../composables/useExperimentSamples'
+
+let fakeResponse: unknown = null
+let fakeError: Error | null = null
+let recordedUrls: string[] = []
+
+describe('useExperimentSamples', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    fakeResponse = {}
+    fakeError = null
+    recordedUrls = []
+    vi.spyOn(axios.Axios.prototype, 'get').mockImplementation(async function (
+      this: unknown,
+      url: string,
+      _config?: AxiosRequestConfig,
+    ) {
+      recordedUrls.push(url)
+      if (fakeError) throw fakeError
+      return { data: fakeResponse }
+    })
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('derives samples from pre-fetched MS Designer design_data', () => {
+    const hook = useExperimentSamples({
+      syncAppExperiment: false,
+      designData: {
+        samples: [
+          { sample_name: 'S1', sample_type: 'sample', conditions: { group: 'A' } },
+          { sample_name: 'QC1', sample_type: 'qc', conditions: { group: 'QC' } },
+        ],
+      },
+    })
+
+    expect(hook.samples.value).toEqual(['S1'])
+    expect(hook.sampleOptions.value).toEqual([{ value: 'S1', label: 'S1' }])
+    expect(recordedUrls).toEqual([])
+  })
+
+  it('loads and unwraps platform design_data for an experiment id', async () => {
+    fakeResponse = {
+      experiment_id: 7,
+      plugin_id: 'ms-designer',
+      data: {
+        samples: [
+          { sample_name: 'S1', sample_type: 'sample' },
+          { sample_name: 'S2', sample_type: 'sample' },
+        ],
+      },
+      schema_version: '1.0',
+    }
+    const hook = useExperimentSamples({ syncAppExperiment: false, immediate: false })
+
+    await hook.fetch(7)
+
+    expect(recordedUrls).toEqual(['/experiments/7/data'])
+    expect(hook.samples.value).toEqual(['S1', 'S2'])
+  })
+
+  it('extracts options from template collection sample sheets', () => {
+    const hook = useExperimentSamples({
+      syncAppExperiment: false,
+      designData: {
+        templates: {
+          'sample-sheet': {
+            data: {
+              samples: [
+                { sampleId: 'ctrl', name: 'Control', group: 'baseline' },
+                { sampleId: 'drug', name: 'Drug', group: 'treated' },
+              ],
+            },
+          },
+        },
+      },
+    })
+
+    expect(hook.samples.value).toEqual(['ctrl', 'drug'])
+    expect(hook.sampleOptions.value).toEqual([
+      { value: 'ctrl', label: 'Control', description: 'baseline' },
+      { value: 'drug', label: 'Drug', description: 'treated' },
+    ])
+  })
+})