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

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

@@ -1,407 +0,0 @@
-import { mount } from '@vue/test-utils'
-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 = {}, pinia = createPinia()) {
-    return mount(SettingsModal, {
-      props: {
-        modelValue: true,
-        showAppearance: false,
-        ...props,
-      },
-      slots,
-      global: {
-        plugins: [pinia],
-        stubs: {
-          teleport: true,
-        },
-      },
-    })
-  }
-
-  it('accepts string shorthand manual tabs', async () => {
-    const wrapper = mountSettingsModal({
-      tabs: ['General', 'Advanced'],
-    }, {
-      'tab-General': '<div class="general-tab">General Content</div>',
-      'tab-Advanced': '<div class="advanced-tab">Advanced Content</div>',
-    })
-
-    const tabs = wrapper.findAll('.mint-modal__tab')
-    expect(tabs.map(tab => tab.text())).toEqual(['General', 'Advanced'])
-    expect(tabs[0].classes()).toContain('mint-modal__tab--active')
-    expect(wrapper.find('.general-tab').exists()).toBe(true)
-
-    await tabs[1].trigger('click')
-
-    // Re-query: the teleport stub rebuilds the strip on re-render, so the
-    // pre-click wrappers point at detached nodes.
-    expect(wrapper.findAll('.mint-modal__tab')[1].classes()).toContain('mint-modal__tab--active')
-  })
-
-  it('syncs schema changes without remounting the modal', async () => {
-    const baseSchema: SettingsModalSchema = {
-      groups: [
-        {
-          id: 'general',
-          label: 'General',
-          fields: [
-            { name: 'threshold', label: 'Threshold', type: 'text', defaultValue: '0.1' },
-          ],
-        },
-      ],
-    }
-    const nextSchema: SettingsModalSchema = {
-      groups: [
-        {
-          id: 'general',
-          label: 'General',
-          fields: [
-            { name: 'threshold', label: 'Threshold', type: 'text', defaultValue: '0.1' },
-          ],
-        },
-        {
-          id: 'advanced',
-          label: 'Advanced',
-          fields: [
-            { name: 'method', label: 'Method', type: 'text', defaultValue: 'linear' },
-          ],
-        },
-      ],
-    }
-
-    const wrapper = mountSettingsModal({ schema: baseSchema })
-
-    await wrapper.find('input').setValue('0.5')
-    await wrapper.setProps({ schema: nextSchema })
-
-    const tabs = wrapper.findAll('.mint-modal__tab')
-    expect(tabs.map(tab => tab.text())).toEqual(['General', 'Advanced'])
-    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.5')
-
-    await tabs[1].trigger('click')
-
-    expect(wrapper.text()).toContain('Method')
-    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('linear')
-  })
-
-  it('uses controlled values when a schema changes', async () => {
-    const baseSchema: SettingsModalSchema = {
-      groups: [
-        {
-          id: 'general',
-          label: 'General',
-          fields: [
-            { name: 'threshold', label: 'Threshold', type: 'text', defaultValue: '0.1' },
-          ],
-        },
-      ],
-    }
-    const nextSchema: SettingsModalSchema = {
-      groups: [
-        {
-          id: 'general',
-          label: 'General',
-          fields: [
-            { name: 'threshold', label: 'Threshold', type: 'text', defaultValue: '0.1' },
-            { name: 'method', label: 'Method', type: 'text', defaultValue: 'linear' },
-          ],
-        },
-      ],
-    }
-
-    const wrapper = mountSettingsModal({
-      schema: baseSchema,
-      values: { threshold: '0.25' },
-    })
-
-    await wrapper.find('input').setValue('0.5')
-    await wrapper.setProps({ schema: nextSchema })
-
-    const inputs = wrapper.findAll('input')
-    expect((inputs[0].element as HTMLInputElement).value).toBe('0.25')
-    expect((inputs[1].element as HTMLInputElement).value).toBe('linear')
-    expect(wrapper.emitted('update:values')?.at(-1)?.[0]).toMatchObject({
-      threshold: '0.25',
-      method: 'linear',
-    })
-  })
-
-  it('preserves controlled values that are not represented in the form schema', async () => {
-    const schema: SettingsModalSchema = {
-      groups: [
-        {
-          id: 'general',
-          label: 'General',
-          fields: [
-            { name: 'threshold', label: 'Threshold', type: 'number' },
-          ],
-        },
-      ],
-    }
-    const wrapper = mountSettingsModal({
-      schema,
-      values: {
-        threshold: 0.25,
-        database_url: '**********',
-      },
-    })
-
-    await wrapper.find('input').setValue('0.5')
-
-    expect(wrapper.emitted('update:values')?.at(-1)?.[0]).toEqual({
-      threshold: 0.5,
-      database_url: '**********',
-    })
-  })
-
-  it('renders compact controls as schema-driven settings', async () => {
-    const controls: ControlSchema = {
-      threshold: {
-        label: 'Threshold',
-        default: 0.25,
-        section: 'parameters',
-        sectionLabel: 'Parameters',
-      },
-      method: {
-        label: 'Method',
-        default: 'linear',
-        options: ['linear', 'logistic'],
-        section: 'advanced',
-        sectionLabel: 'Advanced',
-      },
-    }
-
-    const wrapper = mountSettingsModal({ controls })
-
-    const tabs = wrapper.findAll('.mint-modal__tab')
-    expect(tabs.map(tab => tab.text())).toEqual(['Parameters', 'Advanced'])
-    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.25')
-
-    await wrapper.find('input').setValue('0.5')
-    await tabs[1].trigger('click')
-
-    expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('linear')
-    expect(wrapper.emitted('update:values')?.at(-1)?.[0]).toMatchObject({
-      threshold: 0.5,
-      method: 'linear',
-    })
-  })
-
-  it('uses controlOptions initialValues for compact control settings', async () => {
-    const controls: ControlSchema = {
-      threshold: {
-        label: 'Threshold',
-        default: 0.25,
-        section: 'parameters',
-        sectionLabel: 'Parameters',
-      },
-      method: {
-        label: 'Method',
-        default: 'linear',
-        options: ['linear', 'logistic'],
-        section: 'parameters',
-      },
-    }
-
-    const wrapper = mountSettingsModal({
-      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')
-
-    await wrapper.find('input').setValue('0.5')
-
-    expect(wrapper.emitted('update:values')?.at(-1)?.[0]).toMatchObject({
-      threshold: 0.5,
-      method: 'logistic',
-    })
-  })
-
-  it('renders a complete control model as schema-driven settings', async () => {
-    const model = defineControlModel({
-      views: {
-        run: {
-          label: 'Run',
-          sections: {
-            parameters: {
-              label: 'Parameters',
-              controls: {
-                threshold: { label: 'Threshold', default: 0.25 },
-                method: { label: 'Method', default: 'linear', options: ['linear', 'logistic'] },
-              },
-            },
-          },
-        },
-      },
-    })
-
-    const wrapper = mountSettingsModal({ model })
-
-    expect(wrapper.text()).toContain('Threshold')
-    expect(wrapper.text()).toContain('Method')
-    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.25')
-
-    await wrapper.find('input').setValue('0.5')
-
-    expect(wrapper.emitted('update:values')?.at(-1)?.[0]).toMatchObject({
-      threshold: 0.5,
-      method: 'linear',
-    })
-  })
-
-  it('uses initialValues from a complete control model as schema-driven settings', () => {
-    const model = defineControlModel({
-      initialValues: {
-        threshold: 0.75,
-        method: 'logistic',
-      },
-      views: {
-        run: {
-          label: 'Run',
-          sections: {
-            parameters: {
-              label: 'Parameters',
-              controls: {
-                threshold: { label: 'Threshold', default: 0.25 },
-                method: { label: 'Method', default: 'linear', options: ['linear', 'logistic'] },
-              },
-            },
-          },
-        },
-      },
-    })
-
-    const wrapper = mountSettingsModal({
-      model,
-      controlOptions: {
-        initialValues: {
-          method: 'linear',
-        },
-      },
-    })
-
-    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.75')
-    expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('linear')
-  })
-
-  it('activates compact controls that are loaded after mount', async () => {
-    const controls: ControlSchema = {
-      threshold: {
-        label: 'Threshold',
-        default: 0.25,
-        section: 'parameters',
-        sectionLabel: 'Parameters',
-      },
-    }
-
-    const wrapper = mountSettingsModal({
-      tabs: ['General'],
-    }, {
-      'tab-General': '<div class="manual-tab">Manual settings</div>',
-    })
-
-    expect(wrapper.find('.manual-tab').exists()).toBe(true)
-
-    await wrapper.setProps({ controls })
-
-    expect(wrapper.text()).toContain('Threshold')
-    expect(wrapper.find('.manual-tab').exists()).toBe(false)
-    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.25')
-    expect(wrapper.emitted('update:values')?.at(-1)?.[0]).toMatchObject({
-      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-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-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__/components/SmartGroupFieldRecipe.groups.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  appendQcGroup,
-  computeFieldGroups,
-  fieldRecipeSummary,
-  sampleTotalFor,
-  type SmartGroupField,
-  type SmartGroupSampleRecord,
-} from '../../components/SmartGroupFieldRecipe.groups'
-
-const FIELDS: SmartGroupField[] = [
-  { key: 'Condition', role: 'Factor', vals: 'Control, Treatment', rep: false },
-  { key: 'Dose', role: 'Factor', vals: 'Vehicle, Low, High', rep: false },
-  { key: 'Replicate', role: 'Replicate', vals: 'Rep1, Rep2, Rep3', rep: true },
-]
-
-const BASE = [
-  { Condition: 'Control', Dose: 'Vehicle' },
-  { Condition: 'Treatment', Dose: 'Low' },
-  { Condition: 'Treatment', Dose: 'High' },
-]
-const SAMPLES: SmartGroupSampleRecord[] = BASE.flatMap(base =>
-  [1, 2, 3].map(rep => ({ ...base, Replicate: `Rep${rep}` })),
-)
-
-const PALETTE = ['c1', 'c2', 'c3', 'c4', 'c5']
-
-describe('computeFieldGroups', () => {
-  it('should form three groups of three when grouping by Condition and Dose', () => {
-    const groups = computeFieldGroups(SAMPLES, FIELDS, [true, true, false], PALETTE)
-    expect(groups.map(g => g.name)).toEqual(['Control_Vehicle', 'Treatment_Low', 'Treatment_High'])
-    expect(groups.map(g => g.count)).toEqual([3, 3, 3])
-  })
-
-  it('should shatter into nine singleton groups when Replicate is included', () => {
-    const groups = computeFieldGroups(SAMPLES, FIELDS, [true, true, true], PALETTE)
-    expect(groups).toHaveLength(9)
-    expect(groups.every(g => g.count === 1)).toBe(true)
-  })
-
-  it('should return no groups when no field is active', () => {
-    expect(computeFieldGroups(SAMPLES, FIELDS, [false, false, false], PALETTE)).toEqual([])
-  })
-
-  it('should collapse to Condition only when just the first field is active', () => {
-    const groups = computeFieldGroups(SAMPLES, FIELDS, [true, false, false], PALETTE)
-    expect(groups.map(g => g.name)).toEqual(['Control', 'Treatment'])
-    expect(groups.map(g => g.count)).toEqual([3, 6])
-  })
-
-  it('should cycle colours through the palette in group order', () => {
-    const groups = computeFieldGroups(SAMPLES, FIELDS, [true, true, false], PALETTE)
-    expect(groups.map(g => g.color)).toEqual(['c1', 'c2', 'c3'])
-  })
-
-  it('should join field values following an explicit layer order', () => {
-    const groups = computeFieldGroups(SAMPLES, FIELDS, [true, true, false], PALETTE, [1, 0])
-    expect(groups.map(g => g.name)).toEqual(['Vehicle_Control', 'Low_Treatment', 'High_Treatment'])
-  })
-})
-
-describe('appendQcGroup', () => {
-  const base = computeFieldGroups(SAMPLES, FIELDS, [true, true, false], PALETTE)
-
-  it('should append a QC_Pool group of three when QC is mixed into groups', () => {
-    const result = appendQcGroup(base, 'Mix into groups', 'qc')
-    expect(result).toHaveLength(base.length + 1)
-    expect(result.at(-1)).toEqual({ name: 'QC_Pool', count: 3, color: 'qc' })
-  })
-
-  it('should leave groups untouched when QC overlays or is excluded', () => {
-    expect(appendQcGroup(base, 'Overlay only', 'qc')).toEqual(base)
-    expect(appendQcGroup(base, 'Exclude', 'qc')).toEqual(base)
-  })
-})
-
-describe('sampleTotalFor', () => {
-  it('should drop the QC pool only when QC is excluded', () => {
-    expect(sampleTotalFor('Exclude')).toBe(9)
-    expect(sampleTotalFor('Overlay only')).toBe(12)
-    expect(sampleTotalFor('Mix into groups')).toBe(12)
-  })
-})
-
-describe('fieldRecipeSummary', () => {
-  const baseGroups = computeFieldGroups(SAMPLES, FIELDS, [true, true, false], PALETTE)
-
-  it('should be muted when no factor is active', () => {
-    expect(fieldRecipeSummary({ activeFactors: [], repOn: false, baseGroups: [] }).kind).toBe('mute')
-  })
-
-  it('should warn when a replicate field is switched on', () => {
-    expect(fieldRecipeSummary({ activeFactors: ['Replicate'], repOn: true, baseGroups }).kind).toBe('warn')
-  })
-
-  it('should inform when grouping by factors only', () => {
-    expect(
-      fieldRecipeSummary({ activeFactors: ['Condition', 'Dose'], repOn: false, baseGroups }).kind,
-    ).toBe('info')
-  })
-})

package/src/__tests__/components/SmartGroupManual.cohorts.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  assignSamples,
-  buildCohortTree,
-  filterSamples,
-  type ManualSample,
-} from '../../components/SmartGroupManual.cohorts'
-
-/** Mirrors the design prototype's seeded default sample list. */
-function seededSamples(): ManualSample[] {
-  const blank = { group: null, sub: null, sub2: null, color: null } as const
-  const seed: Record<string, Partial<ManualSample>> = {
-    Pt001_TumorA_d7_rep1: { group: 'Responder', sub: 'Day 7', sub2: 'Batch 1', color: 'c-teal' },
-    Pt001_TumorA_d14_rep1: { group: 'Responder', sub: 'Day 14', color: 'c-teal' },
-    Pt002_TumorB_d7_rep1: { group: 'Non-responder', sub: 'Day 7', sub2: 'Batch 2', color: 'c-rose' },
-  }
-  return ['Pt001_TumorA_d7_rep1', 'Pt001_TumorA_d14_rep1', 'Pt002_TumorB_d7_rep1', 'QC_pool_01'].map(
-    name => ({ name, ...blank, ...(seed[name] ?? {}) }),
-  )
-}
-
-describe('buildCohortTree', () => {
-  const tree = buildCohortTree(seededSamples())
-
-  it('should ignore unassigned samples', () => {
-    expect(tree.size).toBe(2)
-    expect(tree.has('Responder')).toBe(true)
-    expect(tree.has('Non-responder')).toBe(true)
-  })
-
-  it('should total Responder across its two subgroups', () => {
-    const responder = tree.get('Responder')!
-    expect(responder.total).toBe(2)
-    expect(responder.subs.get('Day 7')!.total).toBe(1)
-    expect(responder.subs.get('Day 7')!.subs2.get('Batch 1')).toBe(1)
-    expect(responder.subs.get('Day 14')!.total).toBe(1)
-    expect(responder.subs.get('Day 14')!.subs2.get('—')).toBe(1)
-  })
-
-  it('should nest Non-responder under Day 7 / Batch 2', () => {
-    const nonResponder = tree.get('Non-responder')!
-    expect(nonResponder.total).toBe(1)
-    expect(nonResponder.subs.get('Day 7')!.subs2.get('Batch 2')).toBe(1)
-  })
-})
-
-describe('filterSamples', () => {
-  const samples = seededSamples()
-
-  it('should match names case-insensitively on a substring query', () => {
-    const matches = filterSamples(samples, 'tumorb', 'all')
-    expect(matches.map(m => m.sample.name)).toEqual(['Pt002_TumorB_d7_rep1'])
-  })
-
-  it('should preserve the original index for each match', () => {
-    const matches = filterSamples(samples, 'QC', 'all')
-    expect(matches).toEqual([{ sample: samples[3], index: 3 }])
-  })
-
-  it('should show only unassigned samples when filtered to unassigned', () => {
-    const matches = filterSamples(samples, '', 'unassigned')
-    expect(matches.map(m => m.sample.name)).toEqual(['QC_pool_01'])
-  })
-
-  it('should show only assigned samples when filtered to assigned', () => {
-    const matches = filterSamples(samples, '', 'assigned')
-    expect(matches).toHaveLength(3)
-    expect(matches.every(m => !!m.sample.group)).toBe(true)
-  })
-})
-
-describe('assignSamples', () => {
-  const samples = seededSamples()
-
-  it('should assign group and colour to the selected indices only', () => {
-    const next = assignSamples(samples, new Set([3]), {
-      grp: 'Pooled',
-      sub: '',
-      sub2: '',
-      color: 'c-slate',
-    })
-    expect(next[3]).toMatchObject({ group: 'Pooled', color: 'c-slate' })
-    expect(next[0]).toEqual(samples[0])
-  })
-
-  it('should null out blank subgroup and sub-subgroup values', () => {
-    const next = assignSamples(samples, new Set([3]), {
-      grp: '  Pooled  ',
-      sub: '   ',
-      sub2: '',
-      color: 'c-slate',
-    })
-    expect(next[3].group).toBe('Pooled')
-    expect(next[3].sub).toBeNull()
-    expect(next[3].sub2).toBeNull()
-  })
-})

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

@@ -1,75 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import { nextTick } from 'vue'
-import TagsInput from '../../components/TagsInput.vue'
-
-describe('TagsInput', () => {
-  it('caps pasted tags by maxTags', async () => {
-    const wrapper = mount(TagsInput, {
-      props: {
-        modelValue: ['existing'],
-        maxTags: 3,
-      },
-    })
-
-    await wrapper.find('input').trigger('paste', {
-      clipboardData: {
-        getData: () => 'alpha,beta,gamma',
-      },
-    })
-
-    expect(wrapper.emitted('update:modelValue')?.[0]?.[0]).toEqual([
-      'existing',
-      'alpha',
-      'beta',
-    ])
-  })
-
-  it('keeps duplicate filtering while applying paste limits', async () => {
-    const wrapper = mount(TagsInput, {
-      props: {
-        modelValue: ['alpha'],
-        maxTags: 3,
-      },
-    })
-
-    await wrapper.find('input').trigger('paste', {
-      clipboardData: {
-        getData: () => 'alpha,beta,gamma',
-      },
-    })
-
-    expect(wrapper.emitted('update:modelValue')?.[0]?.[0]).toEqual([
-      'alpha',
-      'beta',
-      'gamma',
-    ])
-  })
-
-  it('uses shared dropdown state for autocomplete suggestions', async () => {
-    const wrapper = mount(TagsInput, {
-      props: {
-        modelValue: [],
-        suggestions: ['alpha', 'beta'],
-      },
-      attachTo: document.body,
-    })
-    const input = wrapper.get('input')
-
-    await input.setValue('a')
-    expect(wrapper.find('.mint-tags-input__dropdown').exists()).toBe(true)
-
-    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }))
-    await nextTick()
-    expect(wrapper.find('.mint-tags-input__dropdown').exists()).toBe(false)
-
-    await input.trigger('focus')
-    expect(wrapper.find('.mint-tags-input__dropdown').exists()).toBe(true)
-
-    document.body.dispatchEvent(new MouseEvent('click', { bubbles: true }))
-    await nextTick()
-    expect(wrapper.find('.mint-tags-input__dropdown').exists()).toBe(false)
-
-    wrapper.unmount()
-  })
-})