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

package/src/__tests__/composables/autoGroup/tokenLength.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { splitByTokenLength } from '../../../composables/autoGroup/tokenLength'
-import type { SampleClass } from '../../../types/auto-group'
-
-function cls(partial: Partial<SampleClass> & Pick<SampleClass, 'members'>): SampleClass {
-  return {
-    kind: 'biological',
-    label: 'Biological / Plasma',
-    subKind: 'Plasma',
-    classTagPositions: [],
-    disposition: 'group',
-    ...partial,
-  }
-}
-
-describe('splitByTokenLength', () => {
-  it('should split a ragged class into one class per token-length, preserving member order', () => {
-    const tokenized = [
-      ['a', 'b', 'c', '01'], // len 4
-      ['a', 'b', 'c', '02'], // len 4
-      ['a', 'b', 'c', 'd', '03'], // len 5
-    ]
-    const out = splitByTokenLength([cls({ members: [0, 1, 2] })], tokenized)
-
-    expect(out).toHaveLength(2)
-    const four = out.find(c => c.tokenLength === 4)
-    const five = out.find(c => c.tokenLength === 5)
-    expect(four?.members).toEqual([0, 1])
-    expect(five?.members).toEqual([2])
-  })
-
-  it('should disambiguate the label with the field count only when a class spans multiple lengths', () => {
-    const tokenized = [
-      ['a', 'b', 'c', '01'],
-      ['a', 'b', 'c', 'd', '02'],
-    ]
-    const out = splitByTokenLength([cls({ members: [0, 1] })], tokenized)
-
-    const labels = out.map(c => c.label).sort()
-    expect(labels).toEqual([
-      'Biological / Plasma · 4 fields',
-      'Biological / Plasma · 5 fields',
-    ])
-  })
-
-  it('should leave the label unchanged but still set tokenLength when a class has a single length', () => {
-    const tokenized = [
-      ['a', 'b', 'c'],
-      ['a', 'b', 'c'],
-    ]
-    const out = splitByTokenLength([cls({ members: [0, 1] })], tokenized)
-
-    expect(out).toHaveLength(1)
-    expect(out[0].label).toBe('Biological / Plasma')
-    expect(out[0].tokenLength).toBe(3)
-  })
-
-  it('should clamp classTagPositions to the split token-length', () => {
-    const tokenized = [
-      ['a', 'b', 'c'], // len 3
-      ['a', 'b', 'c', 'd', 'e'], // len 5
-    ]
-    const out = splitByTokenLength(
-      [cls({ members: [0, 1], classTagPositions: [1, 4] })],
-      tokenized,
-    )
-
-    const short = out.find(c => c.tokenLength === 3)
-    const long = out.find(c => c.tokenLength === 5)
-    expect(short?.classTagPositions).toEqual([1])
-    expect(long?.classTagPositions).toEqual([1, 4])
-  })
-
-  it('should keep distinct input classes separate and ordered', () => {
-    const tokenized = [
-      ['x', '01'], // class A, len 2
-      ['y', 'z', '02'], // class B, len 3
-    ]
-    const a = cls({ kind: 'unknown', subKind: undefined, label: 'Unknown', members: [0] })
-    const b = cls({ members: [1] })
-    const out = splitByTokenLength([a, b], tokenized)
-
-    expect(out.map(c => c.label)).toEqual(['Unknown', 'Biological / Plasma'])
-  })
-})

package/src/__tests__/composables/autoGroup/tokenize.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { splitMulti, pickPrimaryDelimiter } from '../../../composables/autoGroup/tokenize'
-
-describe('pickPrimaryDelimiter', () => {
-  it('should pick underscore when underscore field counts are most consistent', () => {
-    const lines = ['a_b_c', 'd_e_f', 'g_h_i']
-    expect(pickPrimaryDelimiter(lines)).toBe('_')
-  })
-
-  it('should pick hyphen when underscore is absent but hyphen is consistent', () => {
-    const lines = ['a-b-c', 'd-e-f']
-    expect(pickPrimaryDelimiter(lines)).toBe('-')
-  })
-
-  it('should fall back to underscore when no delimiter splits anything', () => {
-    const lines = ['abc', 'def']
-    expect(pickPrimaryDelimiter(lines)).toBe('_')
-  })
-})
-
-describe('splitMulti', () => {
-  it('should split a single sample on the primary delimiter', () => {
-    expect(splitMulti('a_b_c', '_')).toEqual(['a', 'b', 'c'])
-  })
-
-  it('should not re-split on secondary delimiters', () => {
-    expect(splitMulti('a-b_c-d', '_')).toEqual(['a-b', 'c-d'])
-  })
-
-  it('should handle empty string as a single empty token', () => {
-    expect(splitMulti('', '_')).toEqual([''])
-  })
-})

package/src/__tests__/composables/experiment-utils.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-  experimentIdFromRoute,
-  formatExperimentStatus,
-  getExperimentStatusVariant,
-  resolveExperimentCode,
-} from '../../composables/experiment-utils'
-
-describe('experiment-utils', () => {
-  it('formats canonical and custom experiment statuses', () => {
-    expect(formatExperimentStatus('planned')).toBe('Planned')
-    expect(formatExperimentStatus('ongoing')).toBe('Ongoing')
-    expect(formatExperimentStatus('ready_to_extract')).toBe('Ready to extract')
-    expect(formatExperimentStatus('qc-hold')).toBe('Qc hold')
-    expect(formatExperimentStatus(null)).toBe('')
-  })
-
-  it('maps known status variants and falls back for custom statuses', () => {
-    expect(getExperimentStatusVariant('ongoing')).toBe('primary')
-    expect(getExperimentStatusVariant('completed')).toBe('success')
-    expect(getExperimentStatusVariant('ready_to_extract')).toBe('default')
-    expect(getExperimentStatusVariant(undefined)).toBe('default')
-  })
-
-  it('resolves only formal experiment codes', () => {
-    expect(resolveExperimentCode({ id: 42, experiment_code: 'DR-042' })).toBe('DR-042')
-    expect(resolveExperimentCode({ id: 42 })).toBeUndefined()
-    expect(resolveExperimentCode({ id: null })).toBeUndefined()
-  })
-})
-
-describe('experimentIdFromRoute', () => {
-  it('should read the id from the snake_case query key', () => {
-    expect(experimentIdFromRoute({ experiment_id: '42' })).toBe(42)
-  })
-
-  it('should read the id from the camelCase query key', () => {
-    expect(experimentIdFromRoute({ experimentId: '42' })).toBe(42)
-  })
-
-  // vue-router types repeated query params as (string | null)[], so a helper
-  // declared over string[] rejects the very type every caller passes it.
-  it('should read the id from a repeated query param containing nulls', () => {
-    expect(experimentIdFromRoute({ experiment_id: [null, '42'] })).toBe(42)
-  })
-
-  it('should return null when the query carries no experiment id', () => {
-    expect(experimentIdFromRoute({ other: 'value' })).toBeNull()
-  })
-
-  it('should return null for a non-numeric id', () => {
-    expect(experimentIdFromRoute({ experiment_id: 'abc' })).toBeNull()
-  })
-
-  it('should return null for a non-positive id', () => {
-    expect(experimentIdFromRoute({ experiment_id: '0' })).toBeNull()
-  })
-
-  it('should return null for a fractional id', () => {
-    expect(experimentIdFromRoute({ experiment_id: '4.2' })).toBeNull()
-  })
-})

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

@@ -1,191 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { getFieldRegistryEntry, getTypeDefault } from '../../composables/formBuilderRegistry'
-import type { FormFieldType } from '../../types/form-builder'
-
-describe('formBuilderRegistry', () => {
-  describe('getFieldRegistryEntry', () => {
-    it('should return an entry for every supported field type', () => {
-      const types: FormFieldType[] = [
-        'text', 'email', 'password', 'tel', 'url', 'search',
-        'number', 'textarea', 'select', 'multiselect',
-        'checkbox', 'toggle', 'radio', 'slider', 'tags',
-        'date', 'time', 'datetime', 'file', 'path',
-        'formula', 'sequence', 'molecule', 'concentration', 'unit',
-      ]
-
-      for (const type of types) {
-        const entry = getFieldRegistryEntry(type)
-        expect(entry, `missing registry entry for type "${type}"`).toBeDefined()
-        expect(entry.component).toBeDefined()
-        expect(typeof entry.vModel).toBe('boolean')
-        expect(typeof entry.defaults).toBe('object')
-      }
-    })
-
-    it('should return correct component for text type', () => {
-      const entry = getFieldRegistryEntry('text')
-      expect(entry.vModel).toBe(true)
-      expect(entry.defaults).toEqual({ type: 'text' })
-    })
-
-    it('should return correct defaults for email type', () => {
-      const entry = getFieldRegistryEntry('email')
-      expect(entry.defaults).toEqual({ type: 'email' })
-      expect(entry.vModel).toBe(true)
-    })
-
-    it('should return correct defaults for password type', () => {
-      const entry = getFieldRegistryEntry('password')
-      expect(entry.defaults).toEqual({ type: 'password' })
-    })
-
-    it('should return correct defaults for tel type', () => {
-      const entry = getFieldRegistryEntry('tel')
-      expect(entry.defaults).toEqual({ type: 'tel' })
-    })
-
-    it('should return correct defaults for url type', () => {
-      const entry = getFieldRegistryEntry('url')
-      expect(entry.defaults).toEqual({ type: 'url' })
-    })
-
-    it('should return correct defaults for search type', () => {
-      const entry = getFieldRegistryEntry('search')
-      expect(entry.defaults).toEqual({ type: 'search' })
-    })
-
-    it('should have vModel false for file type', () => {
-      const entry = getFieldRegistryEntry('file')
-      expect(entry.vModel).toBe(false)
-    })
-
-    it('should bind generated path inputs with v-model', () => {
-      expect(getFieldRegistryEntry('path').vModel).toBe(true)
-    })
-
-    it('should have vModel true for all non-file types', () => {
-      const vModelTypes: FormFieldType[] = [
-        'text', 'email', 'password', 'tel', 'url', 'search',
-        'number', 'textarea', 'select', 'multiselect',
-        'checkbox', 'toggle', 'radio', 'slider', 'tags',
-        'date', 'time', 'datetime',
-        'formula', 'sequence', 'molecule', 'concentration', 'unit',
-      ]
-
-      for (const type of vModelTypes) {
-        const entry = getFieldRegistryEntry(type)
-        expect(entry.vModel, `vModel should be true for "${type}"`).toBe(true)
-      }
-    })
-
-    it('should return empty defaults object for number type', () => {
-      const entry = getFieldRegistryEntry('number')
-      expect(entry.defaults).toEqual({})
-    })
-
-    it('should return empty defaults object for checkbox type', () => {
-      const entry = getFieldRegistryEntry('checkbox')
-      expect(entry.defaults).toEqual({})
-    })
-  })
-
-  describe('getTypeDefault', () => {
-    it('should return false for checkbox', () => {
-      expect(getTypeDefault('checkbox')).toBe(false)
-    })
-
-    it('should return false for toggle', () => {
-      expect(getTypeDefault('toggle')).toBe(false)
-    })
-
-    it('should return undefined for number', () => {
-      expect(getTypeDefault('number')).toBeUndefined()
-    })
-
-    it('should return undefined for slider', () => {
-      expect(getTypeDefault('slider')).toBeUndefined()
-    })
-
-    it('should return empty array for multiselect', () => {
-      expect(getTypeDefault('multiselect')).toEqual([])
-    })
-
-    it('should return empty array for tags', () => {
-      expect(getTypeDefault('tags')).toEqual([])
-    })
-
-    it('should return empty string for text', () => {
-      expect(getTypeDefault('text')).toBe('')
-    })
-
-    it('should return empty string for email', () => {
-      expect(getTypeDefault('email')).toBe('')
-    })
-
-    it('should return empty string for password', () => {
-      expect(getTypeDefault('password')).toBe('')
-    })
-
-    it('should return empty string for textarea', () => {
-      expect(getTypeDefault('textarea')).toBe('')
-    })
-
-    it('should return empty string for select', () => {
-      expect(getTypeDefault('select')).toBe('')
-    })
-
-    it('should return empty string for date', () => {
-      expect(getTypeDefault('date')).toBe('')
-    })
-
-    it('should return empty string for time', () => {
-      expect(getTypeDefault('time')).toBe('')
-    })
-
-    it('should return empty string for datetime', () => {
-      expect(getTypeDefault('datetime')).toBe('')
-    })
-
-    it('should return empty string for file', () => {
-      expect(getTypeDefault('file')).toBe('')
-    })
-
-    it('should return empty string for radio', () => {
-      expect(getTypeDefault('radio')).toBe('')
-    })
-
-    it('should return empty string for formula', () => {
-      expect(getTypeDefault('formula')).toBe('')
-    })
-
-    it('should return empty string for sequence', () => {
-      expect(getTypeDefault('sequence')).toBe('')
-    })
-
-    it('should return empty string for molecule', () => {
-      expect(getTypeDefault('molecule')).toBe('')
-    })
-
-    it('should return empty string for concentration', () => {
-      expect(getTypeDefault('concentration')).toBe('')
-    })
-
-    it('should return empty string for unit', () => {
-      expect(getTypeDefault('unit')).toBe('')
-    })
-
-    it('should return a new array instance each call for multiselect', () => {
-      const a = getTypeDefault('multiselect')
-      const b = getTypeDefault('multiselect')
-      expect(a).toEqual(b)
-      // Each call should return a distinct array
-      expect(a).not.toBe(b)
-    })
-
-    it('should return a new array instance each call for tags', () => {
-      const a = getTypeDefault('tags')
-      const b = getTypeDefault('tags')
-      expect(a).not.toBe(b)
-    })
-  })
-})

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

@@ -1,65 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { resolvePluginFrontendBase } from '../../composables/pluginFrontendBase'
-
-type InjectedPlatformWindow = Window & {
-  __MINT_PLATFORM__?: unknown
-}
-
-describe('resolvePluginFrontendBase', () => {
-  afterEach(() => {
-    delete (window as InjectedPlatformWindow).__MINT_PLATFORM__
-  })
-
-  it('should use the normalized route prefix when the platform context is integrated', () => {
-    ;(window as InjectedPlatformWindow).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      plugin: {
-        id: 'leaf',
-        name: 'LEAF',
-        version: '0.7.0',
-        route_prefix: '/leaf///',
-        api_prefix: '/api/leaf',
-      },
-    }
-
-    expect(resolvePluginFrontendBase('./')).toBe('/leaf/')
-  })
-
-  it('should preserve the caller fallback when the platform context is absent', () => {
-    expect(resolvePluginFrontendBase('./')).toBe('./')
-  })
-
-  it('should preserve the caller fallback when the platform context is standalone', () => {
-    ;(window as InjectedPlatformWindow).__MINT_PLATFORM__ = {
-      isIntegrated: false,
-      theme: 'light',
-      plugin: {
-        id: 'leaf',
-        name: 'LEAF',
-        version: '0.7.0',
-        route_prefix: '/leaf',
-        api_prefix: '/api/leaf',
-      },
-    }
-
-    expect(resolvePluginFrontendBase('/dev/')).toBe('/dev/')
-  })
-
-  it('should preserve root when the integrated route prefix is root', () => {
-    ;(window as InjectedPlatformWindow).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      plugin: {
-        id: 'root',
-        name: 'Root',
-        version: '1.0.0',
-        route_prefix: '/',
-        api_prefix: '/api',
-      },
-    }
-
-    expect(resolvePluginFrontendBase('./')).toBe('/')
-  })
-})