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

package/src/templates/templateValidators.ts

@@ -1,414 +0,0 @@
-import type {
-  AssayMatrixTemplateData,
-  CalibrationCurveTemplateData,
-  DoseResponseTemplateData,
-  FlowCytometryPanelTemplateData,
-  InstrumentRunTemplateData,
-  PlateMapTemplateData,
-  ProtocolStepsTemplateData,
-  QpcrPlateTemplateData,
-  ReagentListTemplateData,
-  SamplePrepTemplateData,
-  SampleSheetTemplateData,
-  TimeCourseTemplateData,
-} from './types'
-import { assertWellInFormat } from './plateGeometry'
-
-export function validatePlateMapData(data: PlateMapTemplateData): void {
-  if (!Array.isArray(data.plates) || data.plates.length === 0) {
-    throw new Error('Plate-map template requires at least one plate.')
-  }
-  const sampleIds = new Set(data.samples.map(sample => sample.id))
-  if (sampleIds.size !== data.samples.length) {
-    throw new Error('Plate-map sample ids must be unique.')
-  }
-  for (const plate of data.plates) {
-    for (const [wellId, well] of Object.entries(plate.wells)) {
-      if (well.id !== wellId) {
-        throw new Error(`Well key '${wellId}' does not match well id '${well.id}'.`)
-      }
-      if (well.sampleType && !sampleIds.has(well.sampleType)) {
-        throw new Error(`Well '${well.id}' references unknown sample '${well.sampleType}'.`)
-      }
-    }
-  }
-}
-
-export function validateSampleSheetData(data: SampleSheetTemplateData): void {
-  if (!Array.isArray(data.samples) || data.samples.length === 0) {
-    throw new Error('Sample-sheet template requires at least one sample.')
-  }
-  const sampleIds = new Set(data.samples.map(sample => sample.sampleId))
-  if (sampleIds.size !== data.samples.length) {
-    throw new Error('Sample-sheet sample ids must be unique.')
-  }
-  for (const group of data.groups) {
-    for (const sampleId of group.samples) {
-      if (!sampleIds.has(sampleId)) {
-        throw new Error(`Group '${group.name}' references unknown sample '${sampleId}'.`)
-      }
-    }
-  }
-}
-
-export function validateSamplePrepData(data: SamplePrepTemplateData): void {
-  if (!data.protocolName) {
-    throw new Error('Sample-prep template requires protocolName.')
-  }
-  if (!Array.isArray(data.steps) || data.steps.length === 0) {
-    throw new Error('Sample-prep template requires at least one step.')
-  }
-  const stepIds = new Set(data.steps.map(step => step.id))
-  if (stepIds.size !== data.steps.length) {
-    throw new Error('Sample-prep step ids must be unique.')
-  }
-  const orders = new Set(data.steps.map(step => step.order))
-  if (orders.size !== data.steps.length) {
-    throw new Error('Sample-prep step orders must be unique.')
-  }
-  for (const step of data.steps) {
-    if (!step.id || !step.name) {
-      throw new Error('Sample-prep steps require id and name.')
-    }
-    if (step.order < 0) {
-      throw new Error(`Sample-prep step '${step.id}' has a negative order.`)
-    }
-    if (!step.volumeUnit) {
-      throw new Error(`Sample-prep step '${step.id}' requires volumeUnit.`)
-    }
-    if (step.inputVolume !== undefined && step.inputVolume < 0) {
-      throw new Error(`Sample-prep step '${step.id}' has a negative input volume.`)
-    }
-    if (step.outputVolume !== undefined && step.outputVolume < 0) {
-      throw new Error(`Sample-prep step '${step.id}' has a negative output volume.`)
-    }
-    if (step.durationMin !== undefined && step.durationMin < 0) {
-      throw new Error(`Sample-prep step '${step.id}' has a negative duration.`)
-    }
-    if (!step.sourceSampleId && !step.destinationSampleId && !step.reagentId) {
-      throw new Error(`Sample-prep step '${step.id}' requires a source, destination, or reagent.`)
-    }
-  }
-}
-
-export function validateDoseResponseData(data: DoseResponseTemplateData): void {
-  if (!Array.isArray(data.compounds) || data.compounds.length === 0) {
-    throw new Error('Dose-response template requires at least one compound.')
-  }
-  if (!data.unit) {
-    throw new Error('Dose-response template requires a unit.')
-  }
-  if (data.replicates < 1) {
-    throw new Error('Dose-response replicates must be at least 1.')
-  }
-  for (const compound of data.compounds) {
-    if (compound.concentrations.length === 0) {
-      throw new Error(`Compound '${compound.name}' requires at least one concentration.`)
-    }
-    if (compound.concentrations.some(value => value < 0)) {
-      throw new Error(`Compound '${compound.name}' has a negative concentration.`)
-    }
-  }
-}
-
-export function validateCalibrationCurveData(data: CalibrationCurveTemplateData): void {
-  if (!data.analyte) {
-    throw new Error('Calibration-curve template requires an analyte.')
-  }
-  if (!data.xUnit) {
-    throw new Error('Calibration-curve template requires xUnit.')
-  }
-  if (!data.responseUnit) {
-    throw new Error('Calibration-curve template requires responseUnit.')
-  }
-  if (!Array.isArray(data.points) || data.points.length === 0) {
-    throw new Error('Calibration-curve template requires at least one point.')
-  }
-  if (data.acceptance.minRSquared < 0 || data.acceptance.minRSquared > 1) {
-    throw new Error('Calibration-curve minRSquared must be between 0 and 1.')
-  }
-  if (data.acceptance.standardTolerancePercent < 0 || data.acceptance.qcTolerancePercent < 0) {
-    throw new Error('Calibration-curve tolerances cannot be negative.')
-  }
-
-  const pointIds = new Set(data.points.map(point => point.id))
-  if (pointIds.size !== data.points.length) {
-    throw new Error('Calibration-curve point ids must be unique.')
-  }
-  const orders = new Set(data.points.map(point => point.order))
-  if (orders.size !== data.points.length) {
-    throw new Error('Calibration-curve point orders must be unique.')
-  }
-
-  let standards = 0
-  for (const point of data.points) {
-    if (!point.id || !point.level) {
-      throw new Error('Calibration-curve points require id and level.')
-    }
-    if (!point.unit) {
-      throw new Error(`Calibration-curve point '${point.id}' requires unit.`)
-    }
-    if (point.order < 0) {
-      throw new Error(`Calibration-curve point '${point.id}' has a negative order.`)
-    }
-    if (point.concentration < 0) {
-      throw new Error(`Calibration-curve point '${point.id}' has a negative concentration.`)
-    }
-    if ((point.role === 'standard' || point.role === 'qc') && point.concentration <= 0) {
-      throw new Error(`Calibration-curve point '${point.id}' requires positive concentration.`)
-    }
-    if (point.replicate < 1) {
-      throw new Error(`Calibration-curve point '${point.id}' replicate must be at least 1.`)
-    }
-    if (point.role === 'standard' && point.include) {
-      standards += 1
-    }
-  }
-
-  if (standards < 2) {
-    throw new Error('Calibration-curve template requires at least two included standards.')
-  }
-  if (data.acceptance.requireBlank && !data.points.some(point => point.role === 'blank')) {
-    throw new Error('Calibration-curve template requires a blank point when requireBlank is true.')
-  }
-}
-
-export function validateTimeCourseData(data: TimeCourseTemplateData): void {
-  if (!Array.isArray(data.timepoints) || data.timepoints.length === 0) {
-    throw new Error('Time-course template requires at least one time point.')
-  }
-  if (!Array.isArray(data.conditions) || data.conditions.length === 0) {
-    throw new Error('Time-course template requires at least one condition.')
-  }
-  const timepointIds = new Set(data.timepoints.map(timepoint => timepoint.id))
-  if (timepointIds.size !== data.timepoints.length) {
-    throw new Error('Time-course time point ids must be unique.')
-  }
-  const conditionIds = new Set(data.conditions.map(condition => condition.id))
-  if (conditionIds.size !== data.conditions.length) {
-    throw new Error('Time-course condition ids must be unique.')
-  }
-  const sampleIds = new Set(data.samples.map(sample => sample.sampleId))
-  if (sampleIds.size !== data.samples.length) {
-    throw new Error('Time-course sample ids must be unique.')
-  }
-  for (const sample of data.samples) {
-    if (!timepointIds.has(sample.timepointId)) {
-      throw new Error(`Sample '${sample.sampleId}' references unknown time point.`)
-    }
-    if (!conditionIds.has(sample.conditionId)) {
-      throw new Error(`Sample '${sample.sampleId}' references unknown condition.`)
-    }
-  }
-}
-
-export function validateProtocolStepsData(data: ProtocolStepsTemplateData): void {
-  if (!Array.isArray(data.steps) || data.steps.length === 0) {
-    throw new Error('Protocol-steps template requires at least one step.')
-  }
-  const stepIds = new Set(data.steps.map(step => step.id))
-  if (stepIds.size !== data.steps.length) {
-    throw new Error('Protocol-steps ids must be unique.')
-  }
-  const orders = new Set(data.steps.map(step => step.order))
-  if (orders.size !== data.steps.length) {
-    throw new Error('Protocol-steps orders must be unique.')
-  }
-  for (const step of data.steps) {
-    if (!step.id) {
-      throw new Error('Protocol step id is required.')
-    }
-    if (!step.name) {
-      throw new Error(`Protocol step '${step.id}' requires a name.`)
-    }
-    if (step.duration !== undefined && step.duration < 0) {
-      throw new Error(`Protocol step '${step.id}' has a negative duration.`)
-    }
-    if (step.order < 0) {
-      throw new Error(`Protocol step '${step.id}' has a negative order.`)
-    }
-  }
-}
-
-export function validateAssayMatrixData(data: AssayMatrixTemplateData): void {
-  if (!Array.isArray(data.samples) || data.samples.length === 0) {
-    throw new Error('Assay-matrix template requires at least one sample.')
-  }
-  if (!Array.isArray(data.features) || data.features.length === 0) {
-    throw new Error('Assay-matrix template requires at least one feature.')
-  }
-  const sampleIds = new Set(data.samples.map(sample => sample.sampleId))
-  if (sampleIds.size !== data.samples.length) {
-    throw new Error('Assay-matrix sample ids must be unique.')
-  }
-  const featureIds = new Set(data.features.map(feature => feature.id))
-  if (featureIds.size !== data.features.length) {
-    throw new Error('Assay-matrix feature ids must be unique.')
-  }
-  const measurementIds = new Set<string>()
-  for (const measurement of data.measurements) {
-    const key = `${measurement.sampleId}:${measurement.featureId}`
-    if (measurementIds.has(key)) {
-      throw new Error(`Duplicate assay measurement for '${key}'.`)
-    }
-    measurementIds.add(key)
-    if (!sampleIds.has(measurement.sampleId)) {
-      throw new Error(`Measurement references unknown sample '${measurement.sampleId}'.`)
-    }
-    if (!featureIds.has(measurement.featureId)) {
-      throw new Error(`Measurement references unknown feature '${measurement.featureId}'.`)
-    }
-  }
-}
-
-export function validateReagentListData(data: ReagentListTemplateData): void {
-  if (!Array.isArray(data.reagents) || data.reagents.length === 0) {
-    throw new Error('Reagent-list template requires at least one reagent.')
-  }
-  const reagentIds = new Set(data.reagents.map(reagent => reagent.id))
-  if (reagentIds.size !== data.reagents.length) {
-    throw new Error('Reagent-list reagent ids must be unique.')
-  }
-  for (const reagent of data.reagents) {
-    if (!reagent.id) {
-      throw new Error('Reagent-list reagent id is required.')
-    }
-    if (!reagent.name) {
-      throw new Error(`Reagent '${reagent.id}' requires a name.`)
-    }
-    if (reagent.stockLevel !== undefined && reagent.stockLevel < 0) {
-      throw new Error(`Reagent '${reagent.id}' has a negative stock level.`)
-    }
-  }
-}
-
-export function validateFlowCytometryPanelData(data: FlowCytometryPanelTemplateData): void {
-  if (!Array.isArray(data.markers) || data.markers.length === 0) {
-    throw new Error('Flow-cytometry panel template requires at least one marker.')
-  }
-  const markerIds = new Set(data.markers.map(marker => marker.id))
-  if (markerIds.size !== data.markers.length) {
-    throw new Error('Flow-cytometry panel marker ids must be unique.')
-  }
-  const controlIds = new Set(data.controls.map(control => control.id))
-  if (controlIds.size !== data.controls.length) {
-    throw new Error('Flow-cytometry panel control ids must be unique.')
-  }
-  for (const marker of data.markers) {
-    if (!marker.id) {
-      throw new Error('Flow-cytometry panel marker id is required.')
-    }
-    if (!marker.marker) {
-      throw new Error(`Flow-cytometry panel marker '${marker.id}' requires a marker name.`)
-    }
-  }
-  for (const control of data.controls) {
-    if (!control.id) {
-      throw new Error('Flow-cytometry panel control id is required.')
-    }
-    if (!control.name) {
-      throw new Error(`Flow-cytometry panel control '${control.id}' requires a name.`)
-    }
-    if (control.markerId && !markerIds.has(control.markerId)) {
-      throw new Error(`Flow-cytometry panel control '${control.id}' references unknown marker '${control.markerId}'.`)
-    }
-  }
-}
-
-export function validateInstrumentRunData(data: InstrumentRunTemplateData): void {
-  if (!Array.isArray(data.methods) || data.methods.length === 0) {
-    throw new Error('Instrument-run template requires at least one method.')
-  }
-  if (!Array.isArray(data.items) || data.items.length === 0) {
-    throw new Error('Instrument-run template requires at least one run item.')
-  }
-  const methodIds = new Set(data.methods.map(method => method.id))
-  if (methodIds.size !== data.methods.length) {
-    throw new Error('Instrument-run method ids must be unique.')
-  }
-  for (const method of data.methods) {
-    if (!method.id || !method.name) {
-      throw new Error('Instrument-run methods require id and name.')
-    }
-  }
-  const itemIds = new Set(data.items.map(item => item.id))
-  if (itemIds.size !== data.items.length) {
-    throw new Error('Instrument-run item ids must be unique.')
-  }
-  const orders = new Set(data.items.map(item => item.order))
-  if (orders.size !== data.items.length) {
-    throw new Error('Instrument-run item orders must be unique.')
-  }
-  for (const item of data.items) {
-    if (!item.id) {
-      throw new Error('Instrument-run items require id.')
-    }
-    if (!methodIds.has(item.methodId)) {
-      throw new Error(`Instrument-run item '${item.id}' references unknown method '${item.methodId}'.`)
-    }
-    if (item.kind === 'sample' && !item.sampleId) {
-      throw new Error(`Instrument-run sample item '${item.id}' requires sampleId.`)
-    }
-    if (item.order < 0) {
-      throw new Error(`Instrument-run item '${item.id}' has a negative order.`)
-    }
-    if (item.injectionVolume !== undefined && item.injectionVolume < 0) {
-      throw new Error(`Instrument-run item '${item.id}' has a negative injection volume.`)
-    }
-    if (item.expectedDurationMin !== undefined && item.expectedDurationMin < 0) {
-      throw new Error(`Instrument-run item '${item.id}' has a negative expected duration.`)
-    }
-  }
-}
-
-export function validateQpcrPlateData(data: QpcrPlateTemplateData): void {
-  if (!Array.isArray(data.samples) || data.samples.length === 0) {
-    throw new Error('qPCR plate template requires at least one sample.')
-  }
-  if (!Array.isArray(data.targets) || data.targets.length === 0) {
-    throw new Error('qPCR plate template requires at least one target.')
-  }
-  if (!Array.isArray(data.reactions) || data.reactions.length === 0) {
-    throw new Error('qPCR plate template requires at least one reaction.')
-  }
-  const sampleIds = new Set(data.samples.map(sample => sample.sampleId))
-  if (sampleIds.size !== data.samples.length) {
-    throw new Error('qPCR plate sample ids must be unique.')
-  }
-  const targetIds = new Set(data.targets.map(target => target.id))
-  if (targetIds.size !== data.targets.length) {
-    throw new Error('qPCR plate target ids must be unique.')
-  }
-  const reactionIds = new Set(data.reactions.map(reaction => reaction.id))
-  if (reactionIds.size !== data.reactions.length) {
-    throw new Error('qPCR plate reaction ids must be unique.')
-  }
-  const wellIds = new Set(data.reactions.map(reaction => reaction.wellId))
-  if (wellIds.size !== data.reactions.length) {
-    throw new Error('qPCR plate reaction wells must be unique.')
-  }
-  for (const reaction of data.reactions) {
-    assertWellInFormat(reaction.wellId, data.format)
-    if (!reaction.id) {
-      throw new Error('qPCR reaction id is required.')
-    }
-    if (!reaction.targetId || !targetIds.has(reaction.targetId)) {
-      throw new Error(`qPCR reaction '${reaction.id}' references unknown target '${reaction.targetId}'.`)
-    }
-    if (reaction.sampleId && !sampleIds.has(reaction.sampleId)) {
-      throw new Error(`qPCR reaction '${reaction.id}' references unknown sample '${reaction.sampleId}'.`)
-    }
-    if (reaction.controlKind === 'sample' && !reaction.sampleId) {
-      throw new Error(`qPCR sample reaction '${reaction.id}' requires sampleId.`)
-    }
-    if (reaction.replicate < 1) {
-      throw new Error(`qPCR reaction '${reaction.id}' replicate must be at least 1.`)
-    }
-    if (reaction.cq !== undefined && reaction.cq !== null && reaction.cq < 0) {
-      throw new Error(`qPCR reaction '${reaction.id}' has a negative Cq.`)
-    }
-    if (reaction.quantity !== undefined && reaction.quantity !== null && reaction.quantity < 0) {
-      throw new Error(`qPCR reaction '${reaction.id}' has a negative quantity.`)
-    }
-  }
-}

package/src/templates/timeCourseAdapters.ts

@@ -1,73 +0,0 @@
-import { getTemplateData } from './templateEnvelopes'
-import { validateTimeCourseData } from './templateValidators'
-import type {
-  TimeCourseColumnsAdapterResult,
-  TimeCourseDataFrameAdapterResult,
-  TimeCourseRowsAdapterResult,
-  TimeCourseStepsAdapterResult,
-  TimeCourseTemplate,
-  TimeCourseTemplateData,
-} from './types'
-
-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,
-    },
-  }))
-}

package/src/templates/timeCourseBuilder.ts

@@ -1,64 +0,0 @@
-import { DEFAULT_SAMPLE_COLORS } from './builderDefaults'
-import {
-  idFromName,
-  timepointId,
-} from './builderIdUtils'
-import {
-  normalizeCondition,
-  normalizeTimePoint,
-} from './protocolNormalizers'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import { validateTimeCourseData } from './templateValidators'
-import type {
-  CreateTimeCourseTemplateOptions,
-  TimeCourseCondition,
-  TimeCourseTemplate,
-  TimeCourseTemplateData,
-  TimePoint,
-} from './types'
-
-export function createTimeCourseTemplate(
-  options: CreateTimeCourseTemplateOptions
-): TimeCourseTemplate {
-  const timepoints = options.timepoints.map((timepoint, index): TimePoint => {
-    if (typeof timepoint !== 'number') return normalizeTimePoint(timepoint)
-    return {
-      id: timepointId(timepoint, options.unit, index),
-      label: `${timepoint} ${options.unit}`,
-      value: timepoint,
-      unit: options.unit,
-      metadata: {},
-    }
-  }).sort((a, b) => a.value - b.value)
-
-  const conditions = options.conditions.map((condition, index): TimeCourseCondition => {
-    if (typeof condition !== 'string') return normalizeCondition(condition)
-    return {
-      id: idFromName(condition, `condition-${index + 1}`),
-      name: condition,
-      color: DEFAULT_SAMPLE_COLORS[index % DEFAULT_SAMPLE_COLORS.length],
-      metadata: {},
-    }
-  })
-
-  const samples = conditions.flatMap(condition =>
-    timepoints.flatMap(timepoint =>
-      Array.from({ length: options.replicates ?? 1 }, (_, index) => ({
-        sampleId: `${condition.id}-${timepoint.id}-r${index + 1}`,
-        conditionId: condition.id,
-        timepointId: timepoint.id,
-        replicate: index + 1,
-        metadata: {},
-      }))
-    )
-  )
-
-  const data: TimeCourseTemplateData = {
-    timepoints,
-    conditions,
-    samples,
-    metadata: options.metadata ?? {},
-  }
-  validateTimeCourseData(data)
-  return createTemplateEnvelope('time-course', data, options.metadata ?? {})
-}