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

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

@@ -0,0 +1,143 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { mount } from '@vue/test-utils'
+import { createPinia, setActivePinia } from 'pinia'
+import { computed, reactive, ref } from 'vue'
+
+import ExperimentSelectorModal from '../../components/ExperimentSelectorModal.vue'
+import { useExperimentSelector } from '../../composables/useExperimentSelector'
+import { useExperimentStore } from '../../stores/experiment'
+import type { ExperimentSummary } from '../../types'
+
+const fetchExperiments = vi.fn(async () => undefined)
+const fetchFilterOptions = vi.fn(async () => undefined)
+const experiments = ref<ExperimentSummary[]>([])
+
+vi.mock('../../composables/useExperimentSelector', () => ({
+  useExperimentSelector: vi.fn(() => ({
+    experiments,
+    filters: reactive({
+      search: undefined,
+      status: undefined,
+      project: undefined,
+      experimentType: undefined,
+      datePreset: undefined,
+    }),
+    isLoading: ref(false),
+    error: ref(null),
+    sortKey: ref('created_at:desc'),
+    experimentTypes: ref([]),
+    projects: ref([]),
+    groupedByProject: computed(() => []),
+    fetch: fetchExperiments,
+    fetchFilterOptions,
+  })),
+}))
+
+function experiment(overrides: Partial<ExperimentSummary> = {}): ExperimentSummary {
+  return {
+    id: 7,
+    name: 'Hexokinase knockout run',
+    experiment_code: 'EXP-007',
+    status: 'ongoing',
+    experiment_type: 'screen',
+    created_at: '2026-07-01T08:00:00Z',
+    updated_at: '2026-07-01T08:00:00Z',
+    has_design_data: false,
+    ...overrides,
+  }
+}
+
+interface ModalProps {
+  modelValue: boolean
+  allowedExperimentTypes?: string[] | null
+  currentExperimentId?: number | null
+}
+
+function mountModal(props: ModalProps) {
+  return mount(ExperimentSelectorModal, {
+    props,
+    global: {
+      stubs: {
+        BaseModal: {
+          props: ['modelValue', 'title', 'size'],
+          template: '<div><slot /></div>',
+        },
+      },
+    },
+  })
+}
+
+describe('ExperimentSelectorModal', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    experiments.value = []
+    fetchExperiments.mockClear()
+    fetchFilterOptions.mockClear()
+    vi.mocked(useExperimentSelector).mockClear()
+  })
+
+  it('fetches experiments when mounted already open', () => {
+    mountModal({ modelValue: true })
+
+    expect(fetchFilterOptions).toHaveBeenCalledTimes(1)
+    expect(fetchExperiments).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not fetch while mounted closed', () => {
+    mountModal({ modelValue: false })
+
+    expect(fetchFilterOptions).not.toHaveBeenCalled()
+    expect(fetchExperiments).not.toHaveBeenCalled()
+  })
+
+  it('passes allowed experiment types to the selector composable', () => {
+    mountModal({ modelValue: false, allowedExperimentTypes: ['mass_spectrometry'] })
+
+    expect(useExperimentSelector).toHaveBeenCalledWith({
+      experimentType: undefined,
+      allowedExperimentTypes: ['mass_spectrometry'],
+    })
+  })
+
+  it('commits the clicked platform record to the shared store', async () => {
+    const record = experiment()
+    experiments.value = [record]
+    const wrapper = mountModal({ modelValue: true })
+
+    await wrapper.find('.mint-experiment-selector__row').trigger('click')
+
+    const store = useExperimentStore()
+    expect(store.current).toEqual(record)
+    expect(store.currentId).toBe(7)
+  })
+
+  it('does not emit a select event — the store is the single owner', async () => {
+    experiments.value = [experiment()]
+    const wrapper = mountModal({ modelValue: true })
+
+    await wrapper.find('.mint-experiment-selector__row').trigger('click')
+
+    expect(wrapper.emitted('select')).toBeUndefined()
+  })
+
+  it('closes itself after committing a selection', async () => {
+    experiments.value = [experiment()]
+    const wrapper = mountModal({ modelValue: true })
+
+    await wrapper.find('.mint-experiment-selector__row').trigger('click')
+
+    expect(wrapper.emitted('update:modelValue')).toEqual([[false]])
+  })
+
+  it('clears the shared store from the clear-selection footer', async () => {
+    const store = useExperimentStore()
+    store.select(experiment())
+    const wrapper = mountModal({ modelValue: true, currentExperimentId: 7 })
+
+    await wrapper.find('.mint-experiment-selector__clear-btn').trigger('click')
+
+    expect(store.current).toBeNull()
+    expect(store.currentId).toBeNull()
+    expect(wrapper.emitted('update:modelValue')).toEqual([[false]])
+  })
+})

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

@@ -0,0 +1,353 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { nextTick } from 'vue'
+import { describe, expect, it } from 'vitest'
+import FormBuilder from '../../components/FormBuilder.vue'
+import FormActions from '../../components/FormActions.vue'
+import Tooltip from '../../components/Tooltip.vue'
+import { defineControlModel, useControlWorkspace, type ControlSchema } from '../../composables/useControlSchema'
+import type { FormSchema } from '../../types/form-builder'
+
+const controls: ControlSchema = {
+  threshold: {
+    label: 'Threshold',
+    default: 0.05,
+    min: 0,
+    max: 1,
+    section: 'parameters',
+    sectionLabel: 'Parameters',
+  },
+  method: {
+    label: 'Method',
+    default: 'linear',
+    options: ['linear', 'logistic'],
+    section: 'parameters',
+  },
+  notes: {
+    label: 'Notes',
+    placeholder: 'Optional notes',
+    section: 'metadata',
+    sectionLabel: 'Metadata',
+  },
+}
+
+describe('FormBuilder', () => {
+  it('renders compact controls without a prebuilt FormSchema', () => {
+    const wrapper = mount(FormBuilder, {
+      props: { controls },
+    })
+
+    expect(wrapper.find('.mint-form-builder').exists()).toBe(true)
+    expect(wrapper.text()).toContain('Parameters')
+    expect(wrapper.text()).toContain('Metadata')
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.05')
+    expect(wrapper.find('select').exists()).toBe(true)
+  })
+
+  it('merges compact control defaults with incoming model values', async () => {
+    const wrapper = mount(FormBuilder, {
+      props: {
+        controls,
+        modelValue: { threshold: 0.25 },
+      },
+    })
+
+    await wrapper.find('input').setValue('0.5')
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toMatchObject({
+      threshold: 0.5,
+      method: 'linear',
+      notes: '',
+    })
+  })
+
+  it('uses controlOptions initialValues over compact control defaults', () => {
+    const wrapper = mount(FormBuilder, {
+      props: {
+        controls,
+        controlOptions: {
+          initialValues: {
+            threshold: 0.35,
+            method: 'logistic',
+          },
+        },
+      },
+    })
+
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.35')
+    expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('logistic')
+  })
+
+  it('syncs external modelValue changes into rendered fields', async () => {
+    const wrapper = mount(FormBuilder, {
+      props: {
+        controls,
+        modelValue: { threshold: 0.25 },
+      },
+    })
+
+    await wrapper.setProps({ modelValue: { threshold: 0.75, method: 'logistic' } })
+
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.75')
+    expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('logistic')
+  })
+
+  it('syncs compact controls schema changes into rendered fields and submit data', async () => {
+    const thresholdOnly: ControlSchema = {
+      threshold: controls.threshold,
+    }
+
+    const wrapper = mount(FormBuilder, {
+      props: {
+        controls: thresholdOnly,
+      },
+    })
+
+    await wrapper.find('input').setValue('0.5')
+    await wrapper.setProps({
+      controls: {
+        threshold: controls.threshold,
+        method: controls.method,
+      },
+    })
+
+    expect(wrapper.find('select').exists()).toBe(true)
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.5')
+    expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('linear')
+
+    wrapper.findComponent(FormActions).vm.$emit('submit')
+    await flushPromises()
+
+    expect(wrapper.emitted('submit')?.at(-1)?.[0]).toMatchObject({
+      threshold: 0.5,
+      method: 'linear',
+    })
+  })
+
+  it('removes stale field data when compact controls are removed', async () => {
+    const wrapper = mount(FormBuilder, {
+      props: { controls },
+    })
+
+    await wrapper.setProps({
+      controls: {
+        method: controls.method,
+      },
+    })
+
+    expect(wrapper.find('input').exists()).toBe(false)
+    wrapper.findComponent(FormActions).vm.$emit('submit')
+    await flushPromises()
+
+    const submitted = wrapper.emitted('submit')?.at(-1)?.[0] as Record<string, unknown>
+    expect(submitted).toMatchObject({ method: 'linear' })
+    expect(submitted).not.toHaveProperty('threshold')
+  })
+
+  it('renders fields from a complete control model binding', async () => {
+    const model = defineControlModel({
+      views: {
+        run: {
+          label: 'Run',
+          sections: {
+            parameters: {
+              label: 'Parameters',
+              controls: {
+                threshold: { label: 'Threshold', default: 0.05, min: 0, max: 1 },
+                method: { label: 'Method', default: 'linear', options: ['linear', 'logistic'] },
+              },
+            },
+          },
+        },
+      },
+    })
+    const wrapper = mount(FormBuilder, {
+      props: {
+        model,
+        modelValue: { threshold: 0.25 },
+      },
+    })
+
+    expect(wrapper.text()).toContain('Parameters')
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.25')
+    expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('linear')
+
+    await wrapper.find('input').setValue('0.5')
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toMatchObject({
+      threshold: 0.5,
+      method: 'linear',
+    })
+  })
+
+  it('uses initialValues from a complete control model binding', () => {
+    const model = defineControlModel({
+      initialValues: {
+        threshold: 0.25,
+        method: 'logistic',
+      },
+      views: {
+        run: {
+          label: 'Run',
+          sections: {
+            parameters: {
+              label: 'Parameters',
+              controls: {
+                threshold: { label: 'Threshold', default: 0.05, min: 0, max: 1 },
+                method: { label: 'Method', default: 'linear', options: ['linear', 'logistic'] },
+              },
+            },
+          },
+        },
+      },
+    })
+    const wrapper = mount(FormBuilder, {
+      props: {
+        model,
+        controlOptions: {
+          initialValues: {
+            method: 'linear',
+          },
+        },
+      },
+    })
+
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.25')
+    expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('linear')
+  })
+
+  it('ignores external modelValue keys that are not part of the form schema', async () => {
+    const wrapper = mount(FormBuilder, {
+      props: {
+        controls,
+        modelValue: { threshold: 0.25, externalContext: 'experiment-1' },
+      },
+    })
+
+    await wrapper.find('input').setValue('0.5')
+    await wrapper.setProps({
+      modelValue: { threshold: 0.5, method: 'linear', externalContext: 'experiment-2' },
+    })
+
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.5')
+    expect((wrapper.findComponent(FormBuilder).vm as unknown as { form: { dirty: Record<string, boolean> } }).form.dirty.threshold).toBe(true)
+  })
+
+  it('works with direct useControlWorkspace form bindings', async () => {
+    const workspace = useControlWorkspace({
+      threshold: 0.05,
+      method: ['linear', 'logistic'],
+    })
+    const wrapper = mount(FormBuilder, {
+      props: workspace.form,
+    })
+
+    await wrapper.find('input').setValue('0.5')
+    expect(workspace.values.threshold).toBe(0.5)
+
+    workspace.setValues({ method: 'logistic' })
+    await nextTick()
+    expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('logistic')
+  })
+
+  it('uses explicit schema when both schema and controls are provided', () => {
+    const schema: FormSchema = {
+      sections: [
+        {
+          id: 'explicit',
+          title: 'Explicit Schema',
+          fields: [
+            {
+              name: 'explicitField',
+              label: 'Explicit Field',
+              type: 'text',
+              defaultValue: 'from schema',
+            },
+          ],
+        },
+      ],
+    }
+
+    const wrapper = mount(FormBuilder, {
+      props: { controls, schema },
+    })
+
+    expect(wrapper.text()).toContain('Explicit Schema')
+    expect(wrapper.text()).not.toContain('Parameters')
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('from schema')
+  })
+
+  it('can hide the default actions for embedded forms', () => {
+    const wrapper = mount(FormBuilder, {
+      props: {
+        controls,
+        showActions: false,
+      },
+    })
+
+    expect(wrapper.find('.mint-form-actions').exists()).toBe(false)
+  })
+
+  it('renders boolean fields as compact choice rows', async () => {
+    const schema: FormSchema = {
+      sections: [
+        {
+          id: 'display',
+          title: 'Display',
+          fields: [
+            {
+              name: 'showOutliers',
+              label: 'Show outliers',
+              type: 'toggle',
+              defaultValue: true,
+              hint: 'Keep flagged peaks visible',
+              icon: ['M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z'],
+            },
+            {
+              name: 'includeMetadata',
+              label: 'Include metadata',
+              type: 'checkbox',
+              defaultValue: false,
+              hint: 'Add method context',
+              icon: ['M12 3c4.418 0 8 1.343 8 3s-3.582 3-8 3-8-1.343-8-3z'],
+            },
+          ],
+        },
+      ],
+    }
+
+    const wrapper = mount(FormBuilder, {
+      props: { schema, showActions: false },
+    })
+
+    const toggle = wrapper.get('.mint-toggle--row')
+    const checkbox = wrapper.get('.mint-checkbox--row')
+
+    expect(toggle.text()).toContain('Show outliers')
+    expect(toggle.text()).not.toContain('Keep flagged peaks visible')
+    expect(toggle.find('.mint-toggle__row-svg').exists()).toBe(true)
+    expect(wrapper.findAll('.mint-form-field__label')).toHaveLength(0)
+
+    expect(checkbox.text()).toContain('Include metadata')
+    expect(checkbox.text()).not.toContain('Add method context')
+    expect(checkbox.find('.mint-checkbox__row-svg').exists()).toBe(true)
+    expect(wrapper.findAllComponents(Tooltip).map(tooltip => tooltip.props('text'))).toEqual([
+      'Keep flagged peaks visible',
+      'Add method context',
+    ])
+
+    await toggle.trigger('click')
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toMatchObject({
+      showOutliers: false,
+      includeMetadata: false,
+    })
+  })
+
+  it('renders default actions by default', () => {
+    const wrapper = mount(FormBuilder, {
+      props: { controls },
+    })
+
+    expect(wrapper.find('.mint-form-actions').exists()).toBe(true)
+  })
+})

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

@@ -0,0 +1,132 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { createPinia } from 'pinia'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import ArtifactSelectorModal from '../../components/ArtifactSelectorModal.vue'
+import FileUploader from '../../components/FileUploader.vue'
+import GeneratedPathInput from '../../components/GeneratedPathInput.vue'
+import type { AnalysisArtifactDetail } from '../../types/analysisArtifactTypes'
+
+describe('GeneratedPathInput', () => {
+  beforeEach(() => {
+    Object.assign(window, {
+      __MINT_PLATFORM__: {
+        isIntegrated: true,
+        platformApiUrl: '/api',
+        theme: 'system',
+        currentExperimentId: 42,
+      },
+    })
+  })
+
+  afterEach(() => {
+    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
+    vi.unstubAllGlobals()
+  })
+
+  it('should preserve selected directory paths for SDK staging', async () => {
+    const wrapper = mount(GeneratedPathInput, {
+      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+    })
+    const files = [new File(['a'], 'a.txt'), new File(['b'], 'b.txt')]
+
+    await wrapper.findComponent(FileUploader).vm.$emit(
+      'upload',
+      files,
+      'dataset',
+      ['dataset/a.txt', 'dataset/sub/b.txt'],
+    )
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toEqual({
+      kind: 'path',
+      files,
+      rootName: 'dataset',
+      relativePaths: ['dataset/a.txt', 'dataset/sub/b.txt'],
+    })
+  })
+
+  it('should emit one path selection per file when multiple paths are requested', async () => {
+    const wrapper = mount(GeneratedPathInput, {
+      props: { multiple: true },
+      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+    })
+    const files = [new File(['a'], 'a.txt'), new File(['b'], 'b.txt')]
+
+    await wrapper.findComponent(FileUploader).vm.$emit(
+      'upload',
+      files,
+      undefined,
+      ['a.txt', 'b.txt'],
+    )
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toEqual([
+      { kind: 'path', files: [files[0]], relativePaths: ['a.txt'] },
+      { kind: 'path', files: [files[1]], relativePaths: ['b.txt'] },
+    ])
+  })
+
+  it('should remove a file from the submitted value when the uploader removes it', async () => {
+    const wrapper = mount(GeneratedPathInput, {
+      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+    })
+    const uploader = wrapper.findComponent(FileUploader)
+    const file = new File(['a'], 'a.txt')
+
+    const input = uploader.get('input[type="file"]')
+    Object.defineProperty(input.element, 'files', { value: [file] })
+    await input.trigger('change')
+    await wrapper.setProps({
+      modelValue: { kind: 'path', files: [file], relativePaths: ['a.txt'] },
+    })
+    await wrapper.get('button[aria-label="Remove a.txt"]').trigger('click')
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toBeNull()
+  })
+
+  it('should download a selected platform file artifact for staging', async () => {
+    const fetcher = vi.fn().mockResolvedValue(new Response('artifact-data', {
+      headers: { 'Content-Type': 'text/csv' },
+    }))
+    vi.stubGlobal('fetch', fetcher)
+    const wrapper = mount(GeneratedPathInput, {
+      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+    })
+    const detail = {
+      id: 7,
+      experiment_id: 42,
+      plugin_id: 'leaf',
+      artifact_key: 'matrix',
+      display_name: 'Matrix',
+      status: 'active',
+      result_keys: ['file'],
+      tree: [],
+      summary: null,
+      result: {
+        schema_version: 'mint.analysis_file.v1',
+        filename: 'matrix.csv',
+        file: {
+          key: 'analysis-artifacts/matrix/v1/matrix.csv',
+          plugin_id: 'leaf',
+          experiment_id: 42,
+        },
+      },
+    } satisfies AnalysisArtifactDetail
+
+    wrapper.findComponent(ArtifactSelectorModal).vm.$emit('selectDetail', detail)
+    await flushPromises()
+
+    const selection = wrapper.emitted('update:modelValue')?.at(-1)?.[0] as {
+      files: File[]
+      relativePaths: string[]
+    }
+    expect({
+      url: fetcher.mock.calls[0]?.[0],
+      filename: selection.files[0]?.name,
+      relativePaths: selection.relativePaths,
+    }).toEqual({
+      url: '/api/experiments/42/objects/analysis-artifacts/matrix/v1/matrix.csv?plugin_id=leaf&format=raw',
+      filename: 'matrix.csv',
+      relativePaths: ['matrix.csv'],
+    })
+  })
+})