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

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

@@ -1,35 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  findNearestTimeSlotIndex,
-  formatTimeSlot,
-  fromMinutes,
-  generateTimeSlots,
-  toMinutes,
-  useTimeUtils,
-} from '../../composables/useTimeUtils'
-
-describe('useTimeUtils', () => {
-  it('formats HH:MM slots for shared picker display', () => {
-    expect(formatTimeSlot('00:00')).toBe('00:00')
-    expect(formatTimeSlot('14:30', '12h')).toBe('2:30 PM')
-  })
-
-  it('converts between HH:MM strings and minute offsets', () => {
-    expect(toMinutes('09:45')).toBe(585)
-    expect(fromMinutes(585)).toBe('09:45')
-  })
-
-  it('finds the nearest slot index for scroll and highlight behavior', () => {
-    const slots = generateTimeSlots('09:00', '10:00', 15)
-
-    expect(findNearestTimeSlotIndex('09:37', slots)).toBe(2)
-    expect(findNearestTimeSlotIndex('08:00', [])).toBe(-1)
-  })
-
-  it('exposes the shared slot helpers from the composable facade', () => {
-    const utils = useTimeUtils()
-
-    expect(utils.formatTimeSlot('23:15', '12h')).toBe('11:15 PM')
-    expect(utils.findNearestTimeSlotIndex('10:20', ['10:00', '10:30'])).toBe(1)
-  })
-})

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

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-  coordinateToWellId,
-  useWellPainting,
-  wellIdToCoordinate,
-  wellIdsInRectangle,
-} from '../../composables/useWellPainting'
-
-describe('useWellPainting', () => {
-  it('converts well coordinates and computes rectangle selections', () => {
-    expect(wellIdToCoordinate('B2')).toEqual({ row: 1, col: 1 })
-    expect(coordinateToWellId({ row: 0, col: 0 })).toBe('A1')
-    expect(wellIdsInRectangle({ row: 0, col: 0 }, { row: 1, col: 1 }, 96)).toEqual([
-      'A1',
-      'A2',
-      'B1',
-      'B2',
-    ])
-  })
-
-  it('emits rectangle selections in select mode', () => {
-    const completed: string[][] = []
-    const painting = useWellPainting({
-      format: 96,
-      initialMode: 'select',
-      onComplete: result => completed.push(result.wellIds),
-    })
-
-    painting.onWellMouseDown('A1')
-    painting.onWellMouseMove('B2')
-    expect(painting.previewWellIds.value).toEqual(['A1', 'A2', 'B1', 'B2'])
-    painting.onWellMouseUp()
-
-    expect(completed).toEqual([['A1', 'A2', 'B1', 'B2']])
-  })
-
-  it('tracks paint trails for non-select modes', () => {
-    const completed: { mode: string; wells: string[] }[] = []
-    const painting = useWellPainting({
-      format: 96,
-      initialMode: 'paint',
-      onComplete: result => completed.push({ mode: result.mode, wells: result.wellIds }),
-    })
-
-    painting.onWellMouseDown('A1')
-    painting.onWellMouseMove('A3')
-    painting.onWellMouseUp()
-
-    expect(completed).toEqual([{ mode: 'paint', wells: ['A1', 'A3'] }])
-  })
-})

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

@@ -1,50 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-  createColumnConditions,
-  createRowConditions,
-  createWellPlateWells,
-} from '../../composables/useWellPlateAdapter'
-
-describe('well plate adapter helpers', () => {
-  it('maps domain entries to WellPlate wells', () => {
-    const wells = createWellPlateWells(
-      [{ id: 'B3', type: 'sample', signal: 42 }],
-      {
-        getWellId: entry => entry.id,
-        getSampleType: entry => entry.type,
-        getValue: entry => entry.signal,
-        getMetadata: () => ({ source: 'analysis' }),
-      },
-    )
-
-    expect(wells.B3).toEqual({
-      id: 'B3',
-      row: 1,
-      col: 2,
-      state: 'filled',
-      sampleType: 'sample',
-      value: 42,
-      metadata: { source: 'analysis' },
-    })
-  })
-
-  it('builds row and column condition spans from axis entries', () => {
-    const entry = {
-      label: 'Drug A',
-      color: '#123456',
-      start: 2,
-      unit: 'uM',
-      concentrations: [{ value: 1, replicates: 2 }, { value: 10 }],
-    }
-
-    expect(createColumnConditions([entry])[0]).toMatchObject({
-      cols: [2, 3, 4],
-      concentrations: [1, 1, 10],
-    })
-    expect(createRowConditions([{ ...entry, start: 'B' }])[0]).toMatchObject({
-      rows: ['B', 'C', 'D'],
-      concentrations: [1, 1, 10],
-    })
-  })
-})

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

@@ -1,42 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { runWellPlateValidation, useWellPlateValidation } from '../../composables/useWellPlateValidation'
-
-describe('well plate validation helpers', () => {
-  it('runs rule-driven validation', () => {
-    const warnings = runWellPlateValidation(
-      { assigned: 0 },
-      [
-        {
-          type: 'empty',
-          severity: 'warning',
-          validate: context => context.assigned === 0 && 'No wells assigned',
-        },
-      ],
-    )
-
-    expect(warnings).toEqual([
-      { type: 'empty', severity: 'warning', message: 'No wells assigned' },
-    ])
-  })
-
-  it('derives blocking state and counts', () => {
-    const validation = useWellPlateValidation({
-      context: { overlaps: ['A1'] },
-      rules: [
-        {
-          type: 'overlap',
-          severity: 'error',
-          validate: context => ({
-            message: `${context.overlaps.length} overlap`,
-            affectedWells: context.overlaps,
-          }),
-        },
-      ],
-    })
-
-    expect(validation.hasBlockingIssues.value).toBe(true)
-    expect(validation.errorCount.value).toBe(1)
-    expect(validation.warningCount.value).toBe(1)
-  })
-})

package/src/__tests__/docs/extractDocsComponents.test.ts

@@ -1,156 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-import {
-  extractComponent,
-  extractDeprecation,
-  parseComponentExports,
-} from '../../../scripts/extract-docs-components'
-
-const tempDirs: string[] = []
-
-function createTempDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), 'mint-docs-components-'))
-  tempDirs.push(dir)
-  return dir
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-describe('extract docs component helpers', () => {
-  it('parses grouped Vue component exports with JSDoc metadata', () => {
-    const dir = createTempDir()
-    const indexPath = join(dir, 'index.ts')
-    writeFileSync(indexPath, `
-// Base Components
-/** Primary action. */
-export { default as MintButton } from './Button.vue'
-
-// Scheduling / Booking Components
-/**
- * @deprecated Prefer ScheduleCalendar.
- */
-export { default as OldCalendar } from './OldCalendar.vue'
-
-// Custom Group
-export { default as SpecialThing } from './SpecialThing.vue'
-`)
-
-    expect(parseComponentExports(indexPath)).toEqual([
-      {
-        name: 'MintButton',
-        fileBase: 'Button',
-        group: 'base',
-        description: 'Primary action.',
-      },
-      {
-        name: 'OldCalendar',
-        fileBase: 'OldCalendar',
-        group: 'scheduling',
-        description: '@deprecated Prefer ScheduleCalendar.',
-        deprecated: true,
-        replacement: 'ScheduleCalendar',
-      },
-      {
-        name: 'SpecialThing',
-        fileBase: 'SpecialThing',
-        group: 'custom-group',
-      },
-    ])
-  })
-
-  it('extracts deprecation replacements from use/prefer prose', () => {
-    expect(extractDeprecation('@deprecated Use `NewThing()` instead.')).toEqual({
-      deprecated: true,
-      replacement: 'NewThing',
-    })
-    expect(extractDeprecation('Stable component.')).toEqual({})
-  })
-
-  it('extracts SFC props, emits, and slots from public components', () => {
-    const dir = createTempDir()
-    const componentPath = join(dir, 'src', 'components', 'FancyButton.vue')
-    mkdirSync(join(dir, 'src', 'components'), { recursive: true })
-    writeFileSync(componentPath, `
-<script setup lang="ts">
-/**
- * Fancy button docs.
- *
- * @example Recommended
- * \`\`\`vue
- * <FancyButton label="Save" />
- * \`\`\`
- */
-interface Props {
-  /** Visible label. */
-  label: string
-  variant?: 'primary' | 'secondary'
-}
-
-withDefaults(defineProps<Props>(), {
-  variant: 'primary',
-})
-
-defineEmits<{
-  'update:modelValue': [value: string]
-  click: []
-}>()
-
-defineSlots<{
-  default: () => unknown
-  suffix?: () => unknown
-}>()
-</script>
-
-<template>
-  <button>
-    <slot />
-    <slot name="suffix" />
-  </button>
-</template>
-`)
-
-    expect(extractComponent(componentPath, 'FancyButton', 'base', dir)).toMatchObject({
-      name: 'FancyButton',
-      kind: 'component',
-      group: 'base',
-      source: 'packages/sdk-frontend/src/components/FancyButton.vue',
-      description: 'Fancy button docs.',
-      examples: [
-        {
-          title: 'Recommended',
-          language: 'vue',
-          code: '<FancyButton label="Save" />',
-        },
-      ],
-      props: [
-        {
-          name: 'label',
-          type: 'string',
-          required: true,
-          description: 'Visible label.',
-        },
-        {
-          name: 'variant',
-          type: "'primary' | 'secondary'",
-          required: false,
-          default: "'primary'",
-          description: '',
-        },
-      ],
-      emits: [
-        { name: 'update:modelValue', type: '(value: string) => void' },
-        { name: 'click', type: '() => void' },
-      ],
-      slots: [
-        { name: 'default', description: '' },
-        { name: 'suffix', description: '' },
-      ],
-    })
-  })
-})

package/src/__tests__/docs/extractDocsExports.test.ts

@@ -1,92 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-import {
-  parseNamedExports,
-  parseNamedExportSpecs,
-  parseInlineNamedExports,
-  resolveLocalExportPath,
-  resolveNamedExportPath,
-} from '../../../scripts/extract-docs-exports'
-
-const tempDirs: string[] = []
-
-function createTempDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), 'mint-docs-exports-'))
-  tempDirs.push(dir)
-  return dir
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-describe('extract docs export helpers', () => {
-  it('parses aliased named export specs and skips invalid entries', () => {
-    expect(parseNamedExportSpecs(`
-      type LocalType as PublicType,
-      InternalName as PublicName,
-      default,
-      invalid-name,
-      // ignored
-    `)).toEqual([
-      { localName: 'LocalType', exportedName: 'PublicType' },
-      { localName: 'InternalName', exportedName: 'PublicName' },
-    ])
-  })
-
-  it('resolves local export paths across files and directory indexes', () => {
-    const dir = createTempDir()
-    const indexPath = join(dir, 'index.ts')
-    const featureDir = join(dir, 'feature')
-    writeFileSync(indexPath, '')
-    writeFileSync(join(dir, 'direct.ts'), 'export const Direct = 1')
-    writeFileSync(join(dir, 'component.vue'), '<template />')
-    mkdirSync(featureDir)
-    writeFileSync(join(featureDir, 'index.ts'), 'export const Nested = 1')
-
-    expect(resolveLocalExportPath(indexPath, './direct')).toBe(join(dir, 'direct.ts'))
-    expect(resolveLocalExportPath(indexPath, './component')).toBe(join(dir, 'component.vue'))
-    expect(resolveLocalExportPath(indexPath, './feature')).toBe(join(featureDir, 'index.ts'))
-    expect(resolveLocalExportPath(indexPath, 'vue')).toBeNull()
-  })
-
-  it('collects inline exported declarations', () => {
-    expect(parseInlineNamedExports(`
-      export interface Item {}
-      export type ItemId = string
-      export const makeItem = () => ({})
-      export function parseItem() {}
-      export class ItemStore {}
-      export enum ItemKind { A = 'a' }
-      export default function ignored() {}
-    `)).toEqual(['Item', 'ItemId', 'ItemKind', 'ItemStore', 'makeItem', 'parseItem'])
-  })
-
-  it('collects and resolves named exports through re-export chains', () => {
-    const dir = createTempDir()
-    const indexPath = join(dir, 'index.ts')
-    const nestedPath = join(dir, 'nested.ts')
-    const leafPath = join(dir, 'leaf.ts')
-    const starPath = join(dir, 'star.ts')
-    writeFileSync(indexPath, `
-      export { Leaf as PublicLeaf } from './nested'
-      export * from './leaf'
-    `)
-    writeFileSync(nestedPath, "export { InternalLeaf as Leaf } from './leaf'")
-    writeFileSync(leafPath, "export const InternalLeaf = 1\nexport { StarExport } from './star'")
-    writeFileSync(starPath, 'export const StarExport = 2')
-
-    expect(parseNamedExports(indexPath)).toEqual([
-      { name: 'InternalLeaf' },
-      { name: 'PublicLeaf' },
-      { name: 'StarExport' },
-    ])
-    expect(resolveNamedExportPath(indexPath, 'InternalLeaf')).toBe(leafPath)
-    expect(resolveNamedExportPath(indexPath, 'PublicLeaf')).toBe(leafPath)
-    expect(resolveNamedExportPath(indexPath, 'StarExport')).toBe(starPath)
-  })
-})

package/src/__tests__/docs/extractDocsParsing.test.ts

@@ -1,91 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  cleanJsdoc,
-  cleanJsdocSummary,
-  extractBalancedBraces,
-  extractBalancedParens,
-  extractJsdocExamples,
-  extractTrailingJsdoc,
-  findMatchingClose,
-  splitTopLevel,
-} from '../../../scripts/extract-docs-parsing'
-
-describe('extract docs parsing helpers', () => {
-  it('extracts balanced braces after whitespace-insensitive markers', () => {
-    const source = `
-      withDefaults(
-        defineProps<Props>(),
-        {
-          alpha: { nested: true },
-          beta: () => ({ value: 1 }),
-        }
-      )
-    `
-
-    expect(extractBalancedBraces(source, 'withDefaults(defineProps<Props>(),')).toContain(
-      'alpha: { nested: true }',
-    )
-  })
-
-  it('splits only top-level delimiters', () => {
-    expect(splitTopLevel('alpha, beta<{ one: string, two: number }>, gamma()', ',')).toEqual([
-      'alpha',
-      ' beta<{ one: string, two: number }>',
-      ' gamma()',
-    ])
-  })
-
-  it('finds matching close brackets and paren content with nested groups', () => {
-    const source = 'fn(alpha, nested(beta, gamma), delta)'
-    const openIdx = source.indexOf('(')
-
-    expect(findMatchingClose(source, openIdx, '(', ')')).toBe(source.length - openIdx - 1)
-    expect(extractBalancedParens(source, 0)).toBe('alpha, nested(beta, gamma), delta')
-  })
-
-  it('cleans JSDoc blocks and summaries', () => {
-    const comment = `
-      /**
-       * Primary summary.
-       *
-       * More details.
-       */
-    `
-
-    expect(cleanJsdoc(comment)).toBe('Primary summary.\nMore details.')
-    expect(cleanJsdocSummary(comment)).toBe('Primary summary.')
-  })
-
-  it('extracts only the trailing JSDoc closest to a declaration', () => {
-    const source = `
-      /** Earlier. */
-      const a = 1
-
-      /** Selected. */
-      export function useThing() {}
-    `
-
-    expect(extractTrailingJsdoc(source, source.indexOf('export function'))).toContain('Selected.')
-  })
-
-  it('extracts structured examples from JSDoc fenced blocks', () => {
-    const comment = `
-      /**
-       * Component summary.
-       *
-       * @example Recommended
-       * \`\`\`vue
-       * <ExperimentSelectorModal v-model="open" />
-       * \`\`\`
-       */
-    `
-
-    expect(extractJsdocExamples(comment)).toEqual([
-      {
-        title: 'Recommended',
-        language: 'vue',
-        code: '<ExperimentSelectorModal v-model="open" />',
-      },
-    ])
-  })
-})

package/src/__tests__/docs/extractDocsTemplates.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { bioTemplateCatalog } from '../../../src/templates/catalog'
-import { bioTemplatePacks } from '../../../src/templates/packs'
-import { bioTemplatePresets } from '../../../src/templates/presets'
-import {
-  extractTemplatePacks,
-  extractTemplatePresets,
-  extractTemplates,
-} from '../../../scripts/extract-docs-templates'
-
-describe('extract docs template helpers', () => {
-  it('maps catalog templates into docs manifest entries', () => {
-    const entry = bioTemplateCatalog[0]!
-    const template = extractTemplates()[0]!
-
-    expect(extractTemplates()).toHaveLength(bioTemplateCatalog.length)
-    expect(template).toMatchObject({
-      name: entry.name,
-      kind: 'template',
-      group: entry.category,
-      source: 'packages/sdk-frontend/src/templates/catalog.ts',
-      description: entry.purpose,
-      template_id: entry.template_id,
-      template_version: entry.template_version,
-      add_command: entry.add_command,
-    })
-  })
-
-  it('maps curated presets and packs into docs manifest entries', () => {
-    const presetEntry = bioTemplatePresets[0]!
-    const preset = extractTemplatePresets()[0]!
-    const packEntry = bioTemplatePacks[0]!
-    const pack = extractTemplatePacks()[0]!
-
-    expect(extractTemplatePresets()).toHaveLength(bioTemplatePresets.length)
-    expect(preset).toMatchObject({
-      name: presetEntry.name,
-      kind: 'template-preset',
-      group: presetEntry.category,
-      source: 'packages/sdk-frontend/src/templates/presets.ts',
-      templates: presetEntry.templates,
-    })
-    expect(extractTemplatePacks()).toHaveLength(bioTemplatePacks.length)
-    expect(pack).toMatchObject({
-      name: packEntry.name,
-      kind: 'template-pack',
-      group: packEntry.category,
-      source: 'packages/sdk-frontend/src/templates/packs.ts',
-      add_command: packEntry.add_command,
-      docs_command: packEntry.docs_command,
-    })
-  })
-})

package/src/__tests__/docs/extractDocsTheme.test.ts

@@ -1,89 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-import {
-  extractCssVariables,
-  extractTailwindPreset,
-} from '../../../scripts/extract-docs-theme'
-
-const tempDirs: string[] = []
-
-function createTempDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), 'mint-docs-theme-'))
-  tempDirs.push(dir)
-  return dir
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-describe('extract docs theme helpers', () => {
-  it('groups CSS variables by root comment sections', () => {
-    const dir = createTempDir()
-    const cssPath = join(dir, 'variables.css')
-    writeFileSync(cssPath, `
-:root {
-  --spacing-sm: 0.5rem;
-  /* Background colors */
-  --bg-default: #ffffff;
-  --bg-muted: var(--mint-50);
-}
-`)
-
-    expect(extractCssVariables(cssPath)).toEqual({
-      General: [
-        { name: '--spacing-sm', value: '0.5rem' },
-      ],
-      'Background colors': [
-        { name: '--bg-default', value: '#ffffff' },
-        { name: '--bg-muted', value: 'var(--mint-50)' },
-      ],
-    })
-  })
-
-  it('extracts Tailwind color groups and font families', () => {
-    const dir = createTempDir()
-    const presetPath = join(dir, 'tailwind.preset.ts')
-    writeFileSync(presetPath, `
-export default {
-  theme: {
-    extend: {
-      colors: {
-        mint: {
-          50: "#f0fdfa",
-          600: "#0d9488",
-        },
-        bg: {
-          canvas: "var(--bg-default)",
-        },
-      },
-      fontFamily: {
-        sans: ['Inter', 'sans-serif'],
-        mono: ["JetBrains Mono", "monospace"],
-      },
-    },
-  },
-}
-`)
-
-    expect(extractTailwindPreset(presetPath)).toMatchObject({
-      colors: {
-        mint: {
-          50: '#f0fdfa',
-          600: '#0d9488',
-        },
-        bg: {
-          canvas: 'var(--bg-default)',
-        },
-      },
-      fontFamily: {
-        sans: 'Inter',
-        mono: 'JetBrains Mono',
-      },
-    })
-  })
-})