@morscherlab/mint-sdk 1.0.0-rc.1 → 1.0.0-rc.4

package/src/templates/adapters.ts

@@ -1,845 +1,107 @@
+import type { Well } from '../types'
 import type {
-  DataFrameColumn,
-  PlateCondition,
-  PlateMapEditorState,
-  ProtocolStep,
-  ProtocolStepStatus,
-  ProtocolStepType,
-  ScheduleEvent,
-  ScheduleEventStatus,
-  SelectOption,
-  Well,
-} from '../types'
-import {
-  getTemplateData,
-  validateAssayMatrixData,
-  validateCalibrationCurveData,
-  validateDoseResponseData,
-  validateFlowCytometryPanelData,
-  validateInstrumentRunData,
-  validatePlateMapData,
-  validateProtocolStepsData,
-  validateQpcrPlateData,
-  validateReagentListData,
-  validateSamplePrepData,
-  validateSampleSheetData,
-  validateTimeCourseData,
-} from './builders'
-import type {
-  AssayMatrixColumnsAdapterResult,
-  AssayMatrixDataFrameAdapterResult,
-  AssayMatrixRowsAdapterResult,
-  AssayMatrixSampleOptionsAdapterResult,
   AssayMatrixTemplate,
-  AssayMatrixTemplateData,
   BioTemplateEnvelope,
-  CalibrationCurveColumnsAdapterResult,
-  CalibrationCurveDataFrameAdapterResult,
-  CalibrationCurveRowsAdapterResult,
   CalibrationCurveTemplate,
-  CalibrationCurveTemplateData,
   DataFrameTemplate,
-  DoseConditionsAdapterResult,
-  DoseResponseTemplate,
-  DoseResponseTemplateData,
   FlowCytometryPanelTemplate,
-  FlowCytometryPanelTemplateData,
-  FlowPanelColumnsAdapterResult,
-  FlowPanelDataFrameAdapterResult,
-  FlowPanelRowsAdapterResult,
-  InstrumentRunColumnsAdapterResult,
-  InstrumentRunDataFrameAdapterResult,
-  InstrumentRunRowsAdapterResult,
-  InstrumentRunScheduleEventsAdapterResult,
-  InstrumentRunStepsAdapterResult,
   InstrumentRunTemplate,
-  InstrumentRunTemplateData,
-  InstrumentRunItem,
-  InstrumentRunItemKind,
-  InstrumentRunStatus,
-  PlateMapEditorAdapterResult,
-  PlateMapTemplate,
-  PlateMapTemplateData,
-  ProtocolColumnsAdapterResult,
-  ProtocolDataFrameAdapterResult,
-  ProtocolRowsAdapterResult,
-  ProtocolStepsAdapterResult,
   ProtocolStepsTemplate,
-  ProtocolStepsTemplateData,
-  QpcrColumnsAdapterResult,
-  QpcrDataFrameAdapterResult,
   QpcrPlateTemplate,
-  QpcrPlateTemplateData,
-  QpcrRowsAdapterResult,
-  QpcrWellMapAdapterResult,
-  ReagentColumnsAdapterResult,
-  ReagentDataFrameAdapterResult,
-  ReagentListItemsAdapterResult,
   ReagentListTemplate,
-  ReagentListTemplateData,
-  ReagentRowsAdapterResult,
-  SampleColumnsAdapterResult,
-  SampleDataFrameAdapterResult,
-  SampleOptionsAdapterResult,
-  SamplePrepColumnsAdapterResult,
-  SamplePrepDataFrameAdapterResult,
-  SamplePrepRowsAdapterResult,
   SamplePrepTemplate,
-  SamplePrepTemplateData,
-  SampleRowsAdapterResult,
   SampleSheetTemplate,
-  SampleSheetTemplateData,
-  TimeCourseColumnsAdapterResult,
-  TimeCourseDataFrameAdapterResult,
-  TimeCourseRowsAdapterResult,
-  TimeCourseStepsAdapterResult,
   TimeCourseTemplate,
-  TimeCourseTemplateData,
   TemplateDataFrameAdapterResult,
-  WellMapAdapterResult,
 } from './types'
-
-const CONDITION_COLORS = [
-  '#3B82F6',
-  '#10B981',
-  '#EF4444',
-  '#F59E0B',
-  '#8B5CF6',
-  '#F97316',
-  '#06B6D4',
-  '#14B8A6',
-  '#6B7280',
-]
-
-export function toPlateMapEditorState(
-  template: PlateMapTemplate | PlateMapTemplateData
-): PlateMapEditorAdapterResult {
-  const data = getTemplateData(template, 'plate-map')
-  validatePlateMapData(data)
-  const activePlateId = data.activePlateId ?? data.plates[0].id
-  return {
-    plates: data.plates,
-    activePlateId,
-    samples: data.samples,
-    selectedWells: data.selectedWells ?? [],
-    activeSampleId: data.activeSampleId,
-  } satisfies PlateMapEditorState
-}
-
-export function toWellPlateWells(
-  template: PlateMapTemplate | PlateMapTemplateData,
-  plateId?: string
-): WellMapAdapterResult {
-  const state = toPlateMapEditorState(template)
-  const plate = state.plates.find(candidate => candidate.id === (plateId ?? state.activePlateId))
-    ?? state.plates[0]
-  return plate.wells
-}
-
-export function toSampleRows(
-  template: SampleSheetTemplate | SampleSheetTemplateData
-): SampleRowsAdapterResult {
-  const data = getTemplateData(template, 'sample-sheet')
-  validateSampleSheetData(data)
-  return data.samples.map(sample => ({
-    sampleId: sample.sampleId,
-    name: sample.name,
-    group: sample.group,
-    batch: sample.batch,
-    replicate: sample.replicate,
-    plateId: sample.plateId,
-    wellId: sample.wellId,
-    ...(sample.metadata ?? {}),
-  }))
-}
-
-export function toSampleColumns(
-  template: SampleSheetTemplate | SampleSheetTemplateData
-): SampleColumnsAdapterResult {
-  const data = getTemplateData(template, 'sample-sheet')
-  validateSampleSheetData(data)
-  return data.columns.map((column): DataFrameColumn<Record<string, unknown>> => ({
-    key: sampleColumnKey(column.id),
-    label: column.label,
-    sortable: true,
-    align: column.type === 'number' || column.type === 'integer' ? 'right' : 'left',
-  }))
-}
-
-export function toSampleDataFrame(
-  template: SampleSheetTemplate | SampleSheetTemplateData
-): SampleDataFrameAdapterResult {
-  return {
-    data: toSampleRows(template),
-    columns: toSampleColumns(template),
-    rowKey: 'sampleId',
-  }
-}
-
-export function toSampleOptions(
-  template: SampleSheetTemplate | SampleSheetTemplateData
-): SampleOptionsAdapterResult {
-  const data = getTemplateData(template, 'sample-sheet')
-  validateSampleSheetData(data)
-  return data.samples.map((sample): SelectOption<string> => ({
-    value: sample.sampleId,
-    label: sample.name ?? sample.sampleId,
-    description: [sample.group, sample.batch].filter(Boolean).join(' / ') || undefined,
-  }))
-}
-
-export function toSamplePrepRows(
-  template: SamplePrepTemplate | SamplePrepTemplateData
-): SamplePrepRowsAdapterResult {
-  const data = getTemplateData(template, 'sample-prep')
-  validateSamplePrepData(data)
-  return [...data.steps]
-    .sort((a, b) => a.order - b.order)
-    .map(step => ({
-      id: step.id,
-      order: step.order,
-      type: step.type,
-      name: step.name,
-      sourceSampleId: step.sourceSampleId,
-      sourceWellId: step.sourceWellId,
-      destinationSampleId: step.destinationSampleId,
-      destinationWellId: step.destinationWellId,
-      reagentId: step.reagentId,
-      inputVolume: step.inputVolume,
-      outputVolume: step.outputVolume,
-      volumeUnit: step.volumeUnit,
-      durationMin: step.durationMin,
-      status: step.status,
-      protocolName: data.protocolName,
-      ...(step.metadata ?? {}),
-    }))
-}
-
-export function toSamplePrepColumns(): SamplePrepColumnsAdapterResult {
-  return [
-    { key: 'order', label: 'Order', sortable: true, align: 'right' },
-    { key: 'type', label: 'Type', sortable: true },
-    { key: 'name', label: 'Step', sortable: true },
-    { key: 'sourceSampleId', label: 'Source', sortable: true },
-    { key: 'sourceWellId', label: 'Source well', sortable: true },
-    { key: 'destinationSampleId', label: 'Destination', sortable: true },
-    { key: 'destinationWellId', label: 'Destination well', sortable: true },
-    { key: 'reagentId', label: 'Reagent', sortable: true },
-    { key: 'inputVolume', label: 'Input', sortable: true, align: 'right' },
-    { key: 'outputVolume', label: 'Output', sortable: true, align: 'right' },
-    { key: 'volumeUnit', label: 'Unit', sortable: true },
-    { key: 'status', label: 'Status', sortable: true },
-  ]
-}
-
-export function toSamplePrepDataFrame(
-  template: SamplePrepTemplate | SamplePrepTemplateData
-): SamplePrepDataFrameAdapterResult {
-  return {
-    data: toSamplePrepRows(template),
-    columns: toSamplePrepColumns(),
-    rowKey: 'id',
-  }
-}
-
-export function toDoseConditions(
-  template: DoseResponseTemplate | DoseResponseTemplateData
-): DoseConditionsAdapterResult {
-  const data = getTemplateData(template, 'dose-response')
-  validateDoseResponseData(data)
-  return data.compounds.map((compound, index): PlateCondition => ({
-    label: compound.name,
-    color: String(compound.metadata?.color ?? CONDITION_COLORS[index % CONDITION_COLORS.length]),
-    concentrations: compound.concentrations,
-    unit: data.unit,
-  }))
-}
-
-export function toDoseLayoutState(
-  template: DoseResponseTemplate | DoseResponseTemplateData
-): PlateMapEditorState | undefined {
-  const data = getTemplateData(template, 'dose-response')
-  validateDoseResponseData(data)
-  return data.layout ? toPlateMapEditorState(data.layout) : undefined
-}
-
-export function toCalibrationCurveRows(
-  template: CalibrationCurveTemplate | CalibrationCurveTemplateData
-): CalibrationCurveRowsAdapterResult {
-  const data = getTemplateData(template, 'calibration-curve')
-  validateCalibrationCurveData(data)
-  return [...data.points]
-    .sort((a, b) => a.order - b.order)
-    .map(point => ({
-      id: point.id,
-      order: point.order,
-      role: point.role,
-      level: point.level,
-      concentration: point.concentration,
-      unit: point.unit,
-      expectedResponse: point.expectedResponse,
-      response: point.response,
-      replicate: point.replicate,
-      include: point.include,
-      status: point.status,
-      analyte: data.analyte,
-      model: data.model,
-      ...(point.metadata ?? {}),
-    }))
-}
-
-export function toCalibrationCurveColumns(): CalibrationCurveColumnsAdapterResult {
-  return [
-    { key: 'order', label: 'Order', sortable: true, align: 'right' },
-    { key: 'role', label: 'Role', sortable: true },
-    { key: 'level', label: 'Level', sortable: true },
-    { key: 'concentration', label: 'Concentration', sortable: true, align: 'right' },
-    { key: 'unit', label: 'Unit', sortable: true },
-    { key: 'expectedResponse', label: 'Expected', sortable: true, align: 'right' },
-    { key: 'response', label: 'Response', sortable: true, align: 'right' },
-    { key: 'replicate', label: 'Replicate', sortable: true, align: 'right' },
-    { key: 'include', label: 'Include', sortable: true },
-    { key: 'status', label: 'Status', sortable: true },
-  ]
-}
-
-export function toCalibrationCurveDataFrame(
-  template: CalibrationCurveTemplate | CalibrationCurveTemplateData
-): CalibrationCurveDataFrameAdapterResult {
-  return {
-    data: toCalibrationCurveRows(template),
-    columns: toCalibrationCurveColumns(),
-    rowKey: 'id',
-  }
-}
-
-export function toTimeCourseRows(
-  template: TimeCourseTemplate | TimeCourseTemplateData
-): TimeCourseRowsAdapterResult {
-  const data = getTemplateData(template, 'time-course')
-  validateTimeCourseData(data)
-  const timepoints = new Map(data.timepoints.map(timepoint => [timepoint.id, timepoint]))
-  const conditions = new Map(data.conditions.map(condition => [condition.id, condition]))
-
-  return data.samples.map(sample => {
-    const timepoint = timepoints.get(sample.timepointId)
-    const condition = conditions.get(sample.conditionId)
-    return {
-      sampleId: sample.sampleId,
-      condition: condition?.name ?? sample.conditionId,
-      timepoint: timepoint?.label ?? sample.timepointId,
-      value: timepoint?.value,
-      unit: timepoint?.unit,
-      replicate: sample.replicate,
-      ...(sample.metadata ?? {}),
-    }
-  })
-}
-
-export function toTimeCourseColumns(): TimeCourseColumnsAdapterResult {
-  return [
-    { key: 'sampleId', label: 'Sample ID', sortable: true },
-    { key: 'condition', label: 'Condition', sortable: true },
-    { key: 'timepoint', label: 'Time Point', sortable: true },
-    { key: 'value', label: 'Value', sortable: true, align: 'right' },
-    { key: 'unit', label: 'Unit', sortable: true },
-    { key: 'replicate', label: 'Replicate', sortable: true, align: 'right' },
-  ]
-}
-
-export function toTimeCourseDataFrame(
-  template: TimeCourseTemplate | TimeCourseTemplateData
-): TimeCourseDataFrameAdapterResult {
-  return {
-    data: toTimeCourseRows(template),
-    columns: toTimeCourseColumns(),
-    rowKey: 'sampleId',
-  }
-}
-
-export function toTimeCourseSteps(
-  template: TimeCourseTemplate | TimeCourseTemplateData
-): TimeCourseStepsAdapterResult {
-  const data = getTemplateData(template, 'time-course')
-  validateTimeCourseData(data)
-  return data.timepoints.map((timepoint, index) => ({
-    id: timepoint.id,
-    type: 'measurement',
-    name: timepoint.label,
-    description: `${data.conditions.length} condition${data.conditions.length === 1 ? '' : 's'}`,
-    status: 'pending',
-    order: index,
-    parameters: {
-      value: timepoint.value,
-      unit: timepoint.unit,
-    },
-  }))
-}
-
-export function toProtocolSteps(
-  template: ProtocolStepsTemplate | ProtocolStepsTemplateData
-): ProtocolStepsAdapterResult {
-  const data = getTemplateData(template, 'protocol-steps')
-  validateProtocolStepsData(data)
-  return [...data.steps]
-    .sort((a, b) => a.order - b.order)
-    .map(step => ({
-      id: step.id,
-      type: step.type,
-      name: step.name,
-      description: step.description,
-      duration: step.duration,
-      status: step.status,
-      parameters: step.parameters,
-      order: step.order,
-    }))
-}
-
-export function toProtocolRows(
-  template: ProtocolStepsTemplate | ProtocolStepsTemplateData
-): ProtocolRowsAdapterResult {
-  const data = getTemplateData(template, 'protocol-steps')
-  validateProtocolStepsData(data)
-  return [...data.steps]
-    .sort((a, b) => a.order - b.order)
-    .map(step => ({
-      id: step.id,
-      order: step.order,
-      type: step.type,
-      name: step.name,
-      description: step.description,
-      duration: step.duration,
-      status: step.status,
-      ...(step.metadata ?? {}),
-    }))
-}
-
-export function toProtocolColumns(): ProtocolColumnsAdapterResult {
-  return [
-    { key: 'order', label: 'Order', sortable: true, align: 'right' },
-    { key: 'name', label: 'Name', sortable: true },
-    { key: 'type', label: 'Type', sortable: true },
-    { key: 'duration', label: 'Duration', sortable: true, align: 'right' },
-    { key: 'status', label: 'Status', sortable: true },
-    { key: 'description', label: 'Description', sortable: true },
-  ]
-}
-
-export function toProtocolDataFrame(
-  template: ProtocolStepsTemplate | ProtocolStepsTemplateData
-): ProtocolDataFrameAdapterResult {
-  return {
-    data: toProtocolRows(template),
-    columns: toProtocolColumns(),
-    rowKey: 'id',
-  }
-}
-
-export function toAssayMatrixRows(
-  template: AssayMatrixTemplate | AssayMatrixTemplateData
-): AssayMatrixRowsAdapterResult {
-  const data = getTemplateData(template, 'assay-matrix')
-  validateAssayMatrixData(data)
-  const measurements = new Map(
-    data.measurements.map(measurement => [
-      `${measurement.sampleId}:${measurement.featureId}`,
-      measurement.value ?? null,
-    ])
-  )
-
-  return data.samples.map(sample => {
-    const row: Record<string, unknown> = {
-      sampleId: sample.sampleId,
-      name: sample.name,
-      group: sample.group,
-      ...(sample.metadata ?? {}),
-    }
-    for (const feature of data.features) {
-      row[feature.id] = measurements.get(`${sample.sampleId}:${feature.id}`) ?? null
-    }
-    return row
-  })
-}
-
-export function toAssayMatrixColumns(
-  template: AssayMatrixTemplate | AssayMatrixTemplateData
-): AssayMatrixColumnsAdapterResult {
-  const data = getTemplateData(template, 'assay-matrix')
-  validateAssayMatrixData(data)
-  return [
-    { key: 'sampleId', label: 'Sample ID', sortable: true },
-    { key: 'name', label: 'Name', sortable: true },
-    { key: 'group', label: 'Group', sortable: true },
-    ...data.features.map(feature => ({
-      key: feature.id,
-      label: feature.unit ? `${feature.name} (${feature.unit})` : feature.name,
-      sortable: true,
-      align: 'right' as const,
-    })),
-  ]
-}
-
-export function toAssayMatrixDataFrame(
-  template: AssayMatrixTemplate | AssayMatrixTemplateData
-): AssayMatrixDataFrameAdapterResult {
-  return {
-    data: toAssayMatrixRows(template),
-    columns: toAssayMatrixColumns(template),
-    rowKey: 'sampleId',
-  }
-}
-
-/** Convert an assay-matrix template into SampleSelector options derived from assay samples. */
-export function toAssayMatrixSampleOptions(
-  template: AssayMatrixTemplate | AssayMatrixTemplateData
-): AssayMatrixSampleOptionsAdapterResult {
-  const data = getTemplateData(template, 'assay-matrix')
-  validateAssayMatrixData(data)
-  return data.samples.map((sample): SelectOption<string> => ({
-    value: sample.sampleId,
-    label: sample.name ?? sample.sampleId,
-    description: sample.group,
-  }))
-}
-
-export function toReagentListItems(
-  template: ReagentListTemplate | ReagentListTemplateData
-): ReagentListItemsAdapterResult {
-  const data = getTemplateData(template, 'reagent-list')
-  validateReagentListData(data)
-  return data.reagents.map(reagent => ({
-    id: reagent.id,
-    name: reagent.name,
-    catalogNumber: reagent.catalogNumber,
-    lotNumber: reagent.lotNumber,
-    expiryDate: reagent.expiryDate,
-    storageCondition: reagent.storageCondition,
-    location: reagent.location,
-    stockLevel: reagent.stockLevel,
-    stockUnit: reagent.stockUnit,
-    supplier: reagent.supplier,
-    url: reagent.url,
-  }))
-}
-
-export function toReagentRows(
-  template: ReagentListTemplate | ReagentListTemplateData
-): ReagentRowsAdapterResult {
-  const data = getTemplateData(template, 'reagent-list')
-  validateReagentListData(data)
-  return data.reagents.map(reagent => ({
-    id: reagent.id,
-    name: reagent.name,
-    kind: reagent.kind,
-    catalogNumber: reagent.catalogNumber,
-    lotNumber: reagent.lotNumber,
-    expiryDate: reagent.expiryDate,
-    storageCondition: reagent.storageCondition,
-    location: reagent.location,
-    stockLevel: reagent.stockLevel,
-    stockUnit: reagent.stockUnit,
-    supplier: reagent.supplier,
-    concentration: reagent.concentration,
-    ...(reagent.metadata ?? {}),
-  }))
-}
-
-export function toReagentColumns(): ReagentColumnsAdapterResult {
-  return [
-    { key: 'name', label: 'Name', sortable: true },
-    { key: 'kind', label: 'Kind', sortable: true },
-    { key: 'catalogNumber', label: 'Catalog', sortable: true },
-    { key: 'lotNumber', label: 'Lot', sortable: true },
-    { key: 'expiryDate', label: 'Expiry', sortable: true },
-    { key: 'storageCondition', label: 'Storage', sortable: true },
-    { key: 'location', label: 'Location', sortable: true },
-    { key: 'stockLevel', label: 'Stock', sortable: true, align: 'right' },
-    { key: 'stockUnit', label: 'Unit', sortable: true },
-    { key: 'supplier', label: 'Supplier', sortable: true },
-  ]
-}
-
-export function toReagentDataFrame(
-  template: ReagentListTemplate | ReagentListTemplateData
-): ReagentDataFrameAdapterResult {
-  return {
-    data: toReagentRows(template),
-    columns: toReagentColumns(),
-    rowKey: 'id',
-  }
-}
-
-export function toFlowPanelRows(
-  template: FlowCytometryPanelTemplate | FlowCytometryPanelTemplateData
-): FlowPanelRowsAdapterResult {
-  const data = getTemplateData(template, 'flow-cytometry-panel')
-  validateFlowCytometryPanelData(data)
-  return data.markers.map(marker => {
-    const markerControls = data.controls
-      .filter(control => control.markerId === marker.id)
-      .map(control => control.name)
-      .join(', ')
-    return {
-      id: marker.id,
-      marker: marker.marker,
-      fluorophore: marker.fluorophore,
-      detector: marker.detector,
-      clone: marker.clone,
-      reagentId: marker.reagentId,
-      purpose: marker.purpose,
-      compensationRequired: marker.compensationRequired,
-      controls: markerControls,
-      instrument: data.instrument,
-      ...(marker.metadata ?? {}),
-    }
-  })
-}
-
-export function toFlowPanelColumns(): FlowPanelColumnsAdapterResult {
-  return [
-    { key: 'marker', label: 'Marker', sortable: true },
-    { key: 'fluorophore', label: 'Fluorophore', sortable: true },
-    { key: 'detector', label: 'Detector', sortable: true },
-    { key: 'clone', label: 'Clone', sortable: true },
-    { key: 'purpose', label: 'Purpose', sortable: true },
-    { key: 'compensationRequired', label: 'Compensation', sortable: true },
-    { key: 'controls', label: 'Controls' },
-    { key: 'instrument', label: 'Instrument', sortable: true },
-  ]
-}
-
-export function toFlowPanelDataFrame(
-  template: FlowCytometryPanelTemplate | FlowCytometryPanelTemplateData
-): FlowPanelDataFrameAdapterResult {
-  return {
-    data: toFlowPanelRows(template),
-    columns: toFlowPanelColumns(),
-    rowKey: 'id',
-  }
-}
-
-export function toInstrumentRunRows(
-  template: InstrumentRunTemplate | InstrumentRunTemplateData
-): InstrumentRunRowsAdapterResult {
-  const data = getTemplateData(template, 'instrument-run')
-  validateInstrumentRunData(data)
-  const methods = new Map(data.methods.map(method => [method.id, method]))
-  return [...data.items]
-    .sort((a, b) => a.order - b.order)
-    .map(item => {
-      const method = methods.get(item.methodId)
-      return {
-        id: item.id,
-        order: item.order,
-        kind: item.kind,
-        sampleId: item.sampleId,
-        name: item.name ?? item.sampleId ?? item.kind,
-        method: method?.name ?? item.methodId,
-        vial: item.vial,
-        plateId: item.plateId,
-        wellId: item.wellId,
-        injectionVolume: item.injectionVolume,
-        expectedDurationMin: item.expectedDurationMin,
-        status: item.status,
-        instrument: data.instrument ?? method?.instrument,
-        ...(item.metadata ?? {}),
-      }
-    })
-}
-
-export function toInstrumentRunColumns(): InstrumentRunColumnsAdapterResult {
-  return [
-    { key: 'order', label: 'Order', sortable: true, align: 'right' },
-    { key: 'kind', label: 'Kind', sortable: true },
-    { key: 'sampleId', label: 'Sample ID', sortable: true },
-    { key: 'name', label: 'Name', sortable: true },
-    { key: 'method', label: 'Method', sortable: true },
-    { key: 'vial', label: 'Vial', sortable: true },
-    { key: 'wellId', label: 'Well', sortable: true },
-    { key: 'injectionVolume', label: 'Injection', sortable: true, align: 'right' },
-    { key: 'expectedDurationMin', label: 'Duration', sortable: true, align: 'right' },
-    { key: 'status', label: 'Status', sortable: true },
-    { key: 'instrument', label: 'Instrument', sortable: true },
-  ]
-}
-
-export function toInstrumentRunDataFrame(
-  template: InstrumentRunTemplate | InstrumentRunTemplateData
-): InstrumentRunDataFrameAdapterResult {
-  return {
-    data: toInstrumentRunRows(template),
-    columns: toInstrumentRunColumns(),
-    rowKey: 'id',
-  }
-}
-
-/** Convert an instrument-run template into ExperimentTimeline protocol steps for acquisition queue previews. */
-export function toInstrumentRunSteps(
-  template: InstrumentRunTemplate | InstrumentRunTemplateData
-): InstrumentRunStepsAdapterResult {
-  const data = getTemplateData(template, 'instrument-run')
-  validateInstrumentRunData(data)
-  const methods = new Map(data.methods.map(method => [method.id, method]))
-  return [...data.items]
-    .sort((a, b) => a.order - b.order)
-    .map((item): ProtocolStep => {
-      const method = methods.get(item.methodId)
-      const name = item.name ?? item.sampleId ?? item.kind
-      return {
-        id: item.id,
-        type: instrumentRunStepType(item.kind),
-        name,
-        description: [
-          item.kind,
-          method?.name,
-          item.vial ? `Vial ${item.vial}` : undefined,
-          item.wellId ? `Well ${item.wellId}` : undefined,
-        ]
-          .filter(Boolean)
-          .join(' / '),
-        duration: item.expectedDurationMin,
-        status: instrumentRunStepStatus(item.status),
-        parameters: {
-          kind: item.kind,
-          sampleId: item.sampleId,
-          methodId: item.methodId,
-          method: method?.name,
-          vial: item.vial,
-          plateId: item.plateId,
-          wellId: item.wellId,
-          injectionVolume: item.injectionVolume,
-          instrument: data.instrument ?? method?.instrument,
-        },
-        order: item.order,
-      }
-    })
-}
-
-/** Convert an instrument-run template into readonly ScheduleCalendar events ordered by run queue timing. */
-export function toInstrumentRunScheduleEvents(
-  template: InstrumentRunTemplate | InstrumentRunTemplateData
-): InstrumentRunScheduleEventsAdapterResult {
-  const data = getTemplateData(template, 'instrument-run')
-  validateInstrumentRunData(data)
-  const methods = new Map(data.methods.map(method => [method.id, method]))
-  let cursor = dateFromMetadata(data.metadata, ['scheduledStart', 'runStart', 'start', 'startedAt'])
-    ?? new Date('2024-01-01T08:00:00.000Z')
-
-  return [...data.items]
-    .sort((a, b) => a.order - b.order)
-    .map((item): ScheduleEvent => {
-      const method = methods.get(item.methodId)
-      const start = dateFromMetadata(item.metadata, ['scheduledStart', 'start', 'startedAt']) ?? cursor
-      const end = dateFromMetadata(item.metadata, ['scheduledEnd', 'end', 'completedAt'])
-        ?? addMinutes(start, Math.max(item.expectedDurationMin ?? 10, 1))
-      cursor = end
-
-      return {
-        id: item.id,
-        title: item.name ?? item.sampleId ?? item.kind,
-        start: start.toISOString(),
-        end: end.toISOString(),
-        color: instrumentRunScheduleColor(item.kind),
-        status: instrumentRunScheduleStatus(item.status),
-        draggable: false,
-        resizable: false,
-        metadata: {
-          kind: item.kind,
-          sampleId: item.sampleId,
-          methodId: item.methodId,
-          method: method?.name,
-          vial: item.vial,
-          plateId: item.plateId,
-          wellId: item.wellId,
-          injectionVolume: item.injectionVolume,
-          instrument: data.instrument ?? method?.instrument,
-        },
-      }
-    })
-}
-
-export function toQpcrRows(
-  template: QpcrPlateTemplate | QpcrPlateTemplateData
-): QpcrRowsAdapterResult {
-  const data = getTemplateData(template, 'qpcr-plate')
-  validateQpcrPlateData(data)
-  const samples = new Map(data.samples.map(sample => [sample.sampleId, sample]))
-  const targets = new Map(data.targets.map(target => [target.id, target]))
-
-  return data.reactions.map(reaction => {
-    const sample = reaction.sampleId ? samples.get(reaction.sampleId) : undefined
-    const target = targets.get(reaction.targetId)
-    return {
-      id: reaction.id,
-      wellId: reaction.wellId,
-      sampleId: reaction.sampleId,
-      sample: sample?.name ?? reaction.sampleId ?? reaction.controlKind,
-      group: sample?.group,
-      targetId: reaction.targetId,
-      target: target?.name ?? reaction.targetId,
-      replicate: reaction.replicate,
-      controlKind: reaction.controlKind,
-      cq: reaction.cq ?? null,
-      quantity: reaction.quantity ?? null,
-      flags: reaction.flags.join(', '),
-      instrument: data.instrument,
-      chemistry: data.chemistry,
-      ...(reaction.metadata ?? {}),
-    }
-  })
-}
-
-export function toQpcrColumns(): QpcrColumnsAdapterResult {
-  return [
-    { key: 'wellId', label: 'Well', sortable: true },
-    { key: 'sample', label: 'Sample', sortable: true },
-    { key: 'group', label: 'Group', sortable: true },
-    { key: 'target', label: 'Target', sortable: true },
-    { key: 'replicate', label: 'Replicate', sortable: true, align: 'right' },
-    { key: 'controlKind', label: 'Control', sortable: true },
-    { key: 'cq', label: 'Cq', sortable: true, align: 'right' },
-    { key: 'quantity', label: 'Quantity', sortable: true, align: 'right' },
-    { key: 'flags', label: 'Flags' },
-  ]
-}
-
-export function toQpcrDataFrame(
-  template: QpcrPlateTemplate | QpcrPlateTemplateData
-): QpcrDataFrameAdapterResult {
-  return {
-    data: toQpcrRows(template),
-    columns: toQpcrColumns(),
-    rowKey: 'id',
-  }
-}
-
-export function toQpcrWellPlateWells(
-  template: QpcrPlateTemplate | QpcrPlateTemplateData
-): QpcrWellMapAdapterResult {
-  const data = getTemplateData(template, 'qpcr-plate')
-  validateQpcrPlateData(data)
-  return Object.fromEntries(data.reactions.map(reaction => {
-    const [row, col] = wellPositionFromId(reaction.wellId)
-    return [
-      reaction.wellId,
-      {
-        id: reaction.wellId,
-        row,
-        col,
-        state: 'filled' as const,
-        sampleType: reaction.sampleId ?? reaction.controlKind,
-        value: reaction.cq ?? undefined,
-        metadata: {
-          reactionId: reaction.id,
-          sampleId: reaction.sampleId,
-          targetId: reaction.targetId,
-          replicate: reaction.replicate,
-          controlKind: reaction.controlKind,
-        },
-      } satisfies Well,
-    ]
-  }))
-}
+import { toAssayMatrixDataFrame } from './assayMatrixAdapters'
+import { toCalibrationCurveDataFrame } from './calibrationCurveAdapters'
+import { toFlowPanelDataFrame } from './flowPanelAdapters'
+import { toInstrumentRunDataFrame } from './instrumentRunAdapters'
+import { toProtocolDataFrame } from './protocolAdapters'
+import { toQpcrDataFrame } from './qpcrAdapters'
+import { toReagentDataFrame } from './reagentAdapters'
+import { toSamplePrepDataFrame } from './samplePrepAdapters'
+import { toSampleDataFrame } from './sampleSheetAdapters'
+import { toTimeCourseDataFrame } from './timeCourseAdapters'
+
+export {
+  toAssayMatrixColumns,
+  toAssayMatrixDataFrame,
+  toAssayMatrixRows,
+  toAssayMatrixSampleOptions,
+} from './assayMatrixAdapters'
+
+export {
+  toCalibrationCurveColumns,
+  toCalibrationCurveDataFrame,
+  toCalibrationCurveRows,
+} from './calibrationCurveAdapters'
+
+export {
+  toDoseConditions,
+  toDoseLayoutState,
+} from './doseResponseAdapters'
+
+export {
+  toFlowPanelColumns,
+  toFlowPanelDataFrame,
+  toFlowPanelRows,
+} from './flowPanelAdapters'
+
+export {
+  toInstrumentRunColumns,
+  toInstrumentRunDataFrame,
+  toInstrumentRunRows,
+  toInstrumentRunScheduleEvents,
+  toInstrumentRunSteps,
+} from './instrumentRunAdapters'
+
+export {
+  toPlateMapEditorState,
+  toWellPlateWells,
+} from './plateMapAdapters'
+
+export {
+  toProtocolColumns,
+  toProtocolDataFrame,
+  toProtocolRows,
+  toProtocolSteps,
+} from './protocolAdapters'
+
+export {
+  toQpcrColumns,
+  toQpcrDataFrame,
+  toQpcrRows,
+  toQpcrWellPlateWells,
+} from './qpcrAdapters'
+
+export {
+  toReagentColumns,
+  toReagentDataFrame,
+  toReagentListItems,
+  toReagentRows,
+} from './reagentAdapters'
+
+export {
+  toSamplePrepColumns,
+  toSamplePrepDataFrame,
+  toSamplePrepRows,
+} from './samplePrepAdapters'
+
+export {
+  toSampleColumns,
+  toSampleDataFrame,
+  toSampleOptions,
+  toSampleRows,
+} from './sampleSheetAdapters'
+
+export {
+  toTimeCourseColumns,
+  toTimeCourseDataFrame,
+  toTimeCourseRows,
+  toTimeCourseSteps,
+} from './timeCourseAdapters'
 
 export function toTemplateDataFrame(
   template: DataFrameTemplate | BioTemplateEnvelope<unknown>
@@ -873,106 +135,3 @@ export function toTemplateDataFrame(
 export function toWellMapArray(wells: Record<string, Well>): Well[] {
   return Object.values(wells)
 }
-
-function wellPositionFromId(wellId: string): [number, number] {
-  const match = /^([A-Z]+)([1-9][0-9]*)$/.exec(wellId.toUpperCase())
-  if (!match) {
-    throw new Error(`Invalid well id '${wellId}'.`)
-  }
-  const row = [...match[1]].reduce((value, char) => value * 26 + char.charCodeAt(0) - 64, 0) - 1
-  const col = Number(match[2]) - 1
-  return [row, col]
-}
-
-function sampleColumnKey(columnId: string): string {
-  const aliases: Record<string, string> = {
-    sample_id: 'sampleId',
-    plate_id: 'plateId',
-    well_id: 'wellId',
-  }
-  return aliases[columnId] ?? columnId
-}
-
-function instrumentRunStepType(kind: InstrumentRunItemKind): ProtocolStepType {
-  switch (kind) {
-    case 'wash':
-      return 'wash'
-    case 'blank':
-    case 'qc':
-    case 'standard':
-    case 'calibration':
-    case 'sample':
-      return 'measurement'
-    default:
-      return 'custom'
-  }
-}
-
-function instrumentRunStepStatus(status: InstrumentRunStatus): ProtocolStepStatus {
-  switch (status) {
-    case 'running':
-      return 'in_progress'
-    case 'completed':
-      return 'completed'
-    case 'failed':
-      return 'failed'
-    case 'skipped':
-      return 'skipped'
-    case 'planned':
-    case 'queued':
-    default:
-      return 'pending'
-  }
-}
-
-function instrumentRunScheduleStatus(status: InstrumentRunStatus): ScheduleEventStatus {
-  switch (status) {
-    case 'running':
-      return 'in-progress'
-    case 'completed':
-      return 'confirmed'
-    case 'failed':
-    case 'skipped':
-      return 'cancelled'
-    case 'planned':
-    case 'queued':
-    default:
-      return 'pending'
-  }
-}
-
-function instrumentRunScheduleColor(kind: InstrumentRunItem['kind']): string {
-  switch (kind) {
-    case 'blank':
-      return '#64748b'
-    case 'qc':
-      return '#8b5cf6'
-    case 'standard':
-    case 'calibration':
-      return '#f59e0b'
-    case 'wash':
-      return '#06b6d4'
-    case 'sample':
-      return '#2563eb'
-    default:
-      return '#475569'
-  }
-}
-
-function dateFromMetadata(
-  metadata: Record<string, unknown> | undefined,
-  keys: readonly string[]
-): Date | undefined {
-  if (!metadata) return undefined
-  for (const key of keys) {
-    const value = metadata[key]
-    if (!(typeof value === 'string' || value instanceof Date)) continue
-    const date = new Date(value)
-    if (!Number.isNaN(date.getTime())) return date
-  }
-  return undefined
-}
-
-function addMinutes(date: Date, minutes: number): Date {
-  return new Date(date.getTime() + minutes * 60_000)
-}