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

package/src/templates/presetControlSchemas.ts

@@ -1,258 +0,0 @@
-import {
-  CONCENTRATION_UNITS,
-  ICONS,
-  PLATE_FORMAT_OPTIONS,
-} from './controlSchemaConstants'
-import type {
-  BioTemplateControlSchema,
-} from './controlSchemaTypes'
-import {
-  templateControlSchemas,
-} from './templateControlSchemas'
-import type {
-  TemplatePresetId,
-} from './types'
-
-export const presetControlSchemas = {
-  'wellplate-screen': {
-    ...templateControlSchemas['plate-map'],
-    ...templateControlSchemas['dose-response'],
-    sampleNames: {
-      ...templateControlSchemas['plate-map'].sampleNames,
-      default: ['Control', 'Treatment'],
-    },
-  },
-  'qpcr-expression': {
-    sampleNames: {
-      type: 'tags',
-      label: 'Samples',
-      default: ['Control', 'Treatment'],
-      section: 'samples',
-      sectionLabel: 'Samples',
-      sectionSubtitle: 'Expression groups',
-      view: 'design',
-      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
-    },
-    targets: {
-      type: 'tags',
-      label: 'Targets',
-      default: ['ACTB', 'GAPDH'],
-      section: 'assay',
-      sectionLabel: 'Assay',
-      view: 'design',
-      sidebar: { icon: ICONS.plate, iconColor: '#6366f1', iconBg: '#e0e7ff' },
-    },
-    ...templateControlSchemas['qpcr-plate'],
-  },
-  'lcms-batch': {
-    sampleNames: {
-      type: 'tags',
-      label: 'Samples',
-      default: ['S001', 'S002'],
-      section: 'samples',
-      sectionLabel: 'Samples',
-      sectionSubtitle: 'Batch samples',
-      view: 'run',
-      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
-    },
-    featureNames: {
-      type: 'tags',
-      label: 'Features',
-      default: ['Glucose', 'Lactate'],
-      section: 'features',
-      sectionLabel: 'Features',
-      view: 'analysis',
-      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
-    },
-    ...templateControlSchemas['instrument-run'],
-    ...templateControlSchemas['assay-matrix'],
-  },
-  'targeted-metabolomics': {
-    sampleNames: {
-      type: 'tags',
-      label: 'Samples',
-      default: ['S001', 'S002'],
-      section: 'samples',
-      sectionLabel: 'Samples',
-      sectionSubtitle: 'Unknowns and QC pool',
-      view: 'run',
-      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
-    },
-    metaboliteNames: {
-      type: 'tags',
-      label: 'Metabolites',
-      default: ['Glucose', 'Lactate', 'Pyruvate'],
-      section: 'features',
-      sectionLabel: 'Metabolites',
-      sectionSubtitle: 'Quantitation panel',
-      view: 'analysis',
-      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
-    },
-    internalStandards: {
-      type: 'tags',
-      label: 'Internal standards',
-      default: ['Stable isotope internal standard mix'],
-      section: 'standards',
-      sectionLabel: 'Standards',
-      sectionSubtitle: 'Calibration and internal standards',
-      view: 'analysis',
-      sidebar: { icon: ICONS.dose, iconColor: '#8b5cf6', iconBg: '#ede9fe' },
-    },
-    standardConcentrations: {
-      type: 'tags',
-      label: 'Calibration levels',
-      default: ['0.1', '1', '10', '100'],
-      section: 'standards',
-      view: 'analysis',
-    },
-    concentrationUnit: {
-      label: 'Concentration unit',
-      default: 'uM',
-      options: CONCENTRATION_UNITS,
-      section: 'standards',
-      view: 'analysis',
-    },
-    responseUnit: {
-      label: 'Response unit',
-      default: 'peak area ratio',
-      section: 'readout',
-      sectionLabel: 'Readout',
-      view: 'analysis',
-      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
-    },
-    instrument: {
-      ...templateControlSchemas['instrument-run'].instrument,
-      default: 'LC-MS',
-    },
-    method: {
-      ...templateControlSchemas['instrument-run'].method,
-      default: 'Targeted metabolomics',
-    },
-    prepType: {
-      ...templateControlSchemas['sample-prep'].prepType,
-      default: 'extraction',
-    },
-    outputVolume: templateControlSchemas['sample-prep'].outputVolume,
-    includeQc: templateControlSchemas['instrument-run'].includeQc,
-  },
-  'elisa-assay': {
-    sampleNames: {
-      type: 'tags',
-      label: 'Samples',
-      default: ['Control', 'Treatment'],
-      section: 'samples',
-      sectionLabel: 'Samples',
-      sectionSubtitle: 'Unknowns and controls',
-      view: 'design',
-      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
-    },
-    analyte: {
-      label: 'Analyte',
-      default: 'Analyte',
-      section: 'standards',
-      sectionLabel: 'Standards',
-      sectionSubtitle: 'Calibration setup',
-      view: 'analysis',
-      sidebar: { icon: ICONS.dose, iconColor: '#8b5cf6', iconBg: '#ede9fe' },
-    },
-    standardConcentrations: {
-      type: 'tags',
-      label: 'Standards',
-      default: ['1000', '100', '10', '1'],
-      section: 'standards',
-      view: 'analysis',
-    },
-    unit: {
-      label: 'Concentration unit',
-      default: 'pg/mL',
-      options: ['pg/mL', 'ng/mL', 'ug/mL', 'nM', 'uM'],
-      section: 'standards',
-      view: 'analysis',
-    },
-    responseUnit: {
-      label: 'Response unit',
-      default: 'OD450',
-      section: 'readout',
-      sectionLabel: 'Readout',
-      view: 'analysis',
-      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
-    },
-    plateName: {
-      label: 'Plate name',
-      default: 'ELISA plate',
-      section: 'layout',
-      sectionLabel: 'Layout',
-      sectionSubtitle: 'Plate geometry',
-      view: 'design',
-      sidebar: { icon: ICONS.plate, iconColor: '#6366f1', iconBg: '#e0e7ff' },
-    },
-    plateFormat: {
-      label: 'Format',
-      default: 96,
-      options: PLATE_FORMAT_OPTIONS,
-      section: 'layout',
-      view: 'design',
-    },
-  },
-  'flow-cytometry-assay': {
-    sampleNames: {
-      type: 'tags',
-      label: 'Samples',
-      default: ['Control', 'Treatment'],
-      section: 'samples',
-      sectionLabel: 'Samples',
-      sectionSubtitle: 'Assay groups',
-      view: 'design',
-      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
-    },
-    markers: {
-      ...templateControlSchemas['flow-cytometry-panel'].markers,
-      default: ['CD3', 'CD4', 'CD8'],
-    },
-    featureNames: {
-      type: 'tags',
-      label: 'Readouts',
-      default: ['CD3+ cells', 'CD4+ cells', 'CD8+ cells'],
-      section: 'features',
-      sectionLabel: 'Readouts',
-      sectionSubtitle: 'Assay matrix columns',
-      view: 'analysis',
-      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
-    },
-    instrument: {
-      ...templateControlSchemas['flow-cytometry-panel'].instrument,
-      default: 'Flow cytometer',
-    },
-    includeDefaultControls: templateControlSchemas['flow-cytometry-panel'].includeDefaultControls,
-  },
-  'western-blot-assay': {
-    sampleNames: {
-      type: 'tags',
-      label: 'Samples',
-      default: ['Control', 'Treatment'],
-      section: 'samples',
-      sectionLabel: 'Samples',
-      sectionSubtitle: 'Blot lanes and groups',
-      view: 'design',
-      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
-    },
-    targets: {
-      type: 'tags',
-      label: 'Targets',
-      default: ['Target protein'],
-      section: 'assay',
-      sectionLabel: 'Assay',
-      sectionSubtitle: 'Protein targets',
-      view: 'design',
-      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
-    },
-    loadingControl: {
-      label: 'Loading control',
-      default: 'ACTB',
-      section: 'normalization',
-      sectionLabel: 'Normalization',
-      view: 'analysis',
-      sidebar: { icon: ICONS.settings, iconColor: '#6366f1', iconBg: '#e0e7ff' },
-    },
-  },
-} satisfies Record<TemplatePresetId, BioTemplateControlSchema>

package/src/templates/presets.ts

@@ -1,179 +0,0 @@
-import type { TemplateId, TemplatePresetId } from './types'
-
-import { templateIdentifierMatches, templateSearchMatches } from './lookup'
-
-export interface BioTemplatePresetEntry {
-  name: TemplatePresetId
-  label: string
-  category: 'bio-template-preset'
-  purpose: string
-  templates: readonly TemplateId[]
-  aliases: readonly string[]
-  python_import: string
-  python_example: string
-  frontend_import: string
-  frontend_adapters: readonly string[]
-  components: readonly string[]
-}
-
-export const bioTemplatePresets = [
-  {
-    name: 'wellplate-screen',
-    label: 'Well-plate screen',
-    category: 'bio-template-preset',
-    purpose: 'Plate map, sample sheet, and dose-response payloads for plate-based screening assays.',
-    templates: ['plate-map', 'sample-sheet', 'dose-response'],
-    aliases: [
-      'wellplate',
-      'well-plate screen',
-      'drug screen',
-      'plate screen',
-      'dose response plate',
-      'dose design',
-      'dose planner',
-    ],
-    python_import: 'from mint_sdk.templates import create_wellplate_screen_collection, save_template_collection',
-    python_example: 'create_wellplate_screen_collection(samples=["Control", "Treatment"], compounds={"Drug A": [10, 1, 0.1]}, unit="uM")',
-    frontend_import: "import { createWellPlateScreenCollection, toPlateMapEditorState, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toPlateMapEditorState', 'toTemplateDataFrame', 'toDoseConditions'],
-    components: ['PlateMapEditor', 'WellPlate', 'DataFrame', 'DoseCalculator'],
-  },
-  {
-    name: 'qpcr-expression',
-    label: 'qPCR expression',
-    category: 'bio-template-preset',
-    purpose: 'Sample metadata and qPCR/ddPCR plate layout for target-expression assays.',
-    templates: ['sample-sheet', 'qpcr-plate'],
-    aliases: ['qpcr', 'qPCR', 'rt-qpcr', 'ddpcr', 'gene expression', 'primer plate'],
-    python_import: 'from mint_sdk.templates import create_qpcr_expression_collection, save_template_collection',
-    python_example: 'create_qpcr_expression_collection(samples=["Control", "Treatment"], targets=["ACTB", "GAPDH"], replicates=3)',
-    frontend_import: "import { createQpcrExpressionCollection, toQpcrWellPlateWells, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toQpcrDataFrame', 'toQpcrWellPlateWells'],
-    components: ['DataFrame', 'WellPlate', 'SampleSelector'],
-  },
-  {
-    name: 'lcms-batch',
-    label: 'LC-MS batch',
-    category: 'bio-template-preset',
-    purpose: 'Sample metadata, instrument queue, and assay matrix payloads for omics acquisition batches.',
-    templates: ['sample-sheet', 'instrument-run', 'assay-matrix'],
-    aliases: [
-      'lcms',
-      'lc-ms',
-      'mass spec batch',
-      'omics batch',
-      'metabolomics',
-      'metabolism',
-      'metabolite profiling',
-      'run queue',
-      'sequence table',
-    ],
-    python_import: 'from mint_sdk.templates import create_lcms_batch_collection, save_template_collection',
-    python_example: 'create_lcms_batch_collection(samples=["S001", "S002"], features=["Glucose", "Lactate"], instrument="LC-MS")',
-    frontend_import: "import { createLcmsBatchCollection, toAssayMatrixSampleOptions, toInstrumentRunDataFrame, toInstrumentRunScheduleEvents, toInstrumentRunSteps, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toInstrumentRunDataFrame', 'toInstrumentRunSteps', 'toInstrumentRunScheduleEvents', 'toAssayMatrixDataFrame', 'toAssayMatrixSampleOptions'],
-    components: ['DataFrame', 'ExperimentTimeline', 'ScheduleCalendar', 'ChartContainer', 'SampleSelector'],
-  },
-  {
-    name: 'targeted-metabolomics',
-    label: 'Targeted metabolomics',
-    category: 'bio-template-preset',
-    purpose: 'Sample metadata, extraction prep, internal standards, LC/GC-MS sequence, calibration curve, and metabolite readout matrix for quantitative metabolomics.',
-    templates: ['sample-sheet', 'sample-prep', 'reagent-list', 'instrument-run', 'calibration-curve', 'assay-matrix'],
-    aliases: [
-      'targeted metabolomics',
-      'quantitative metabolomics',
-      'lc-ms metabolomics',
-      'gc-ms metabolomics',
-      'targeted lcms',
-      'metabolite quantitation',
-      'mass spec quantitation',
-      'internal standards',
-      'peak area ratio',
-    ],
-    python_import: 'from mint_sdk.templates import create_targeted_metabolomics_collection, save_template_collection',
-    python_example: 'create_targeted_metabolomics_collection(samples=["S001", "S002"], metabolites=["Glucose", "Lactate"], internal_standards=["13C Glucose"], instrument="LC-MS")',
-    frontend_import: "import { createTargetedMetabolomicsCollection, toInstrumentRunDataFrame, toCalibrationCurveDataFrame, toAssayMatrixDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toSamplePrepDataFrame', 'toReagentDataFrame', 'toInstrumentRunDataFrame', 'toInstrumentRunSteps', 'toInstrumentRunScheduleEvents', 'toCalibrationCurveDataFrame', 'toAssayMatrixDataFrame', 'toAssayMatrixSampleOptions'],
-    components: ['DataFrame', 'ReagentList', 'ExperimentTimeline', 'ScheduleCalendar', 'FitPanel', 'ChartContainer', 'SampleSelector'],
-  },
-  {
-    name: 'elisa-assay',
-    label: 'ELISA assay',
-    category: 'bio-template-preset',
-    purpose: 'Plate layout, sample metadata, standard curve, and readout matrix for ELISA and plate-reader assays.',
-    templates: ['plate-map', 'sample-sheet', 'calibration-curve', 'assay-matrix'],
-    aliases: ['elisa', 'plate reader assay', 'standard curve plate', 'absorbance assay', 'immunoassay'],
-    python_import: 'from mint_sdk.templates import create_elisa_assay_collection, save_template_collection',
-    python_example: 'create_elisa_assay_collection(samples=["Control", "Treatment"], analyte="IL-6", standard_concentrations=[1000, 100, 10, 1], unit="pg/mL")',
-    frontend_import: "import { createElisaAssayCollection, toPlateMapEditorState, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toPlateMapEditorState', 'toTemplateDataFrame', 'toCalibrationCurveDataFrame'],
-    components: ['PlateMapEditor', 'WellPlate', 'DataFrame', 'FitPanel', 'ChartContainer'],
-  },
-  {
-    name: 'flow-cytometry-assay',
-    label: 'Flow cytometry assay',
-    category: 'bio-template-preset',
-    purpose: 'Sample metadata, antibody marker panel, compensation controls, and readout matrix for flow-cytometry assays.',
-    templates: ['sample-sheet', 'flow-cytometry-panel', 'assay-matrix'],
-    aliases: [
-      'flow cytometry',
-      'facs',
-      'facs panel',
-      'flow panel',
-      'immune phenotyping',
-      'immunophenotyping',
-    ],
-    python_import: 'from mint_sdk.templates import create_flow_cytometry_assay_collection, save_template_collection',
-    python_example: 'create_flow_cytometry_assay_collection(samples=["Control", "Treatment"], markers=["CD3", "CD4", "CD8"], instrument="BD LSRFortessa")',
-    frontend_import: "import { createFlowCytometryAssayCollection, toFlowPanelDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toFlowPanelDataFrame', 'toAssayMatrixDataFrame'],
-    components: ['DataFrame', 'SampleSelector', 'ChartContainer'],
-  },
-  {
-    name: 'western-blot-assay',
-    label: 'Western blot assay',
-    category: 'bio-template-preset',
-    purpose: 'Sample metadata, antibody/reagent list, protocol steps, and normalized protein readout matrix for Western blot assays.',
-    templates: ['sample-sheet', 'reagent-list', 'protocol-steps', 'assay-matrix'],
-    aliases: ['western blot', 'western-blot', 'immunoblot', 'protein blot', 'protein expression'],
-    python_import: 'from mint_sdk.templates import create_western_blot_assay_collection, save_template_collection',
-    python_example: 'create_western_blot_assay_collection(samples=["Control", "Treatment"], targets=["pERK", "ERK"], loading_control="ACTB")',
-    frontend_import: "import { createWesternBlotAssayCollection, toReagentDataFrame, toProtocolDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toReagentDataFrame', 'toProtocolDataFrame'],
-    components: ['DataFrame', 'ReagentList', 'ExperimentTimeline', 'SampleSelector'],
-  },
-] as const satisfies readonly BioTemplatePresetEntry[]
-
-export function listBioTemplatePresets(): readonly BioTemplatePresetEntry[] {
-  return bioTemplatePresets
-}
-
-export function getBioTemplatePresetInfo(name: string): BioTemplatePresetEntry | undefined {
-  return bioTemplatePresets.find(entry => {
-    const identifiers = [
-      entry.name,
-      entry.label,
-      ...entry.aliases,
-    ]
-    return templateIdentifierMatches(name, identifiers)
-  })
-}
-
-export function searchBioTemplatePresets(query: string): readonly BioTemplatePresetEntry[] {
-  const normalized = query.trim().toLowerCase()
-  if (!normalized) return bioTemplatePresets
-
-  return bioTemplatePresets.filter(entry => templateSearchMatches(normalized, [
-    entry.name,
-    entry.label,
-    entry.purpose,
-    entry.python_import,
-    entry.python_example,
-    entry.frontend_import,
-    ...entry.templates,
-    ...entry.aliases,
-    ...entry.frontend_adapters,
-    ...entry.components,
-  ]))
-}

package/src/templates/protocolAdapters.ts

@@ -1,69 +0,0 @@
-import { getTemplateData } from './templateEnvelopes'
-import { validateProtocolStepsData } from './templateValidators'
-import type {
-  ProtocolColumnsAdapterResult,
-  ProtocolDataFrameAdapterResult,
-  ProtocolRowsAdapterResult,
-  ProtocolStepsAdapterResult,
-  ProtocolStepsTemplate,
-  ProtocolStepsTemplateData,
-} from './types'
-
-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',
-  }
-}

package/src/templates/protocolNormalizers.ts

@@ -1,37 +0,0 @@
-import type {
-  ProtocolStepRecord,
-  TimeCourseCondition,
-  TimePoint,
-} from './types'
-import { idFromName } from './builderIdUtils'
-
-export function normalizeTimePoint(timepoint: TimePoint): TimePoint {
-  return {
-    ...timepoint,
-    metadata: timepoint.metadata ?? {},
-  }
-}
-
-export function normalizeCondition(condition: TimeCourseCondition): TimeCourseCondition {
-  return {
-    ...condition,
-    metadata: condition.metadata ?? {},
-  }
-}
-
-export function normalizeProtocolStep(
-  step: Partial<ProtocolStepRecord> & { name: string },
-  index: number
-): ProtocolStepRecord {
-  return {
-    id: step.id ?? idFromName(step.name, `step-${index + 1}`),
-    type: step.type ?? 'custom',
-    name: step.name,
-    description: step.description,
-    duration: step.duration,
-    status: step.status ?? 'pending',
-    parameters: step.parameters ?? {},
-    order: step.order ?? index,
-    metadata: step.metadata ?? {},
-  }
-}

package/src/templates/protocolStepsBuilder.ts

@@ -1,36 +0,0 @@
-import { idFromName } from './builderIdUtils'
-import { normalizeProtocolStep } from './protocolNormalizers'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import { validateProtocolStepsData } from './templateValidators'
-import type {
-  CreateProtocolStepsTemplateOptions,
-  ProtocolStepRecord,
-  ProtocolStepsTemplate,
-  ProtocolStepsTemplateData,
-} from './types'
-
-export function createProtocolStepsTemplate(
-  options: CreateProtocolStepsTemplateOptions
-): ProtocolStepsTemplate {
-  const steps = options.steps.map((step, index): ProtocolStepRecord => {
-    if (typeof step === 'string') {
-      return {
-        id: idFromName(step, `step-${index + 1}`),
-        type: 'custom',
-        name: step,
-        status: 'pending',
-        parameters: {},
-        order: index,
-        metadata: {},
-      }
-    }
-    return normalizeProtocolStep(step, index)
-  }).sort((a, b) => a.order - b.order)
-
-  const data: ProtocolStepsTemplateData = {
-    steps,
-    metadata: options.metadata ?? {},
-  }
-  validateProtocolStepsData(data)
-  return createTemplateEnvelope('protocol-steps', data, options.metadata ?? {})
-}

package/src/templates/qpcrAdapters.ts

@@ -1,104 +0,0 @@
-import type { Well } from '../types'
-import { getTemplateData } from './templateEnvelopes'
-import { validateQpcrPlateData } from './templateValidators'
-import type {
-  QpcrColumnsAdapterResult,
-  QpcrDataFrameAdapterResult,
-  QpcrPlateTemplate,
-  QpcrPlateTemplateData,
-  QpcrRowsAdapterResult,
-  QpcrWellMapAdapterResult,
-} from './types'
-
-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,
-    ]
-  }))
-}
-
-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]
-}