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

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

@@ -0,0 +1,164 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import { nextTick } from 'vue'
+import axios, { type AxiosRequestConfig } from 'axios'
+
+import { useExperimentSelector } from '../../composables/useExperimentSelector'
+import type { ExperimentListResponse, ExperimentSummary } from '../../types'
+
+let fakeResponse: ExperimentListResponse
+let fakeError: Error | null = null
+let recordedUrls: string[] = []
+
+function experiment(id: number, overrides: Partial<ExperimentSummary> = {}): ExperimentSummary {
+  return {
+    id,
+    name: `Experiment ${id}`,
+    status: 'planned',
+    experiment_type: 'screen',
+    created_at: '2026-05-07T08:00:00Z',
+    updated_at: '2026-05-07T08:00:00Z',
+    has_design_data: false,
+    ...overrides,
+  }
+}
+
+describe('useExperimentSelector', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    fakeResponse = {
+      experiments: [experiment(1)],
+      total: 1,
+    }
+    fakeError = null
+    recordedUrls = []
+    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
+    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.useRealTimers()
+    vi.restoreAllMocks()
+  })
+
+  it('fetches experiments, tracks loading, and marks lastLoadedAt', async () => {
+    let resolveGet!: (value: { data: ExperimentListResponse }) => void
+    vi.mocked(axios.Axios.prototype.get).mockImplementationOnce(async function (
+      this: unknown,
+      url: string,
+      _config?: AxiosRequestConfig,
+    ) {
+      recordedUrls.push(url)
+      return new Promise((resolve) => {
+        resolveGet = resolve
+      })
+    })
+
+    const hook = useExperimentSelector({ limit: 25 })
+    expect(hook.isLoading.value).toBe(false)
+    expect(hook.lastLoadedAt.value).toBeNull()
+
+    const promise = hook.fetch()
+    expect(hook.isLoading.value).toBe(true)
+
+    resolveGet({ data: fakeResponse })
+    await promise
+
+    expect(hook.isLoading.value).toBe(false)
+    expect(hook.error.value).toBeNull()
+    expect(hook.experiments.value).toHaveLength(1)
+    expect(hook.total.value).toBe(1)
+    expect(hook.lastLoadedAt.value).toBeInstanceOf(Date)
+    expect(recordedUrls[0]).toContain('/experiments?')
+    expect(recordedUrls[0]).toContain('limit=25')
+    expect(recordedUrls[0]).toContain('skip=0')
+    expect(recordedUrls[0]).toContain('sort_by=created_at')
+  })
+
+  it('loadMore appends the next page', async () => {
+    const hook = useExperimentSelector({ limit: 1 })
+
+    fakeResponse = { experiments: [experiment(1)], total: 2 }
+    await hook.fetch()
+    fakeResponse = { experiments: [experiment(2)], total: 2 }
+    await hook.loadMore()
+
+    expect(hook.experiments.value.map(item => item.id)).toEqual([1, 2])
+    expect(hook.page.value).toBe(1)
+    expect(recordedUrls[1]).toContain('skip=1')
+  })
+
+  it('sets error and clears first page results on failure', async () => {
+    fakeError = new Error('network down')
+    const hook = useExperimentSelector()
+
+    await hook.fetch()
+
+    expect(hook.error.value).toBe('network down')
+    expect(hook.experiments.value).toEqual([])
+    expect(hook.total.value).toBe(0)
+    expect(hook.lastLoadedAt.value).toBeNull()
+  })
+
+  it('clear resets selection, filters, sort, and errors', async () => {
+    const hook = useExperimentSelector()
+    hook.select(experiment(7))
+    hook.filters.search = 'drug'
+    hook.sortKey.value = 'name:asc'
+
+    fakeError = new Error('failed once')
+    await hook.fetch()
+    expect(hook.error.value).toBe('failed once')
+
+    hook.clear()
+
+    expect(hook.selectedExperiment.value).toBeNull()
+    expect(hook.filters.search).toBeUndefined()
+    expect(hook.sortKey.value).toBe('created_at:desc')
+    expect(hook.error.value).toBeNull()
+  })
+
+  it('debounces search filter fetches', async () => {
+    vi.useFakeTimers()
+    const hook = useExperimentSelector()
+    await hook.fetch()
+
+    hook.filters.search = 'glu'
+    await nextTick()
+    hook.filters.search = 'glucose'
+    await nextTick()
+
+    await vi.advanceTimersByTimeAsync(299)
+    expect(recordedUrls).toHaveLength(1)
+
+    await vi.advanceTimersByTimeAsync(1)
+    expect(recordedUrls).toHaveLength(2)
+    expect(recordedUrls[1]).toContain('search=glucose')
+  })
+
+  it('cancels pending search debounce when discrete filters change', async () => {
+    vi.useFakeTimers()
+    const hook = useExperimentSelector()
+    await hook.fetch()
+
+    hook.filters.search = 'pending'
+    await nextTick()
+    hook.filters.status = 'planned'
+    await nextTick()
+    await Promise.resolve()
+
+    expect(recordedUrls).toHaveLength(2)
+    expect(recordedUrls[1]).toContain('status=planned')
+
+    await vi.advanceTimersByTimeAsync(300)
+    expect(recordedUrls).toHaveLength(2)
+  })
+})

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

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi } from 'vitest'
+import { nextTick, reactive } from 'vue'
 
 // Mock vue lifecycle hooks since we're not in a component
 vi.mock('vue', async () => {
@@ -20,6 +21,25 @@ describe('useForm', () => {
       expect(data.email).toBe('')
     })
 
+    it('should unwrap nested reactive initial values before cloning', () => {
+      const initial = reactive({
+        sampleNames: ['Vehicle', 'Drug'],
+        metadata: { groups: ['Control'] },
+      })
+
+      const { data, reset } = useForm(initial)
+
+      expect(data.sampleNames).toEqual(['Vehicle', 'Drug'])
+      expect(data.metadata.groups).toEqual(['Control'])
+
+      data.sampleNames.push('Rescue')
+      data.metadata.groups.push('Treatment')
+      reset()
+
+      expect(data.sampleNames).toEqual(['Vehicle', 'Drug'])
+      expect(data.metadata.groups).toEqual(['Control'])
+    })
+
     it('should start with no errors', () => {
       const { errors } = useForm({ name: '' })
       expect(errors.name).toBeNull()
@@ -173,6 +193,44 @@ describe('useForm', () => {
     })
   })
 
+  describe('replaceState', () => {
+    it('should replace values and clear field state', async () => {
+      const { data, errors, touched, dirty, isDirty, replaceState, setFieldTouched } = useForm<Record<string, unknown>>(
+        { name: 'initial', stale: 'remove' },
+        { name: { required: true } }
+      )
+
+      data.name = ''
+      setFieldTouched('name')
+      expect(errors.name).toBe('This field is required')
+
+      replaceState({ name: 'server', added: 3 })
+      await nextTick()
+
+      expect(data.name).toBe('server')
+      expect(data.stale).toBeUndefined()
+      expect(data.added).toBe(3)
+      expect(errors.name).toBeNull()
+      expect(errors.stale).toBeUndefined()
+      expect(touched.name).toBe(false)
+      expect(dirty.name).toBe(false)
+      expect(isDirty.value).toBe(false)
+    })
+
+    it('should use replaced values as the next reset baseline', () => {
+      const { data, replaceState, reset } = useForm<Record<string, unknown>>({
+        samples: ['Vehicle'],
+      })
+      const loaded = reactive({ samples: ['Drug'] })
+
+      replaceState(loaded)
+      ;(data.samples as string[]).push('Rescue')
+      reset()
+
+      expect(data.samples).toEqual(['Drug'])
+    })
+  })
+
   describe('dirty tracking', () => {
     it('should track dirty state on setFieldValue', () => {
       const { setFieldValue } = useForm({ name: 'original' })

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

@@ -852,6 +852,21 @@ describe('useFormBuilder', () => {
       })
       expect(getFieldOptions('choice')).toEqual(dynamicOptions)
     })
+
+    it('accepts shorthand dynamic options from enhancements', () => {
+      const dynamicOptions = ['linear', 'logistic']
+      const schema = makeSchema([
+        { name: 'choice', label: 'Choice', type: 'select' },
+      ])
+      const { getFieldOptions, getResolvedFieldProps, fields } = useFormBuilder(schema, undefined, {
+        fields: {
+          choice: { options: () => dynamicOptions },
+        },
+      })
+
+      expect(getFieldOptions('choice')).toEqual(dynamicOptions)
+      expect(getResolvedFieldProps(fields[0]).options).toEqual(dynamicOptions)
+    })
   })
 
   // ---------------------------------------------------------------------------
@@ -914,4 +929,66 @@ describe('useFormBuilder', () => {
       expect(form.data.name).toBe('Charlie')
     })
   })
+
+  // ---------------------------------------------------------------------------
+  // updateSchema
+  // ---------------------------------------------------------------------------
+
+  describe('updateSchema', () => {
+    it('rebuilds fields, values, and validation rules for a replacement schema', () => {
+      const initialSchema = makeSchema([
+        { name: 'name', label: 'Name', type: 'text', defaultValue: 'Alice' },
+        { name: 'legacy', label: 'Legacy', type: 'text', defaultValue: 'remove' },
+      ])
+      const nextSchema = makeSchema([
+        {
+          name: 'name',
+          label: 'Name',
+          type: 'text',
+          defaultValue: 'Alice',
+          validation: { required: true },
+        },
+        { name: 'count', label: 'Count', type: 'number', defaultValue: 2, validation: { min: 3 } },
+      ])
+      const builder = useFormBuilder<Record<string, unknown>>(initialSchema)
+
+      builder.form.data.name = 'Edited'
+      builder.form.setFieldTouched('name')
+      builder.updateSchema(nextSchema, { name: 'Loaded', count: 4 })
+
+      expect(builder.fields.map((field) => field.name)).toEqual(['name', 'count'])
+      expect(builder.form.data.name).toBe('Loaded')
+      expect(builder.form.data.count).toBe(4)
+      expect(builder.form.data.legacy).toBeUndefined()
+      expect(builder.form.touched.name).toBe(false)
+      expect(builder.form.errors.name).toBeNull()
+      expect(builder.validate()).toBe(true)
+
+      builder.form.data.count = 1
+      expect(builder.validate()).toBe(false)
+      expect(builder.form.errors.count).toBe('Must be at least 3')
+    })
+
+    it('resets wizard position when the schema changes', () => {
+      const stepSchema: FormSchema = {
+        steps: [
+          { id: 'one', label: 'One', sections: [makeSection([{ name: 'a', label: 'A', type: 'text' }])] },
+          { id: 'two', label: 'Two', sections: [makeSection([{ name: 'b', label: 'B', type: 'text' }])] },
+        ],
+      }
+      const nextSchema = makeSchema([
+        { name: 'name', label: 'Name', type: 'text', defaultValue: 'Alice' },
+      ])
+      const builder = useFormBuilder(stepSchema)
+
+      expect(builder.goNext()).toBe(true)
+      expect(builder.currentStep.value).toBe(1)
+
+      builder.updateSchema(nextSchema)
+
+      expect(builder.currentStep.value).toBe(0)
+      expect(builder.fields.map((field) => field.name)).toEqual(['name'])
+      expect(builder.form.data.name).toBe('Alice')
+    })
+  })
 })

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

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest'
+import { ref } from 'vue'
+import { useGroupAssignment } from '../../composables/useGroupAssignment'
+import type { GroupItem } from '../../types'
+
+const groups: GroupItem[] = [
+  { name: 'control-a', color: '#3B82F6', count: 3 },
+  { name: 'control-b', color: '#06B6D4', count: 2 },
+  { name: 'treatment-a', color: '#F43F5E', count: 4 },
+]
+
+describe('useGroupAssignment', () => {
+  it('derives zone groups, unassigned groups, counts, and validation state', () => {
+    const assignment = useGroupAssignment({
+      groups,
+      group1: ['control-a'],
+      group2: [],
+      label1: 'Control',
+      label2: 'Treatment',
+      minPerGroup: 1,
+    })
+
+    expect(assignment.zone1Groups.value.map(group => group.name)).toEqual(['control-a'])
+    expect(assignment.zone2Groups.value).toEqual([])
+    expect(assignment.unassignedGroups.value.map(group => group.name)).toEqual(['control-b', 'treatment-a'])
+    expect(assignment.zone1Count.value).toBe(3)
+    expect(assignment.zone2Count.value).toBe(0)
+    expect(assignment.isValid.value).toBe(false)
+    expect(assignment.validationMessage.value).toBe('Add 1 more to Treatment')
+  })
+
+  it('moves assignments between zones without mutating the input arrays', () => {
+    const group1 = ['control-a']
+    const group2 = ['treatment-a']
+    const assignment = useGroupAssignment({ groups, group1, group2 })
+
+    expect(assignment.getZoneForGroup('control-a')).toBe('zone1')
+    expect(assignment.assignToZone('control-a', 'zone2')).toEqual({
+      group1: [],
+      group2: ['treatment-a', 'control-a'],
+    })
+    expect(assignment.removeFromZone('treatment-a', 'zone2')).toEqual({
+      group1: ['control-a'],
+      group2: [],
+    })
+    expect(assignment.clearAll()).toEqual({ group1: [], group2: [] })
+    expect(group1).toEqual(['control-a'])
+    expect(group2).toEqual(['treatment-a'])
+  })
+
+  it('updates from reactive sources and normalizes minimum group counts', () => {
+    const group1 = ref<string[]>([])
+    const group2 = ref<string[]>(['treatment-a'])
+    const minPerGroup = ref(2.8)
+    const assignment = useGroupAssignment({
+      groups: () => groups,
+      group1,
+      group2,
+      minPerGroup,
+    })
+
+    expect(assignment.isValid.value).toBe(false)
+    expect(assignment.validationMessage.value).toBe('Add 2 more to Control and 1 more to Treatment')
+
+    group1.value = ['control-a', 'control-b']
+    group2.value = ['treatment-a', 'control-a']
+    minPerGroup.value = 0
+
+    expect(assignment.isValid.value).toBe(true)
+    expect(assignment.validationMessage.value).toBeNull()
+    expect(assignment.unassignedGroups.value).toEqual([])
+  })
+})

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

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest'
+import { computed, ref } from 'vue'
+import { useListSelection } from '../../composables/useListSelection'
+
+describe('useListSelection', () => {
+  it('toggles single values and all configured items', () => {
+    const selected = ref<string[]>(['A'])
+    const selection = useListSelection({
+      selected,
+      items: ['A', 'B', 'C'],
+    })
+
+    expect(selection.isSelected('A')).toBe(true)
+    expect(selection.toggleValue('A')).toEqual([])
+    expect(selection.toggleValue('B')).toEqual(['A', 'B'])
+    expect(selection.isAllSelected.value).toBe(false)
+
+    selected.value = ['A', 'B', 'C']
+    expect(selection.isAllSelected.value).toBe(true)
+    expect(selection.toggleAll()).toEqual([])
+  })
+
+  it('reports full and partial batch selection', () => {
+    const selection = useListSelection({
+      selected: ['A', 'B'],
+    })
+
+    expect(selection.isFullySelected(['A', 'B'])).toBe(true)
+    expect(selection.isPartiallySelected(['A', 'C'])).toBe(true)
+    expect(selection.isPartiallySelected(['C', 'D'])).toBe(false)
+    expect(selection.toggleValues(['A', 'B'])).toEqual([])
+    expect(selection.toggleValues(['B', 'C'])).toEqual(['A', 'B', 'C'])
+  })
+
+  it('uses item value adapters for object lists', () => {
+    const selection = useListSelection({
+      selected: computed(() => [2]),
+      items: [
+        { id: 1, label: 'Control' },
+        { id: 2, label: 'Treatment' },
+      ],
+      getValue: item => item.id,
+    })
+
+    expect(selection.itemValues.value).toEqual([1, 2])
+    expect(selection.isAllSelected.value).toBe(false)
+    expect(selection.selectAll()).toEqual([2, 1])
+  })
+
+  it('respects disabled and max-selection constraints', () => {
+    const disabledSelection = useListSelection({
+      selected: ['A'],
+      disabled: true,
+    })
+    expect(disabledSelection.toggleValue('B')).toEqual(['A'])
+    expect(disabledSelection.clear()).toEqual(['A'])
+
+    const limitedSelection = useListSelection({
+      selected: ['A'],
+      max: 1,
+    })
+    expect(limitedSelection.canAddMore.value).toBe(false)
+    expect(limitedSelection.toggleValue('B')).toEqual(['A'])
+    expect(limitedSelection.toggleValue('A')).toEqual([])
+  })
+})