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

package/src/composables/useWellPlateAdapter.ts

@@ -0,0 +1,147 @@
+import { computed, toValue, type ComputedRef, type Ref } from 'vue'
+import type { ColumnCondition, RowCondition, Well } from '../types'
+
+export type WellPlateAdapterSource<T> =
+  | T
+  | Ref<T>
+  | ComputedRef<T>
+  | (() => T)
+
+export interface WellPlateEntry {
+  wellId: string
+  state?: Well['state']
+  sampleType?: string
+  value?: number
+  metadata?: Record<string, unknown>
+}
+
+export interface WellPlateAdapterOptions<TEntry> {
+  entries: WellPlateAdapterSource<readonly TEntry[]>
+  getWellId: (entry: TEntry) => string
+  getState?: (entry: TEntry) => Well['state'] | undefined
+  getSampleType?: (entry: TEntry) => string | undefined
+  getValue?: (entry: TEntry) => number | undefined
+  getMetadata?: (entry: TEntry) => Record<string, unknown> | undefined
+}
+
+export interface UseWellPlateAdapterReturn {
+  wells: ComputedRef<Record<string, Partial<Well>>>
+}
+
+/** Convert domain rows into WellPlate's wells prop without hand-written adapters. */
+export function useWellPlateAdapter<TEntry>(
+  options: WellPlateAdapterOptions<TEntry>,
+): UseWellPlateAdapterReturn {
+  const wells = computed(() => createWellPlateWells(toValue(options.entries), options))
+  return { wells }
+}
+
+export function createWellPlateWells<TEntry>(
+  entries: readonly TEntry[],
+  options: Omit<WellPlateAdapterOptions<TEntry>, 'entries'>,
+): Record<string, Partial<Well>> {
+  return Object.fromEntries(entries.map((entry) => {
+    const wellId = options.getWellId(entry)
+    const coord = parseWellId(wellId)
+    const well: Partial<Well> = {
+      id: wellId,
+      row: coord.row,
+      col: coord.col,
+      state: options.getState?.(entry) ?? 'filled',
+      sampleType: options.getSampleType?.(entry),
+      value: options.getValue?.(entry),
+      metadata: options.getMetadata?.(entry),
+    }
+    return [wellId, well]
+  }))
+}
+
+export interface AxisConditionEntry {
+  label: string
+  color: string
+  start: string | number
+  concentrations: readonly { value: number; replicates?: number }[]
+  unit?: string
+}
+
+export function createColumnConditions(entries: readonly AxisConditionEntry[]): ColumnCondition[] {
+  return entries.map((entry) => {
+    const startCol = typeof entry.start === 'number'
+      ? entry.start
+      : Number.parseInt(entry.start, 10)
+    const cols: number[] = []
+    const concentrations: number[] = []
+
+    for (const concentration of entry.concentrations) {
+      const replicates = concentration.replicates ?? 1
+      for (let index = 0; index < replicates; index++) {
+        cols.push(startCol + cols.length)
+        concentrations.push(concentration.value)
+      }
+    }
+
+    return {
+      label: entry.label,
+      color: entry.color,
+      unit: entry.unit,
+      cols,
+      concentrations,
+    }
+  })
+}
+
+export function createRowConditions(entries: readonly AxisConditionEntry[]): RowCondition[] {
+  return entries.map((entry) => {
+    const startRow = typeof entry.start === 'number'
+      ? entry.start
+      : rowLabelToIndex(entry.start)
+    const rows: string[] = []
+    const concentrations: number[] = []
+
+    for (const concentration of entry.concentrations) {
+      const replicates = concentration.replicates ?? 1
+      for (let index = 0; index < replicates; index++) {
+        rows.push(indexToRowLabel(startRow + rows.length))
+        concentrations.push(concentration.value)
+      }
+    }
+
+    return {
+      label: entry.label,
+      color: entry.color,
+      unit: entry.unit,
+      rows,
+      concentrations,
+    }
+  })
+}
+
+function parseWellId(wellId: string): { row: number; col: number } {
+  const match = /^([A-Z]+)(\d+)$/i.exec(wellId.trim())
+  if (!match) {
+    throw new Error(`[MINT SDK] Invalid well id "${wellId}".`)
+  }
+  return {
+    row: rowLabelToIndex(match[1].toUpperCase()),
+    col: Number(match[2]) - 1,
+  }
+}
+
+function rowLabelToIndex(label: string): number {
+  let result = 0
+  for (const char of label.toUpperCase()) {
+    result = result * 26 + (char.charCodeAt(0) - 64)
+  }
+  return result - 1
+}
+
+function indexToRowLabel(index: number): string {
+  let value = index + 1
+  let label = ''
+  while (value > 0) {
+    value--
+    label = String.fromCharCode(65 + (value % 26)) + label
+    value = Math.floor(value / 26)
+  }
+  return label
+}

package/src/composables/useWellPlateEditor.ts

@@ -0,0 +1,425 @@
+import { ref, computed, toRaw, type ComputedRef } from 'vue'
+import type {
+  PlateMapEditorState,
+  PlateMap,
+  SampleType,
+  WellPlateFormat,
+} from '../types'
+
+const DEFAULT_PALETTE = [
+  '#3B82F6', // blue
+  '#10B981', // green
+  '#EF4444', // red
+  '#F59E0B', // amber
+  '#8B5CF6', // purple
+  '#F97316', // orange
+  '#06B6D4', // cyan
+  '#14B8A6', // teal
+  '#6B7280', // gray
+]
+
+const MAX_HISTORY = 50
+
+interface HistoryEntry {
+  plates: PlateMap[]
+  samples: SampleType[]
+}
+
+export interface UseWellPlateEditorOptions {
+  maxHistory?: number
+  defaultFormat?: WellPlateFormat
+}
+
+export interface UseWellPlateEditorReturn {
+  state: ComputedRef<PlateMapEditorState>
+  plates: ComputedRef<PlateMap[]>
+  activePlate: ComputedRef<PlateMap | undefined>
+  samples: ComputedRef<SampleType[]>
+  selectedWells: ComputedRef<string[]>
+  activeSampleId: ComputedRef<string | undefined>
+  canUndo: ComputedRef<boolean>
+  canRedo: ComputedRef<boolean>
+  setActivePlate: (plateId: string) => void
+  setActiveSample: (sampleId: string | undefined) => void
+  setSelectedWells: (wellIds: string[]) => void
+  addPlate: (name?: string, format?: WellPlateFormat) => PlateMap
+  removePlate: (plateId: string) => void
+  addSample: (name: string, color?: string) => SampleType
+  removeSample: (sampleId: string) => void
+  assignSample: (wellIds: string[], sampleId: string | undefined) => void
+  clearWells: (wellIds: string[]) => void
+  undo: () => void
+  redo: () => void
+  exportData: (format: 'json' | 'csv') => string
+  importData: (data: string, format: 'json' | 'csv') => boolean
+  loadState: (state: Partial<PlateMapEditorState>) => void
+  reset: () => void
+}
+
+function createEmptyPlate(
+  name: string,
+  format: WellPlateFormat,
+  id?: string
+): PlateMap {
+  return {
+    id: id || `plate-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    name,
+    format,
+    wells: {},
+  }
+}
+
+function generateSampleId(): string {
+  return `sample-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+}
+
+function cloneValue<T>(value: T): T {
+  return structuredClone(toRaw(value))
+}
+
+/** Manages multi-plate well-plate state with sample assignment, selection, and undo/redo history. */
+export function useWellPlateEditor(
+  initialState?: Partial<PlateMapEditorState>,
+  options: UseWellPlateEditorOptions = {}
+): UseWellPlateEditorReturn {
+  const { maxHistory = MAX_HISTORY, defaultFormat = 96 } = options
+
+  const defaultPlate = createEmptyPlate('Plate 1', defaultFormat)
+
+  const internalState = ref<PlateMapEditorState>({
+    plates: initialState?.plates || [defaultPlate],
+    activePlateId: initialState?.activePlateId || defaultPlate.id,
+    samples: initialState?.samples || [],
+    selectedWells: initialState?.selectedWells || [],
+    activeSampleId: initialState?.activeSampleId,
+  })
+
+  const history = ref<HistoryEntry[]>([])
+  const historyIndex = ref(-1)
+
+  const state = computed(() => internalState.value)
+  const plates = computed(() => internalState.value.plates)
+  const activePlate = computed(() =>
+    internalState.value.plates.find(p => p.id === internalState.value.activePlateId)
+  )
+  const samples = computed(() => internalState.value.samples)
+  const selectedWells = computed(() => internalState.value.selectedWells)
+  const activeSampleId = computed(() => internalState.value.activeSampleId)
+
+  const canUndo = computed(() => historyIndex.value >= 0)
+  const canRedo = computed(() => historyIndex.value < history.value.length - 1)
+
+  function saveToHistory() {
+    const entry: HistoryEntry = {
+      plates: cloneValue(internalState.value.plates),
+      samples: cloneValue(internalState.value.samples),
+    }
+
+    if (historyIndex.value < history.value.length - 1) {
+      history.value = history.value.slice(0, historyIndex.value + 1)
+    }
+
+    history.value.push(entry)
+
+    if (history.value.length > maxHistory) {
+      history.value.shift()
+    } else {
+      historyIndex.value++
+    }
+  }
+
+  function setActivePlate(plateId: string) {
+    if (internalState.value.plates.some(p => p.id === plateId)) {
+      internalState.value.activePlateId = plateId
+      internalState.value.selectedWells = []
+    }
+  }
+
+  function setActiveSample(sampleId: string | undefined) {
+    internalState.value.activeSampleId = sampleId
+  }
+
+  function setSelectedWells(wellIds: string[]) {
+    internalState.value.selectedWells = wellIds
+  }
+
+  function addPlate(name?: string, format?: WellPlateFormat): PlateMap {
+    saveToHistory()
+    const plateNumber = internalState.value.plates.length + 1
+    const plate = createEmptyPlate(
+      name || `Plate ${plateNumber}`,
+      format || defaultFormat
+    )
+    internalState.value.plates.push(plate)
+    internalState.value.activePlateId = plate.id
+    internalState.value.selectedWells = []
+    return plate
+  }
+
+  function removePlate(plateId: string) {
+    if (internalState.value.plates.length <= 1) return
+
+    saveToHistory()
+    const index = internalState.value.plates.findIndex(p => p.id === plateId)
+    if (index === -1) return
+
+    internalState.value.plates.splice(index, 1)
+    if (internalState.value.activePlateId === plateId) {
+      internalState.value.activePlateId = internalState.value.plates[0].id
+      internalState.value.selectedWells = []
+    }
+  }
+
+  function addSample(name: string, color?: string): SampleType {
+    saveToHistory()
+    const sample: SampleType = {
+      id: generateSampleId(),
+      name,
+      color: color || DEFAULT_PALETTE[internalState.value.samples.length % DEFAULT_PALETTE.length],
+      count: 0,
+    }
+    internalState.value.samples.push(sample)
+    return sample
+  }
+
+  function removeSample(sampleId: string) {
+    saveToHistory()
+    const index = internalState.value.samples.findIndex(s => s.id === sampleId)
+    if (index === -1) return
+
+    internalState.value.samples.splice(index, 1)
+
+    for (const plate of internalState.value.plates) {
+      for (const well of Object.values(plate.wells)) {
+        if (well.sampleType === sampleId) {
+          delete well.sampleType
+          well.state = 'empty'
+        }
+      }
+    }
+
+    if (internalState.value.activeSampleId === sampleId) {
+      internalState.value.activeSampleId = undefined
+    }
+
+    updateSampleCounts()
+  }
+
+  function assignSample(wellIds: string[], sampleId: string | undefined) {
+    if (wellIds.length === 0) return
+
+    saveToHistory()
+    const plate = activePlate.value
+    if (!plate) return
+
+    for (const wellId of wellIds) {
+      const well = plate.wells[wellId] || {
+        id: wellId,
+        row: wellId.charCodeAt(0) - 65,
+        col: parseInt(wellId.slice(1)) - 1,
+        state: 'empty',
+      }
+
+      if (sampleId) {
+        well.sampleType = sampleId
+        well.state = 'filled'
+      } else {
+        delete well.sampleType
+        well.state = 'empty'
+      }
+
+      plate.wells[wellId] = well
+    }
+    updateSampleCounts()
+  }
+
+  function clearWells(wellIds: string[]) {
+    assignSample(wellIds, undefined)
+  }
+
+  function updateSampleCounts() {
+    const counts: Record<string, number> = {}
+
+    for (const plate of internalState.value.plates) {
+      for (const well of Object.values(plate.wells)) {
+        if (well.sampleType) {
+          counts[well.sampleType] = (counts[well.sampleType] || 0) + 1
+        }
+      }
+    }
+
+    for (const sample of internalState.value.samples) {
+      sample.count = counts[sample.id] || 0
+    }
+  }
+
+  function undo() {
+    if (!canUndo.value) return
+
+    const entry = history.value[historyIndex.value]
+    historyIndex.value--
+
+    internalState.value.plates = cloneValue(entry.plates)
+    internalState.value.samples = cloneValue(entry.samples)
+
+    const activePlateExists = internalState.value.plates.some(p => p.id === internalState.value.activePlateId)
+    if (!activePlateExists) {
+      internalState.value.activePlateId = internalState.value.plates[0]?.id || ''
+    }
+    internalState.value.selectedWells = []
+  }
+
+  function redo() {
+    if (!canRedo.value) return
+
+    historyIndex.value++
+    const entry = history.value[historyIndex.value]
+
+    internalState.value.plates = cloneValue(entry.plates)
+    internalState.value.samples = cloneValue(entry.samples)
+    internalState.value.selectedWells = []
+  }
+
+  function exportData(format: 'json' | 'csv'): string {
+    if (format === 'json') {
+      return JSON.stringify({
+        plates: internalState.value.plates,
+        samples: internalState.value.samples,
+      }, null, 2)
+    }
+
+    const sampleMap = new Map(internalState.value.samples.map(s => [s.id, s.name]))
+    const rows = ['Plate,Well,Sample Type,Sample Name']
+
+    for (const plate of internalState.value.plates) {
+      for (const [wellId, well] of Object.entries(plate.wells)) {
+        if (well.sampleType) {
+          const sampleName = sampleMap.get(well.sampleType) || ''
+          rows.push(`"${plate.name}","${wellId}","${well.sampleType}","${sampleName}"`)
+        }
+      }
+    }
+
+    return rows.join('\n')
+  }
+
+  function importData(data: string, format: 'json' | 'csv'): boolean {
+    try {
+      saveToHistory()
+
+      if (format === 'json') {
+        const parsed = JSON.parse(data)
+        if (parsed.plates && Array.isArray(parsed.plates)) {
+          internalState.value.plates = parsed.plates
+          internalState.value.activePlateId = parsed.plates[0]?.id || ''
+        }
+        if (parsed.samples && Array.isArray(parsed.samples)) {
+          internalState.value.samples = parsed.samples
+        }
+        internalState.value.selectedWells = []
+        updateSampleCounts()
+        return true
+      }
+
+      const lines = data.trim().split('\n')
+      if (lines.length < 2) return false
+
+      const plateMap = new Map<string, PlateMap>()
+      const sampleMap = new Map<string, SampleType>()
+
+      for (let i = 1; i < lines.length; i++) {
+        const parts = lines[i].match(/(?:[^",]+|"[^"]*")+/g)
+        if (!parts || parts.length < 4) continue
+
+        const plateName = parts[0].replace(/^"|"$/g, '')
+        const wellId = parts[1].replace(/^"|"$/g, '')
+        const sampleId = parts[2].replace(/^"|"$/g, '')
+        const sampleName = parts[3].replace(/^"|"$/g, '')
+
+        if (!plateMap.has(plateName)) {
+          plateMap.set(plateName, createEmptyPlate(plateName, defaultFormat))
+        }
+
+        if (sampleId && !sampleMap.has(sampleId)) {
+          sampleMap.set(sampleId, {
+            id: sampleId,
+            name: sampleName || sampleId,
+            color: DEFAULT_PALETTE[sampleMap.size % DEFAULT_PALETTE.length],
+            count: 0,
+          })
+        }
+
+        const plate = plateMap.get(plateName)!
+        plate.wells[wellId] = {
+          id: wellId,
+          row: wellId.charCodeAt(0) - 65,
+          col: parseInt(wellId.slice(1)) - 1,
+          state: sampleId ? 'filled' : 'empty',
+          sampleType: sampleId || undefined,
+        }
+      }
+
+      internalState.value.plates = Array.from(plateMap.values())
+      internalState.value.samples = Array.from(sampleMap.values())
+      internalState.value.activePlateId = internalState.value.plates[0]?.id || ''
+      internalState.value.selectedWells = []
+      updateSampleCounts()
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  function loadState(state: Partial<PlateMapEditorState>) {
+    saveToHistory()
+    if (state.plates && state.plates.length > 0) {
+      internalState.value.plates = cloneValue(state.plates)
+      internalState.value.activePlateId = state.activePlateId ?? state.plates[0].id
+    }
+    if (state.samples) {
+      internalState.value.samples = cloneValue(state.samples)
+    }
+    internalState.value.selectedWells = state.selectedWells ?? []
+    internalState.value.activeSampleId = state.activeSampleId
+    updateSampleCounts()
+  }
+
+  function reset() {
+    const plate = createEmptyPlate('Plate 1', defaultFormat)
+    internalState.value = {
+      plates: [plate],
+      activePlateId: plate.id,
+      samples: [],
+      selectedWells: [],
+      activeSampleId: undefined,
+    }
+    history.value = []
+    historyIndex.value = -1
+  }
+
+  return {
+    state,
+    plates,
+    activePlate,
+    samples,
+    selectedWells,
+    activeSampleId,
+    canUndo,
+    canRedo,
+    setActivePlate,
+    setActiveSample,
+    setSelectedWells,
+    addPlate,
+    removePlate,
+    addSample,
+    removeSample,
+    assignSample,
+    clearWells,
+    undo,
+    redo,
+    exportData,
+    importData,
+    loadState,
+    reset,
+  }
+}

package/src/composables/useWellPlateValidation.ts

@@ -0,0 +1,85 @@
+import { computed, toValue, type ComputedRef, type Ref } from 'vue'
+
+export type WellPlateValidationSeverity = 'error' | 'warning' | 'info'
+
+export interface WellPlateValidationWarning<TType extends string = string> {
+  type: TType
+  severity: WellPlateValidationSeverity
+  message: string
+  affectedWells?: string[]
+}
+
+export interface WellPlateValidationRule<TContext, TType extends string = string> {
+  type: TType
+  severity: WellPlateValidationSeverity
+  validate: (context: TContext) => false | string | Omit<WellPlateValidationWarning<TType>, 'type' | 'severity'>
+}
+
+export type WellPlateValidationSource<T> =
+  | T
+  | Ref<T>
+  | ComputedRef<T>
+  | (() => T)
+
+export interface UseWellPlateValidationOptions<TContext, TType extends string = string> {
+  context: WellPlateValidationSource<TContext>
+  rules: WellPlateValidationSource<readonly WellPlateValidationRule<TContext, TType>[]>
+}
+
+export interface UseWellPlateValidationReturn<TType extends string = string> {
+  warnings: ComputedRef<WellPlateValidationWarning<TType>[]>
+  hasBlockingIssues: ComputedRef<boolean>
+  warningCount: ComputedRef<number>
+  errorCount: ComputedRef<number>
+}
+
+/** Rule-driven validation state for WellPlate layout/design screens. */
+export function useWellPlateValidation<TContext, TType extends string = string>(
+  options: UseWellPlateValidationOptions<TContext, TType>,
+): UseWellPlateValidationReturn<TType> {
+  const warnings = computed(() => runWellPlateValidation(
+    toValue(options.context),
+    toValue(options.rules),
+  ))
+  const hasBlockingIssues = computed(() => warnings.value.some(warning => warning.severity === 'error'))
+  const warningCount = computed(() => warnings.value.length)
+  const errorCount = computed(() => warnings.value.filter(warning => warning.severity === 'error').length)
+
+  return {
+    warnings,
+    hasBlockingIssues,
+    warningCount,
+    errorCount,
+  }
+}
+
+export function runWellPlateValidation<TContext, TType extends string = string>(
+  context: TContext,
+  rules: readonly WellPlateValidationRule<TContext, TType>[],
+): WellPlateValidationWarning<TType>[] {
+  const warnings: WellPlateValidationWarning<TType>[] = []
+  for (const rule of rules) {
+    const result = rule.validate(context)
+    if (!result) continue
+    warnings.push(normalizeWarning(rule, result))
+  }
+  return warnings
+}
+
+function normalizeWarning<TContext, TType extends string>(
+  rule: WellPlateValidationRule<TContext, TType>,
+  result: string | Omit<WellPlateValidationWarning<TType>, 'type' | 'severity'>,
+): WellPlateValidationWarning<TType> {
+  if (typeof result === 'string') {
+    return {
+      type: rule.type,
+      severity: rule.severity,
+      message: result,
+    }
+  }
+  return {
+    type: rule.type,
+    severity: rule.severity,
+    ...result,
+  }
+}