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

package/src/__tests__/templates/templates.test.ts

@@ -20,6 +20,7 @@ import {
   createReagentListTemplate,
   createSampleSheetTemplate,
   createSamplePrepTemplate,
+  createTargetedMetabolomicsCollection,
   createDefaultBioTemplate,
   createTemplateCollection,
   createTimeCourseTemplate,
@@ -209,6 +210,7 @@ describe('bio data templates', () => {
       'wellplate-screen',
       'qpcr-expression',
       'lcms-batch',
+      'targeted-metabolomics',
       'elisa-assay',
       'flow-cytometry-assay',
       'western-blot-assay',
@@ -224,6 +226,8 @@ describe('bio data templates', () => {
     expect(getBioTemplatePresetInfo('metabolomics')?.name).toBe('lcms-batch')
     expect(getBioTemplatePresetInfo('metabolism')?.name).toBe('lcms-batch')
     expect(getBioTemplatePresetInfo('metabolite profiling')?.name).toBe('lcms-batch')
+    expect(getBioTemplatePresetInfo('targeted metabolomics')?.name).toBe('targeted-metabolomics')
+    expect(searchBioTemplatePresets('internal standards')[0].name).toBe('targeted-metabolomics')
     expect(getBioTemplatePresetInfo('immunoassay')?.templates).toEqual([
       'plate-map',
       'sample-sheet',
@@ -275,6 +279,7 @@ describe('bio data templates', () => {
     const plateSchema = getBioTemplateControlSchema('wellplate')
     const presetSchema = getBioTemplateControlSchema('wellplate-screen')
     const defaults = getBioTemplateControlDefaults('lcms-batch')
+    const targetedDefaults = getBioTemplateControlDefaults('targeted-metabolomics')
     const elisaDefaults = getBioTemplateControlDefaults('elisa-assay')
     const flowDefaults = getBioTemplateControlDefaults('flow-cytometry-assay')
     const westernDefaults = getBioTemplateControlDefaults('western-blot-assay')
@@ -284,6 +289,9 @@ describe('bio data templates', () => {
     expect(presetSchema?.replicates.default).toBe(3)
     expect(defaults.instrument).toBe('LC-MS')
     expect(defaults.featureNames).toEqual(['Glucose', 'Lactate'])
+    expect(targetedDefaults.metaboliteNames).toEqual(['Glucose', 'Lactate', 'Pyruvate'])
+    expect(targetedDefaults.internalStandards).toEqual(['Stable isotope internal standard mix'])
+    expect(targetedDefaults.method).toBe('Targeted metabolomics')
     expect(elisaDefaults.analyte).toBe('Analyte')
     expect(elisaDefaults.standardConcentrations).toEqual(['1000', '100', '10', '1'])
     expect(flowDefaults.markers).toEqual(['CD3', 'CD4', 'CD8'])
@@ -299,6 +307,7 @@ describe('bio data templates', () => {
     const elisaBindings = getBioTemplateComponentBindings('elisa-assay')
     const flowBindings = getBioTemplateComponentBindings('flow-cytometry-assay')
     const lcmsBindings = getBioTemplateComponentBindings('lcms-batch')
+    const targetedBindings = getBioTemplateComponentBindings('targeted-metabolomics')
     const westernBindings = getBioTemplateComponentBindings('western-blot-assay')
     const wellplateImports = toBioTemplateComponentImports('wellplate-screen')
 
@@ -311,6 +320,9 @@ describe('bio data templates', () => {
     expect(elisaBindings.map(binding => binding.component)).toContain('DataFrame')
     expect(lcmsBindings.map(binding => binding.component)).toContain('ScheduleCalendar')
     expect(lcmsBindings.map(binding => binding.component)).toContain('ExperimentTimeline')
+    expect(targetedBindings.map(binding => binding.component)).toContain('ReagentList')
+    expect(targetedBindings.map(binding => binding.component)).toContain('DataFrame')
+    expect(targetedBindings.map(binding => binding.component)).toContain('ScheduleCalendar')
     expect(flowBindings.map(binding => binding.template_id)).toEqual([
       'sample-sheet',
       'sample-sheet',
@@ -541,6 +553,13 @@ describe('bio data templates', () => {
       features: ['Glucose'],
       instrument: 'LC-MS',
     })
+    const targeted = createTargetedMetabolomicsCollection({
+      samples: ['S001', 'S002'],
+      metabolites: ['Glucose', 'Lactate'],
+      internalStandards: ['13C Glucose'],
+      standardConcentrations: [0.1, 1, 10],
+      instrument: 'Orbitrap',
+    })
     const flow = createFlowCytometryAssayCollection({
       samples: ['Control', 'Treatment'],
       markers: ['CD3', 'CD4'],
@@ -555,6 +574,7 @@ describe('bio data templates', () => {
     const wellplateTemplates = extractTemplateCollection(wellplate)
     const qpcrTemplates = extractTemplateCollection(qpcr)
     const lcmsTemplates = extractTemplateCollection(lcms)
+    const targetedTemplates = extractTemplateCollection(targeted)
     const flowTemplates = extractTemplateCollection(flow)
     const westernTemplates = extractTemplateCollection(western)
     const wellplateComponentProps = toBioTemplateComponentProps(wellplate)
@@ -572,6 +592,28 @@ describe('bio data templates', () => {
     expect(toInstrumentRunRows(lcmsTemplates['instrument-run'] as InstrumentRunTemplate)[2].sampleId).toBe('s001')
     expect(toTemplateDataFrame(lcmsTemplates['assay-matrix']).columns.map(column => column.key)).toContain('glucose')
     expect(toAssayMatrixSampleOptions(lcmsTemplates['assay-matrix'] as AssayMatrixTemplate).map(option => option.label)).toEqual(['S001', 'S002'])
+    expect(Object.keys(targetedTemplates)).toEqual([
+      'sample-sheet',
+      'sample-prep',
+      'reagent-list',
+      'instrument-run',
+      'calibration-curve',
+      'assay-matrix',
+    ])
+    expect(targeted.metadata?.preset).toBe('targeted-metabolomics')
+    expect(toReagentDataFrame(targetedTemplates['reagent-list'] as ReagentListTemplate).data[0].kind).toBe('compound')
+    expect(toTemplateDataFrame(targetedTemplates['calibration-curve']).data[0].role).toBe('blank')
+    expect(toInstrumentRunRows(targetedTemplates['instrument-run'] as InstrumentRunTemplate).map(row => row.kind)).toEqual([
+      'blank',
+      'standard',
+      'standard',
+      'standard',
+      'qc',
+      'qc',
+      'sample',
+      'sample',
+    ])
+    expect(toTemplateDataFrame(targetedTemplates['assay-matrix']).columns.map(column => column.key)).toContain('lactate')
     expect(Object.keys(flowTemplates)).toEqual(['sample-sheet', 'flow-cytometry-panel', 'assay-matrix'])
     expect(flow.metadata?.preset).toBe('flow-cytometry-assay')
     expect(flowTemplates['flow-cytometry-panel'].data).toMatchObject({
@@ -596,6 +638,7 @@ describe('bio data templates', () => {
     expect(Object.keys(extractTemplateCollection(aliasCollection))).toEqual(['plate-map', 'sample-sheet', 'dose-response'])
     expect(createBioTemplatePresetCollection('facs').metadata?.preset).toBe('flow-cytometry-assay')
     expect(createBioTemplatePresetCollection('immunoblot').metadata?.preset).toBe('western-blot-assay')
+    expect(createBioTemplatePresetCollection('targeted metabolomics').metadata?.preset).toBe('targeted-metabolomics')
     expect(() => createBioTemplatePresetCollection('unknown-preset')).toThrow("Unknown template preset 'unknown-preset'.")
   })
 
@@ -682,6 +725,49 @@ describe('bio data templates', () => {
     expect(run.data.items.map(item => item.kind)).toEqual(['blank', 'sample', 'sample'])
     expect(toTemplateDataFrame(lcmsTemplates['assay-matrix']).columns.map(column => column.key)).toContain('pyruvate')
 
+    const targetedOptions = bioTemplatePresetControlValuesToOptions('targeted-metabolomics', {
+      sampleNames: 'QC Pool, Patient A',
+      metaboliteNames: 'Glucose, Citrate',
+      internalStandards: '13C Glucose',
+      standardConcentrations: '0.5, 5, 50',
+      concentrationUnit: 'nM',
+      responseUnit: 'area ratio',
+      instrument: 'Triple quadrupole',
+      method: 'MRM panel',
+      outputVolume: '25',
+      includeQc: false,
+    })
+    const targetedTemplates = extractTemplateCollection(
+      createBioTemplatePresetCollectionFromControls('targeted-metabolomics', {
+        sampleNames: 'QC Pool, Patient A',
+        metaboliteNames: 'Glucose, Citrate',
+        internalStandards: '13C Glucose',
+        standardConcentrations: '0.5, 5, 50',
+        concentrationUnit: 'nM',
+        responseUnit: 'area ratio',
+        instrument: 'Triple quadrupole',
+        method: 'MRM panel',
+        outputVolume: '25',
+        includeQc: false,
+      }),
+    )
+    const targetedRun = targetedTemplates['instrument-run'] as InstrumentRunTemplate
+
+    expect(targetedOptions.metabolites).toEqual(['Glucose', 'Citrate'])
+    expect(targetedOptions.standardConcentrations).toEqual([0.5, 5, 50])
+    expect(targetedOptions.outputVolume).toBe(25)
+    expect(targetedRun.data.instrument).toBe('Triple quadrupole')
+    expect(targetedRun.data.methods[0].name).toBe('MRM panel')
+    expect(targetedRun.data.items.map(item => item.kind)).toEqual([
+      'blank',
+      'standard',
+      'standard',
+      'standard',
+      'sample',
+      'sample',
+    ])
+    expect(toTemplateDataFrame(targetedTemplates['assay-matrix']).columns.map(column => column.key)).toContain('citrate')
+
     const flowOptions = bioTemplatePresetControlValuesToOptions('flow-cytometry-assay', {
       sampleNames: 'Control, Treatment',
       markers: 'CD3, CD19',

package/src/__tests__/utils/instrument.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest'
+import {
+  estimateSequenceFinishDate,
+  estimateSequenceRemainingSeconds,
+  formatSequenceRemaining,
+  sequenceProgressPercent,
+} from '../../instrument'
+import type { SequenceProgress } from '../../types'
+
+describe('instrument sequence helpers', () => {
+  const progress: SequenceProgress = {
+    current_sample: 3,
+    total_samples: 6,
+    elapsed_seconds: 180,
+    sample_durations: [50, 70, 60],
+  }
+
+  it('calculates percent and remaining time from sample durations', () => {
+    expect(sequenceProgressPercent(progress)).toBe(50)
+    expect(estimateSequenceRemainingSeconds(progress)).toBe(180)
+    expect(formatSequenceRemaining(progress)).toBe('~3m left')
+  })
+
+  it('falls back to elapsed average when sample durations are unavailable', () => {
+    expect(estimateSequenceRemainingSeconds({
+      current_sample: 2,
+      total_samples: 5,
+      elapsed_seconds: 120,
+    })).toBe(180)
+  })
+
+  it('uses explicit finish time or builds one from remaining seconds', () => {
+    const now = new Date('2026-05-15T12:00:00.000Z')
+
+    expect(estimateSequenceFinishDate(progress, now)?.toISOString()).toBe('2026-05-15T12:03:00.000Z')
+    expect(estimateSequenceFinishDate({
+      current_sample: 1,
+      total_samples: 2,
+      estimated_finish_time: '2026-05-15T13:00:00.000Z',
+    })?.toISOString()).toBe('2026-05-15T13:00:00.000Z')
+  })
+
+  it('clamps completed or over-complete sequences for display', () => {
+    expect(sequenceProgressPercent({ current_sample: 12, total_samples: 10 })).toBe(100)
+    expect(formatSequenceRemaining({ current_sample: 10, total_samples: 10 })).toBeNull()
+  })
+})

package/src/__tests__/utils/lcms.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest'
+import {
+  basenameFromWindowsPath,
+  extractLcmsCommonPrefix,
+  extractLcmsSampleName,
+  inferLcmsPlateTypeFromWellIds,
+  lcmsWellIdFromPosition,
+  reconstructLcmsPlateCellsFromSequenceItems,
+} from '../../lcms'
+
+describe('lcms utilities', () => {
+  it('extracts common prefixes and sample names from Xcalibur file names', () => {
+    const prefix = extractLcmsCommonPrefix([
+      'Batch_01_NEG_S1_001',
+      'Batch_01_NEG_S2_002',
+      'Batch_01_NEG_QC_003',
+    ])
+
+    expect(prefix).toBe('Batch_01')
+    expect(extractLcmsSampleName('Batch_01_NEG_S1_001', prefix)).toBe('S1')
+  })
+
+  it('infers plate type from well geometry', () => {
+    expect(lcmsWellIdFromPosition('R:A1')).toBe('A1')
+    expect(inferLcmsPlateTypeFromWellIds(['A1', 'F9'])).toBe('54vial')
+    expect(inferLcmsPlateTypeFromWellIds(['A1', 'H12'])).toBe('96well')
+  })
+
+  it('reconstructs plate cells from sequence items while skipping controls', () => {
+    const result = reconstructLcmsPlateCellsFromSequenceItems([
+      {
+        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: 'Unknown',
+        file_name: 'Batch_NEG_S2_002',
+        sample_id: 'R:H12',
+        path: '',
+        instrument_method: 'C:\\Methods\\neg.meth',
+        position: 'R:H12',
+        injection_volume: 5,
+      },
+      {
+        sample_type: 'Blank',
+        file_name: 'Batch_NEG_Blank_003',
+        sample_id: 'R:F9',
+        path: '',
+        instrument_method: 'C:\\Methods\\neg.meth',
+        position: 'R:F9',
+        injection_volume: 5,
+      },
+    ])
+
+    expect(result).toEqual({
+      plateType: '96well',
+      cells: [
+        { row: 'A', column: 1, sample_name: 'S1' },
+        { row: 'H', column: 12, sample_name: 'S2' },
+      ],
+    })
+  })
+
+  it('extracts basenames from Windows and POSIX paths', () => {
+    expect(basenameFromWindowsPath('C:\\Methods\\neg.meth')).toBe('neg.meth')
+    expect(basenameFromWindowsPath('/methods/pos.meth')).toBe('pos.meth')
+  })
+})

package/src/__tests__/utils/permissions.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+import {
+  canAccessAdmin,
+  canAccessByPolicy,
+  canAccessPlugin,
+  getAccessAudience,
+  hasAllPermissions,
+  hasAnyPermission,
+  isAdminUser,
+} from '../../permissions'
+
+describe('permission helpers', () => {
+  const member = {
+    role: 'member',
+    role_obj: {
+      slug: 'member',
+      permissions: ['experiments.view', 'plugins.configure'],
+      plugin_access: ['dose'],
+    },
+  }
+
+  it('treats the admin role as full access', () => {
+    const admin = { role: 'admin' }
+
+    expect(isAdminUser(admin)).toBe(true)
+    expect(getAccessAudience(admin)).toBe('admin')
+    expect(hasAllPermissions(admin, ['platform.configure'])).toBe(true)
+    expect(canAccessAdmin(admin)).toBe(true)
+  })
+
+  it('checks role permissions and plugin access for non-admin users', () => {
+    expect(isAdminUser(member)).toBe(false)
+    expect(getAccessAudience(member)).toBe('user')
+    expect(hasAllPermissions(member, ['experiments.view'])).toBe(true)
+    expect(hasAllPermissions(member, ['platform.configure'])).toBe(false)
+    expect(hasAnyPermission(member, ['platform.configure', 'plugins.configure'])).toBe(true)
+    expect(canAccessAdmin(member)).toBe(true)
+    expect(canAccessPlugin(member, 'dose')).toBe(true)
+    expect(canAccessPlugin(member, 'reports')).toBe(false)
+  })
+
+  it('evaluates access policies consistently', () => {
+    expect(canAccessByPolicy(member, { visibleFor: 'user' })).toBe(true)
+    expect(canAccessByPolicy(member, { visibleFor: 'admin' })).toBe(false)
+    expect(canAccessByPolicy(member, { permissions: ['experiments.view'] })).toBe(true)
+    expect(canAccessByPolicy(member, { anyPermissions: ['platform.configure', 'plugins.configure'] })).toBe(true)
+    expect(canAccessByPolicy(member, { requiresAdmin: true })).toBe(false)
+    expect(canAccessByPolicy(member, { plugin: 'reports' })).toBe(false)
+  })
+})

package/src/__tests__/utils/rack.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest'
+import {
+  createLcmsControlWellEditData,
+  getLcmsDefaultControlWellId,
+  lcmsPlateCellsToRacks,
+  rackToLcmsPlateCells,
+} from '../../utils/rack'
+import type { Rack } from '../../types'
+
+describe('rack LCMS adapters', () => {
+  it('converts LCMS plate cells into rack wells grouped by slot', () => {
+    const racks = lcmsPlateCellsToRacks([
+      {
+        row: 'A',
+        column: 1,
+        sample_name: 'S1',
+        sample_type: 'sample',
+        injection_volume: 7,
+        slot: 'G',
+      },
+      {
+        row: 'H',
+        column: 10,
+        sample_name: 'IQC',
+        sample_type: 'iqc',
+        injection_count: 2,
+        slot: 'R',
+      },
+    ])
+
+    expect(racks.map(rack => rack.slot)).toEqual(['R', 'G'])
+    expect(racks[0]).toMatchObject({
+      id: 'rack-R',
+      format: 96,
+      wells: {
+        H10: {
+          sampleType: 'iqc',
+          metadata: {
+            label: 'IQC',
+            injectionVolume: 5,
+            injectionCount: 2,
+          },
+        },
+      },
+    })
+    expect(racks[1].wells.A1?.metadata).toMatchObject({
+      label: 'S1',
+      injectionVolume: 7,
+    })
+  })
+
+  it('flattens rack wells back to LCMS plate cells with slot metadata', () => {
+    const rack: Rack = {
+      id: 'rack-R',
+      name: 'Rack R',
+      format: 54,
+      slot: 'R',
+      injectionVolume: 5,
+      wells: {
+        A1: {
+          id: 'A1',
+          state: 'filled',
+          sampleType: 'sample',
+          metadata: {
+            label: 'S1',
+            injectionVolume: 7,
+            injectionCount: 3,
+            customMethod: 'C:\\Methods\\custom.meth',
+          },
+        },
+        F7: {
+          id: 'F7',
+          state: 'filled',
+          sampleType: 'iqc',
+          metadata: {
+            label: 'IQC',
+          },
+        },
+      },
+    }
+
+    expect(rackToLcmsPlateCells(rack)).toEqual([
+      {
+        row: 'A',
+        column: 1,
+        sample_name: 'S1',
+        sample_type: 'sample',
+        injection_volume: 7,
+        injection_count: 3,
+        custom_method: 'C:\\Methods\\custom.meth',
+        slot: 'R',
+      },
+      {
+        row: 'F',
+        column: 7,
+        sample_name: 'IQC',
+        sample_type: 'iqc',
+        injection_volume: 5,
+        injection_count: 1,
+        custom_method: null,
+        slot: 'R',
+      },
+    ])
+  })
+
+  it('exposes LCMS default control well edit data', () => {
+    expect(getLcmsDefaultControlWellId('54vial', 'iqc')).toBe('F7')
+    expect(createLcmsControlWellEditData('qc', {
+      plateType: '96well',
+      injectionVolume: 8,
+    })).toEqual({
+      wellId: 'H11',
+      label: 'QC',
+      sampleType: 'qc',
+      injectionVolume: 8,
+      injectionCount: 1,
+      customMethod: '',
+    })
+  })
+})

package/src/components/AppTopBar.vue

@@ -451,6 +451,7 @@ function currentItemIdFromLocation(pages: Array<Pick<PageSelectorItem, 'id' | 't
     :control-options="settingsConfig?.controlOptions"
     :values="settingsConfig?.values"
     :enhancements="settingsConfig?.enhancements"
+    :user-type="settingsConfig?.userType"
     @update:values="emit('settings-values-change', $event)"
   >
     <template v-for="tab in normalizedSettingsTabs" :key="tab.id" #[`tab-${tab.id}`]>

package/src/components/BaseTabs.vue

@@ -21,6 +21,11 @@ const emit = defineEmits<{
 const activeTab = computed(() => props.modelValue)
 const normalizedTabs = computed<TabItem[]>(() => props.tabs.map(normalizeItemInput))
 
+function isSvgIcon(icon: TabItem['icon']): icon is string | string[] {
+  if (!icon) return false
+  return Array.isArray(icon) || icon.trim().startsWith('M') || icon.trim().startsWith('m')
+}
+
 function selectTab(tabId: string) {
   const tab = normalizedTabs.value.find(t => t.id === tabId)
   if (tab && !tab.disabled) {
@@ -46,7 +51,23 @@ function selectTab(tabId: string) {
       @click="selectTab(tab.id)"
     >
       <span class="mint-tab__content">
-        <span v-if="tab.icon" class="mint-tab__icon">{{ tab.icon }}</span>
+        <svg
+          v-if="isSvgIcon(tab.icon)"
+          class="mint-tab__icon mint-tab__icon--svg"
+          viewBox="0 0 24 24"
+          fill="none"
+          stroke="currentColor"
+          stroke-width="2"
+          stroke-linecap="round"
+          stroke-linejoin="round"
+          aria-hidden="true"
+        >
+          <template v-if="Array.isArray(tab.icon)">
+            <path v-for="(d, index) in tab.icon" :key="index" :d="d" />
+          </template>
+          <path v-else :d="tab.icon" />
+        </svg>
+        <span v-else-if="tab.icon" class="mint-tab__icon">{{ tab.icon }}</span>
         {{ tab.label }}
         <span v-if="tab.badge !== undefined" class="mint-tab__badge">
           {{ tab.badge }}