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

package/src/__tests__/types/GeneratedJsonSchema.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { GeneratedJsonSchema } from '../../types/generated-ui'
-
-describe('GeneratedJsonSchema', () => {
-  it('should accept minimum array size constraints emitted by Pydantic', () => {
-    const schema: GeneratedJsonSchema = { minItems: 1 }
-
-    expect(schema.minItems).toBe(1)
-  })
-
-  it('should accept array size constraints emitted by Pydantic', () => {
-    const schema: GeneratedJsonSchema = { maxItems: 100 }
-
-    expect(schema.maxItems).toBe(100)
-  })
-
-  it('should accept write-only fields emitted by Pydantic', () => {
-    const schema: GeneratedJsonSchema = { writeOnly: true }
-
-    expect(schema.writeOnly).toBe(true)
-  })
-
-  it('should accept tuple item schemas emitted by Pydantic', () => {
-    const schema: GeneratedJsonSchema = {
-      prefixItems: [{ type: 'string' }, { type: 'number' }],
-    }
-
-    expect(schema.prefixItems).toHaveLength(2)
-  })
-
-  it('should accept exclusive numeric bounds emitted by Pydantic', () => {
-    const schema: GeneratedJsonSchema = { exclusiveMinimum: 0 }
-
-    expect(schema.exclusiveMinimum).toBe(0)
-  })
-
-  it('should accept string patterns emitted by Pydantic', () => {
-    const schema: GeneratedJsonSchema = { pattern: '^[0-9a-f]{64}$' }
-
-    expect(schema.pattern).toBe('^[0-9a-f]{64}$')
-  })
-
-  it('should accept discriminators emitted for Pydantic unions', () => {
-    const schema: GeneratedJsonSchema = {
-      discriminator: {
-        propertyName: 'kind',
-        mapping: { targeted: '#/$defs/TargetedResult' },
-      },
-    }
-
-    expect(schema.discriminator?.propertyName).toBe('kind')
-  })
-
-  it('should accept exclusive union branches emitted by Pydantic', () => {
-    const schema: GeneratedJsonSchema = {
-      oneOf: [{ $ref: '#/$defs/TargetedResult' }],
-    }
-
-    expect(schema.oneOf).toHaveLength(1)
-  })
-})

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

@@ -1,96 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { hexToHsl, hslToHex, deriveShade } from '../../utils/color'
-
-describe('hexToHsl', () => {
-  it('parses 6-digit hex', () => {
-    const hsl = hexToHsl('#3B82F6')
-    expect(hsl.h).toBeGreaterThan(200)
-    expect(hsl.h).toBeLessThan(230)
-    expect(hsl.s).toBeGreaterThan(80)
-    expect(hsl.l).toBeGreaterThan(45)
-    expect(hsl.l).toBeLessThan(65)
-  })
-
-  it('parses 3-digit hex', () => {
-    const a = hexToHsl('#39F')
-    const b = hexToHsl('#3399FF')
-    expect(Math.abs(a.h - b.h)).toBeLessThan(1)
-    expect(Math.abs(a.s - b.s)).toBeLessThan(1)
-    expect(Math.abs(a.l - b.l)).toBeLessThan(1)
-  })
-
-  it('handles missing # prefix', () => {
-    const a = hexToHsl('3B82F6')
-    const b = hexToHsl('#3B82F6')
-    expect(a).toEqual(b)
-  })
-
-  it('returns neutral gray for invalid input', () => {
-    const hsl = hexToHsl('not-a-hex')
-    expect(hsl.h).toBe(0)
-    expect(hsl.s).toBe(0)
-    expect(hsl.l).toBe(50)
-  })
-})
-
-describe('hslToHex round-trip', () => {
-  it('round-trips common colors within 1% lightness and 1° hue', () => {
-    const samples = ['#3B82F6', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6']
-    for (const hex of samples) {
-      const hsl = hexToHsl(hex)
-      const back = hexToHsl(hslToHex(hsl.h, hsl.s, hsl.l))
-      expect(Math.abs(back.l - hsl.l)).toBeLessThan(1)
-      // Shortest angular distance between input and output hue
-      const dh = Math.abs(((back.h - hsl.h + 540) % 360) - 180)
-      const hueDelta = Math.min(dh, 360 - dh)
-      expect(hueDelta).toBeLessThan(1)
-    }
-  })
-})
-
-describe('deriveShade', () => {
-  it('returns the parent unchanged when total <= 1', () => {
-    expect(deriveShade('#3B82F6', 0, 1)).toBe('#3B82F6')
-    expect(deriveShade('#10B981', 0, 0)).toBe('#10B981')
-  })
-
-  it('produces children that share the parent hue', () => {
-    const parent = '#3B82F6'
-    const parentH = hexToHsl(parent).h
-
-    const shades = [0, 1, 2, 3].map(i => deriveShade(parent, i, 4))
-    for (const child of shades) {
-      const ch = hexToHsl(child).h
-      expect(Math.abs(ch - parentH)).toBeLessThan(2) // hue locked
-    }
-  })
-
-  it('produces a monotonically darkening progression', () => {
-    const shades = [0, 1, 2, 3, 4].map(i => deriveShade('#3B82F6', i, 5))
-    const lightnesses = shades.map(s => hexToHsl(s).l)
-    for (let i = 1; i < lightnesses.length; i++) {
-      expect(lightnesses[i]).toBeLessThan(lightnesses[i - 1])
-    }
-  })
-
-  it('clamps lightness within readable [35, 75] band', () => {
-    const lightParent = '#FFFFFF'
-    const darkParent = '#000000'
-    for (const parent of [lightParent, darkParent]) {
-      for (let i = 0; i < 4; i++) {
-        const child = deriveShade(parent, i, 4)
-        const { l } = hexToHsl(child)
-        expect(l).toBeGreaterThanOrEqual(34)
-        expect(l).toBeLessThanOrEqual(76)
-      }
-    }
-  })
-
-  it('keeps minimum saturation so colors do not turn grey', () => {
-    const shades = [0, 1, 2].map(i => deriveShade('#3B82F6', i, 3))
-    for (const c of shades) {
-      const { s } = hexToHsl(c)
-      expect(s).toBeGreaterThanOrEqual(35)
-    }
-  })
-})

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

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

@@ -1,95 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-  normalizeJobPercent,
-  normalizeJobState,
-  resolveJobCapabilities,
-} from '../../jobs'
-import type { JobStateInput, JobStatus } from '../../types/jobs'
-
-const legacyCapabilities: Record<JobStatus, [boolean, boolean]> = {
-  awaiting_input: [false, false],
-  queued: [true, false],
-  running: [true, false],
-  completed: [false, true],
-  failed: [false, true],
-  cancelled: [false, true],
-}
-
-function job(status: JobStatus): JobStateInput {
-  return {
-    id: status,
-    job_id: status,
-    kind: 'analysis',
-    name: status,
-    status,
-    progress: {
-      current_file: 0,
-      total_files: 0,
-      current_filename: null,
-      percent: 0,
-      message: '',
-      stage: status,
-    },
-    queue_position: 0,
-    warnings: [],
-    error: null,
-    output_path: null,
-    save_path: null,
-    session_id: null,
-    folders: [],
-    folder_path: null,
-    user_id: '1',
-    owner_user_id: '1',
-    experiment_id: null,
-    extraction_result_id: null,
-    metadata: {},
-    created_at: '2026-07-14T10:00:00+00:00',
-    started_at: null,
-    completed_at: null,
-  }
-}
-
-describe('job capability normalization', () => {
-  it.each(Object.entries(legacyCapabilities))(
-    'infers legacy capabilities for %s',
-    (status, expected) => {
-      const capabilities = resolveJobCapabilities({ status: status as JobStatus })
-
-      expect([capabilities.can_cancel, capabilities.can_delete]).toEqual(expected)
-    },
-  )
-
-  it('keeps explicit capabilities authoritative', () => {
-    const capabilities = resolveJobCapabilities({
-      status: 'running',
-      can_cancel: false,
-      can_delete: true,
-    })
-
-    expect(capabilities).toEqual({ can_cancel: false, can_delete: true })
-  })
-
-  it('fails closed for an unknown legacy status', () => {
-    const capabilities = resolveJobCapabilities({ status: 'custom-status' })
-
-    expect(capabilities).toEqual({ can_cancel: false, can_delete: false })
-  })
-
-  it('normalizes without mutating the transport input', () => {
-    const input = job('awaiting_input')
-
-    normalizeJobState(input)
-
-    expect('can_cancel' in input).toBe(false)
-  })
-
-  it.each([
-    [Number.NaN, 0],
-    [Number.POSITIVE_INFINITY, 0],
-    [-1, 0],
-    [101, 100],
-  ])('clamps unsafe progress value %s', (value, expected) => {
-    expect(normalizeJobPercent(value)).toBe(expected)
-  })
-})

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

@@ -1,73 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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('allows notice publishers to enter the admin panel', () => {
-    const publisher = {
-      role: 'notice-publisher',
-      role_obj: {
-        slug: 'notice-publisher',
-        permissions: ['notices.publish'],
-      },
-    }
-
-    expect(canAccessAdmin(publisher)).toBe(true)
-  })
-
-  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

@@ -1,120 +0,0 @@
-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/ActionMenu.story.vue

@@ -1,26 +0,0 @@
-<script setup lang="ts">
-import ActionMenu from './ActionMenu.vue'
-import type { ActionMenuItem } from '../types'
-
-const items: ActionMenuItem[] = [
-  { id: 'edit', label: 'Edit' },
-  { id: 'docs', label: 'Documentation ↗', href: 'https://example.com/docs', target: '_blank' },
-  { id: 'delete', label: 'Delete', danger: true },
-]
-</script>
-
-<template>
-  <Story title="Action/ActionMenu">
-    <Variant title="Default">
-      <div style="min-height: 14rem; display: flex; justify-content: center; padding: 2rem;">
-        <ActionMenu label="More actions" :items="items" />
-      </div>
-    </Variant>
-
-    <Variant title="Disabled">
-      <div style="display: flex; justify-content: center; padding: 2rem;">
-        <ActionMenu label="More actions" :items="items" disabled />
-      </div>
-    </Variant>
-  </Story>
-</template>