@morscherlab/mint-sdk 1.2.0-beta.8 → 1.2.0

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

@@ -1,127 +0,0 @@
-import { computed, ref } from 'vue'
-import { describe, expect, it } from 'vitest'
-import { useAutoGroup } from '../../composables/useAutoGroup'
-import { useAutoGroupInputSources } from '../../composables/useAutoGroupInputSources'
-import type { WizardStep } from '../../types/components'
-
-function makeSources(options: {
-  samples?: string[]
-  experimentId?: number
-  designData?: Record<string, unknown>
-  apiGet?: (url: string) => Promise<Record<string, unknown>>
-} = {}) {
-  const autoGroup = useAutoGroup()
-  const currentStep = ref(0)
-  const dynamicSteps = ref<WizardStep[]>([
-    { id: 'input', label: 'Input' },
-    { id: 'fields', label: 'Fields' },
-    { id: 'preview', label: 'Preview' },
-  ])
-  const sources = useAutoGroupInputSources({
-    autoGroup,
-    samples: computed(() => options.samples ?? []),
-    experimentId: computed(() => options.experimentId),
-    designData: computed(() => options.designData),
-    currentStep,
-    dynamicSteps,
-    api: {
-      get: async <T>(url: string): Promise<T> => {
-        const value = options.apiGet
-          ? await options.apiGet(url)
-          : { data: undefined }
-        return value as T
-      },
-    },
-  })
-
-  return { autoGroup, currentStep, dynamicSteps, sources }
-}
-
-describe('useAutoGroupInputSources', () => {
-  it('initializes pasted sample input when samples are provided', async () => {
-    const { autoGroup, currentStep, sources } = makeSources({
-      samples: ['S1_Control', 'S2_Treated'],
-    })
-    currentStep.value = 2
-
-    await sources.initializeInputSources()
-
-    expect(currentStep.value).toBe(0)
-    expect(autoGroup.rawText.value).toBe('S1_Control\nS2_Treated')
-    expect(sources.csvFileName.value).toBe('')
-    expect(sources.experimentError.value).toBeNull()
-  })
-
-  it('loads experiment design data and advances to the fields step', async () => {
-    const { autoGroup, currentStep, sources } = makeSources({
-      designData: {
-        samples: [
-          { sample_name: 'S1', sample_type: 'sample', conditions: { Treatment: 'Control' } },
-          { sample_name: 'S2', sample_type: 'sample', conditions: { Treatment: 'Drug' } },
-        ],
-      },
-    })
-
-    await sources.initializeInputSources()
-
-    expect(autoGroup.inputMode.value).toBe('experiment')
-    expect(autoGroup.csvData.value?.rows).toHaveLength(2)
-    expect(sources.experimentFieldNames.value).toEqual(['Treatment', 'sample_type'])
-    expect(currentStep.value).toBe(1)
-    expect(sources.experimentLoading.value).toBe(false)
-  })
-
-  it('filters loaded experiment metadata to the provided sample subset', async () => {
-    const { autoGroup, sources } = makeSources({
-      samples: ['S2', 'MissingFromDesign'],
-      designData: {
-        samples: [
-          { sample_name: 'S1', sample_type: 'sample', conditions: { Tissue: 'Kidney', Treatment: 'Control' } },
-          { sample_name: 'S2', sample_type: 'sample', conditions: { Tissue: 'Liver', Treatment: 'Drug' } },
-        ],
-      },
-    })
-
-    await sources.initializeInputSources()
-
-    expect(autoGroup.samples.value).toEqual(['S2', 'MissingFromDesign'])
-    expect(autoGroup.groups.value.map(g => g.name).sort()).toEqual([
-      'Liver / Drug',
-      'Outlier',
-    ])
-  })
-
-  it('parses uploaded CSV files and can clear them back to paste mode', async () => {
-    const { autoGroup, sources } = makeSources()
-    const file = {
-      name: 'samples.csv',
-      text: async () => 'sample_name,Treatment\nS1,Control\nS2,Drug',
-    } as File
-
-    await sources.processFile(file)
-
-    expect(autoGroup.inputMode.value).toBe('csv')
-    expect(autoGroup.csvData.value?.rows).toHaveLength(2)
-    expect(sources.csvFileName.value).toBe('samples.csv')
-
-    sources.clearCsvFile()
-
-    expect(autoGroup.inputMode.value).toBe('paste')
-    expect(autoGroup.csvData.value).toBeNull()
-    expect(sources.csvFileName.value).toBe('')
-  })
-
-  it('surfaces API errors when experiment metadata cannot be fetched', async () => {
-    const { sources } = makeSources({
-      experimentId: 42,
-      apiGet: async () => {
-        throw new Error('offline')
-      },
-    })
-
-    await sources.initializeInputSources()
-
-    expect(sources.experimentLoading.value).toBe(false)
-    expect(sources.experimentError.value).toBe('offline')
-  })
-})

package/src/composables/autoGroupConstants.ts

@@ -1,4 +0,0 @@
-export const DEFAULT_COLORS = [
-  '#3B82F6', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6',
-  '#EC4899', '#06B6D4', '#84CC16', '#F97316', '#6366F1',
-]

package/src/composables/autoGroupGrouping.ts

@@ -1,148 +0,0 @@
-import type {
-  AutoGroupResult,
-  ColumnInfo,
-  MetadataRow,
-  OutlierAction,
-  ParsedCsvData,
-} from '../types/auto-group'
-import type { SampleGroup } from '../types/components'
-import { DEFAULT_COLORS } from './autoGroupConstants'
-
-export function computeGroups(
-  allSamples: string[],
-  columns: ColumnInfo[],
-  enabledFields: Set<number>,
-  outlierActions: Map<number, OutlierAction>,
-  delimiter: string,
-  minFieldCount: number,
-): AutoGroupResult {
-  const excludedSamples: string[] = []
-  const qcSamples: string[] = []
-  const conformingSamples: string[] = []
-
-  for (let i = 0; i < allSamples.length; i++) {
-    const action = outlierActions.get(i)
-    if (action === 'exclude') {
-      excludedSamples.push(allSamples[i])
-    } else if (action === 'qc') {
-      qcSamples.push(allSamples[i])
-    } else {
-      conformingSamples.push(allSamples[i])
-    }
-  }
-
-  // Build group map
-  const groupMap = new Map<string, string[]>()
-  const metadata: MetadataRow[] = []
-  const enabledIndices = [...enabledFields].sort((a, b) => a - b)
-  const suffixCount = minFieldCount - 1
-
-  for (const sample of conformingSamples) {
-    const parts = sample.split(delimiter)
-    const splitAt = Math.max(1, parts.length - suffixCount)
-    const row = [
-      parts.slice(0, splitAt).join(delimiter),
-      ...parts.slice(splitAt),
-    ]
-
-    // Build group key from enabled columns
-    const keyParts: string[] = []
-    for (const idx of enabledIndices) {
-      if (idx < row.length && idx < columns.length) {
-        keyParts.push(row[idx])
-      }
-    }
-    const groupKey = keyParts.join(' / ')
-
-    const group = groupMap.get(groupKey)
-    if (group) {
-      group.push(sample)
-    } else {
-      groupMap.set(groupKey, [sample])
-    }
-
-    // Build metadata row with ALL columns
-    const fields: Record<string, string> = {}
-    for (const col of columns) {
-      if (col.index < row.length) {
-        fields[col.name] = row[col.index]
-      }
-    }
-    metadata.push({ sampleName: sample, fields, group: groupKey })
-  }
-
-  // Convert to SampleGroup[]
-  const groups: SampleGroup[] = []
-  let colorIdx = 0
-  for (const [name, samples] of groupMap) {
-    groups.push({
-      name,
-      color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
-      samples,
-    })
-    colorIdx++
-  }
-
-  // QC group
-  if (qcSamples.length > 0) {
-    groups.push({
-      name: 'QC',
-      color: '#6B7280',
-      samples: qcSamples,
-    })
-    for (const sample of qcSamples) {
-      metadata.push({ sampleName: sample, fields: {}, group: 'QC' })
-    }
-  }
-
-  return { groups, metadata, excludedSamples }
-}
-
-export function computeGroupsFromCsv(
-  csvData: ParsedCsvData,
-  columns: ColumnInfo[],
-  enabledFields: Set<number>,
-): AutoGroupResult {
-  const groupMap = new Map<string, string[]>()
-  const metadata: MetadataRow[] = []
-  const enabledCols = columns
-    .filter(c => enabledFields.has(c.index))
-    .sort((a, b) => a.index - b.index)
-
-  for (const row of csvData.rows) {
-    const sampleName = row[csvData.sampleColumn]
-
-    // Build group key from enabled CSV column values
-    // Use originalName for CSV row lookup (survives user renames), display name for group key
-    const keyParts = enabledCols.map(col => row[col.originalName ?? col.name])
-    const groupKey = keyParts.join(' / ')
-
-    const group = groupMap.get(groupKey)
-    if (group) {
-      group.push(sampleName)
-    } else {
-      groupMap.set(groupKey, [sampleName])
-    }
-
-    // Build metadata row with ALL columns - use display name as key, original for lookup
-    const fields: Record<string, string> = {}
-    for (const col of columns) {
-      fields[col.name] = row[col.originalName ?? col.name]
-    }
-    metadata.push({ sampleName, fields, group: groupKey })
-  }
-
-  // Convert to SampleGroup[]
-  const groups: SampleGroup[] = []
-  let colorIdx = 0
-  for (const [name, samples] of groupMap) {
-    groups.push({
-      name,
-      color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
-      samples,
-    })
-    colorIdx++
-  }
-
-  return { groups, metadata, excludedSamples: [] }
-}

package/src/composables/useAutoGroupInputSources.ts

@@ -1,147 +0,0 @@
-import { computed, nextTick, ref, type Ref } from 'vue'
-import { parseCSV, type useAutoGroup } from './useAutoGroup'
-import { useApi, type UseApiReturn } from './useApi'
-import type { WizardStep } from '../types/components'
-
-type AutoGroupController = ReturnType<typeof useAutoGroup>
-type ReadableRef<T> = Readonly<Ref<T>>
-type AutoGroupApi = Pick<UseApiReturn, 'get'>
-
-export interface UseAutoGroupInputSourcesOptions {
-  autoGroup: AutoGroupController
-  samples: ReadableRef<readonly string[]>
-  experimentId: ReadableRef<number | undefined>
-  designData: ReadableRef<Record<string, unknown> | undefined>
-  currentStep: Ref<number>
-  dynamicSteps: ReadableRef<readonly WizardStep[]>
-  api?: AutoGroupApi
-}
-
-/** Manages AutoGroupModal input sources: pasted samples, CSV/TSV files, and experiment metadata. */
-export function useAutoGroupInputSources(options: UseAutoGroupInputSourcesOptions) {
-  const api = options.api ?? useApi()
-  const isDragOver = ref(false)
-  const csvFileName = ref('')
-  const experimentLoading = ref(false)
-  const experimentError = ref<string | null>(null)
-  const csvError = ref<string | null>(null)
-
-  const experimentFieldNames = computed(() =>
-    options.autoGroup.csvData.value?.columns.filter(c => c !== 'sample_name') ?? [],
-  )
-
-  async function initializeInputSources() {
-    options.autoGroup.reset()
-    options.currentStep.value = 0
-    resetInputSourceState()
-
-    if (options.experimentId.value || options.designData.value) {
-      await fetchExperimentData()
-    } else if (options.samples.value.length > 0) {
-      options.autoGroup.rawText.value = options.samples.value.join('\n')
-    }
-  }
-
-  function resetInputSourceState() {
-    csvFileName.value = ''
-    experimentError.value = null
-    csvError.value = null
-    isDragOver.value = false
-  }
-
-  async function fetchExperimentData() {
-    if (!options.experimentId.value && !options.designData.value) return
-
-    options.autoGroup.inputMode.value = 'experiment'
-    experimentLoading.value = true
-    experimentError.value = null
-
-    try {
-      const pluginData = await loadExperimentPluginData()
-
-      if (!pluginData || typeof pluginData !== 'object') {
-        experimentError.value = 'No design data found for this experiment'
-        return
-      }
-
-      const success = options.autoGroup.loadExperimentData(pluginData, { samples: options.samples.value })
-      if (!success) {
-        experimentError.value = 'No sample metadata found in this experiment'
-        return
-      }
-
-      await nextTick()
-      const fieldsIdx = options.dynamicSteps.value.findIndex(s => s.id === 'fields')
-      if (fieldsIdx >= 0) {
-        options.currentStep.value = fieldsIdx
-      }
-    } catch (e) {
-      experimentError.value = e instanceof Error ? e.message : 'Failed to fetch experiment data'
-    } finally {
-      experimentLoading.value = false
-    }
-  }
-
-  async function loadExperimentPluginData(): Promise<Record<string, unknown> | undefined> {
-    if (options.designData.value) {
-      return options.designData.value
-    }
-
-    const result = await api.get<Record<string, unknown>>(
-      `/experiments/${options.experimentId.value}/data`,
-    )
-    return result.data as Record<string, unknown> | undefined
-  }
-
-  function handleFileDrop(event: DragEvent) {
-    event.preventDefault()
-    isDragOver.value = false
-    const files = event.dataTransfer?.files
-    if (files && files.length > 0) {
-      void processFile(files[0])
-    }
-  }
-
-  function handleFileInput(event: Event) {
-    const target = event.target as HTMLInputElement
-    if (target.files && target.files.length > 0) {
-      void processFile(target.files[0])
-    }
-  }
-
-  async function processFile(file: File) {
-    if (!file.name.endsWith('.csv') && !file.name.endsWith('.tsv')) return
-
-    csvError.value = null
-    try {
-      const text = await file.text()
-      const parsed = parseCSV(text)
-      options.autoGroup.inputMode.value = 'csv'
-      options.autoGroup.csvData.value = parsed
-      csvFileName.value = file.name
-    } catch (e) {
-      csvError.value = e instanceof Error ? e.message : 'Failed to parse file'
-    }
-  }
-
-  function clearCsvFile() {
-    options.autoGroup.csvData.value = null
-    options.autoGroup.inputMode.value = 'paste'
-    csvFileName.value = ''
-  }
-
-  return {
-    isDragOver,
-    csvFileName,
-    experimentLoading,
-    experimentError,
-    csvError,
-    experimentFieldNames,
-    initializeInputSources,
-    fetchExperimentData,
-    handleFileDrop,
-    handleFileInput,
-    processFile,
-    clearCsvFile,
-  }
-}

package/src/templates/builderDefaults.ts

@@ -1,11 +0,0 @@
-export const DEFAULT_SAMPLE_COLORS = [
-  '#3B82F6',
-  '#10B981',
-  '#EF4444',
-  '#F59E0B',
-  '#8B5CF6',
-  '#F97316',
-  '#06B6D4',
-  '#14B8A6',
-  '#6B7280',
-]

package/src/templates/plateGeometry.ts

@@ -1,62 +0,0 @@
-import type { WellPlateFormat } from '../types'
-
-const PLATE_DIMENSIONS: Record<number, readonly [number, number]> = {
-  6: [2, 3],
-  12: [3, 4],
-  24: [4, 6],
-  48: [6, 8],
-  54: [6, 9],
-  96: [8, 12],
-  384: [16, 24],
-}
-
-export function wellIdsForFormat(format: number): string[] {
-  const dimensions = PLATE_DIMENSIONS[format]
-  if (!dimensions) {
-    throw new Error(`Unsupported plate format '${format}'.`)
-  }
-  const [rows, cols] = dimensions
-  return Array.from({ length: rows }, (_, row) =>
-    Array.from({ length: cols }, (_col, col) => `${rowLabel(row)}${col + 1}`)
-  ).flat()
-}
-
-export function assertWellInFormat(wellId: string, format: number): void {
-  const dimensions = PLATE_DIMENSIONS[format]
-  if (!dimensions) {
-    throw new Error(`Unsupported plate format '${format}'.`)
-  }
-  const match = /^([A-Z]+)([1-9][0-9]*)$/.exec(wellId.toUpperCase())
-  if (!match) {
-    throw new Error(`Invalid well id '${wellId}'.`)
-  }
-  const row = rowIndex(match[1])
-  const col = Number(match[2]) - 1
-  const [rows, cols] = dimensions
-  if (row < 0 || col < 0 || row >= rows || col >= cols) {
-    throw new Error(`Well '${wellId}' is outside a ${format}-well plate.`)
-  }
-}
-
-export function readPlateFormat(value: unknown, fallback: WellPlateFormat): WellPlateFormat {
-  const parsed = typeof value === 'number'
-    ? value
-    : typeof value === 'string'
-      ? Number(value)
-      : Number.NaN
-  return parsed in PLATE_DIMENSIONS ? (parsed as WellPlateFormat) : fallback
-}
-
-function rowLabel(index: number): string {
-  let label = ''
-  let current = index
-  while (true) {
-    label = String.fromCharCode(65 + (current % 26)) + label
-    current = Math.floor(current / 26) - 1
-    if (current < 0) return label
-  }
-}
-
-function rowIndex(label: string): number {
-  return [...label].reduce((value, char) => value * 26 + char.charCodeAt(0) - 64, 0) - 1
-}