@morscherlab/mint-sdk 1.0.0-rc.2 → 1.0.0-rc.5

package/src/templates/timeCourseBuilder.ts

@@ -0,0 +1,64 @@
+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 ?? {})
+}

package/src/templates/types.ts

@@ -1,16 +1,11 @@
 import type {
-  DataFrameColumn,
-  PlateCondition,
   PlateMap,
-  PlateMapEditorState,
   ProtocolStep,
   Reagent,
-  ScheduleEvent,
   SampleType,
-  SelectOption,
   Well,
-  WellPlateFormat,
 } from '../types'
+import type { QpcrPlateTemplate } from './templateQpcrTypes'
 
 export type TemplateKind = 'experiment-design'
 export type TemplateId =
@@ -42,10 +37,6 @@ export type TemplatePackId =
   | 'longitudinal-study'
   | 'molecular-assay'
 
-export interface CreateBioTemplatePackCollectionOptions {
-  metadata?: Record<string, unknown>
-}
-
 export interface BioTemplateEnvelope<TData = Record<string, unknown>> {
   template_id: TemplateId | string
   template_version: string
@@ -410,52 +401,6 @@ export type InstrumentRunTemplate = BioTemplateEnvelope<InstrumentRunTemplateDat
 export type InstrumentMethodInput = Partial<InstrumentMethod> & { name?: string }
 export type InstrumentRunItemInput = Partial<InstrumentRunItem> & { name?: string; sampleId?: string }
 
-export type QpcrChemistry = 'sybr' | 'taqman' | 'probe' | 'evagreen' | 'other'
-export type QpcrControlKind = 'sample' | 'no-template' | 'no-rt' | 'positive' | 'standard' | 'calibrator'
-
-export interface QpcrSample {
-  sampleId: string
-  name?: string
-  group?: string
-  metadata?: Record<string, unknown>
-}
-
-export interface QpcrTarget {
-  id: string
-  name: string
-  assayId?: string
-  reporter?: string
-  quencher?: string
-  ampliconBp?: number
-  metadata?: Record<string, unknown>
-}
-
-export interface QpcrReaction {
-  id: string
-  wellId: string
-  sampleId?: string
-  targetId: string
-  replicate: number
-  controlKind: QpcrControlKind
-  cq?: number | null
-  quantity?: number | null
-  flags: string[]
-  metadata?: Record<string, unknown>
-}
-
-export interface QpcrPlateTemplateData {
-  plateId: string
-  format: WellPlateFormat
-  samples: QpcrSample[]
-  targets: QpcrTarget[]
-  reactions: QpcrReaction[]
-  instrument?: string
-  chemistry: QpcrChemistry
-  metadata: Record<string, unknown>
-}
-
-export type QpcrPlateTemplate = BioTemplateEnvelope<QpcrPlateTemplateData>
-
 export type DataFrameTemplate =
   | SampleSheetTemplate
   | SamplePrepTemplate
@@ -468,222 +413,81 @@ export type DataFrameTemplate =
   | InstrumentRunTemplate
   | QpcrPlateTemplate
 
-export interface CreatePlateMapTemplateOptions {
-  name?: string
-  id?: string
-  format?: WellPlateFormat
-  samples?: Array<string | TemplateSample>
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateSampleSheetTemplateOptions {
-  samples: SampleRecord[]
-  columns?: SampleColumn[]
-  groups?: SampleGroupDefinition[]
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateSamplePrepTemplateOptions {
-  samples: Array<string | SamplePrepStepInput>
-  prepType?: SamplePrepStepType
-  protocolName?: string
-  volumeUnit?: string
-  inputVolume?: number
-  outputVolume?: number
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateDoseResponseTemplateOptions {
-  compounds: Record<string, number[]> | CompoundDoseSeries[]
-  unit: string
-  replicates?: number
-  controls?: ControlDefinition[]
-  layout?: PlateMapTemplate | PlateMapTemplateData
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateCalibrationCurveTemplateOptions {
-  concentrations: Array<number | CalibrationPointInput>
-  analyte?: string
-  unit?: string
-  responseUnit?: string
-  model?: CalibrationModel
-  includeBlank?: boolean
-  includeQc?: boolean
-  acceptance?: CalibrationAcceptanceInput
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateTimeCourseTemplateOptions {
-  timepoints: Array<number | TimePoint>
-  unit: TimeUnit
-  conditions: Array<string | TimeCourseCondition>
-  replicates?: number
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateAssayMatrixTemplateOptions {
-  samples: Array<string | AssaySample>
-  features: Array<string | AssayFeature>
-  values?: Record<string, Record<string, number | null | undefined>>
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateProtocolStepsTemplateOptions {
-  steps: Array<string | (Partial<ProtocolStepRecord> & { name: string })>
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateReagentListTemplateOptions {
-  reagents: Array<string | ReagentTemplateInput>
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateFlowCytometryPanelTemplateOptions {
-  markers: Array<string | (Partial<FlowPanelMarker> & { marker: string })>
-  controls?: Array<string | (Partial<FlowPanelControl> & { name: string })>
-  instrument?: string
-  includeDefaultControls?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateInstrumentRunTemplateOptions {
-  items: Array<string | InstrumentRunItemInput>
-  method?: string | InstrumentMethodInput
-  instrument?: string
-  includeBlanks?: boolean
-  includeQc?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateQpcrPlateTemplateOptions {
-  samples: Array<string | QpcrSample>
-  targets: Array<string | QpcrTarget>
-  format?: WellPlateFormat
-  replicates?: number
-  includeNoTemplateControls?: boolean
-  instrument?: string
-  chemistry?: QpcrChemistry
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateWellPlateScreenCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  compounds?: Record<string, number[]> | CompoundDoseSeries[]
-  unit?: string
-  replicates?: number
-  plateName?: string
-  plateFormat?: WellPlateFormat
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateQpcrExpressionCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  targets?: Array<string | QpcrTarget>
-  chemistry?: QpcrChemistry
-  includeNoTemplateControls?: boolean
-  format?: WellPlateFormat
-  replicates?: number
-  instrument?: string
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateLcmsBatchCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  features?: Array<string | AssayFeature>
-  instrument?: string
-  method?: string | InstrumentMethodInput
-  includeQc?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateTargetedMetabolomicsCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  metabolites?: Array<string | AssayFeature>
-  internalStandards?: Array<string | ReagentTemplateInput>
-  standardConcentrations?: number[]
-  concentrationUnit?: string
-  responseUnit?: string
-  calibrationAnalyte?: string
-  instrument?: string
-  method?: string | InstrumentMethodInput
-  prepType?: SamplePrepStepType
-  outputVolume?: number
-  includeQc?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateElisaAssayCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  analyte?: string
-  standardConcentrations?: number[]
-  unit?: string
-  responseUnit?: string
-  plateName?: string
-  plateFormat?: WellPlateFormat
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateFlowCytometryAssayCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  markers?: CreateFlowCytometryPanelTemplateOptions['markers']
-  features?: Array<string | AssayFeature>
-  instrument?: string
-  includeDefaultControls?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateWesternBlotAssayCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  targets?: Array<string | AssayFeature>
-  loadingControl?: string
-  metadata?: Record<string, unknown>
-}
-
-export type PlateMapEditorAdapterResult = PlateMapEditorState
-export type WellMapAdapterResult = Record<string, Well>
-export type SampleRowsAdapterResult = Array<Record<string, unknown>>
-export type SampleColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export interface DataFrameAdapterResult {
-  data: Array<Record<string, unknown>>
-  columns: DataFrameColumn<Record<string, unknown>>[]
-  rowKey?: string
-}
-export type SampleDataFrameAdapterResult = DataFrameAdapterResult
-export type SampleOptionsAdapterResult = SelectOption<string>[]
-export type SamplePrepRowsAdapterResult = Array<Record<string, unknown>>
-export type SamplePrepColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export type SamplePrepDataFrameAdapterResult = DataFrameAdapterResult
-export type DoseConditionsAdapterResult = PlateCondition[]
-export type CalibrationCurveRowsAdapterResult = Array<Record<string, unknown>>
-export type CalibrationCurveColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export type CalibrationCurveDataFrameAdapterResult = DataFrameAdapterResult
-export type TimeCourseRowsAdapterResult = Array<Record<string, unknown>>
-export type TimeCourseColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export type TimeCourseDataFrameAdapterResult = DataFrameAdapterResult
-export type TimeCourseStepsAdapterResult = ProtocolStep[]
-export type ProtocolStepsAdapterResult = ProtocolStep[]
-export type ProtocolRowsAdapterResult = Array<Record<string, unknown>>
-export type ProtocolColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export type ProtocolDataFrameAdapterResult = DataFrameAdapterResult
-export type AssayMatrixRowsAdapterResult = Array<Record<string, unknown>>
-export type AssayMatrixColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export type AssayMatrixDataFrameAdapterResult = DataFrameAdapterResult
-export type AssayMatrixSampleOptionsAdapterResult = SelectOption<string>[]
-export type ReagentListItemsAdapterResult = Reagent[]
-export type ReagentRowsAdapterResult = Array<Record<string, unknown>>
-export type ReagentColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export type ReagentDataFrameAdapterResult = DataFrameAdapterResult
-export type FlowPanelRowsAdapterResult = Array<Record<string, unknown>>
-export type FlowPanelColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export type FlowPanelDataFrameAdapterResult = DataFrameAdapterResult
-export type InstrumentRunRowsAdapterResult = Array<Record<string, unknown>>
-export type InstrumentRunColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export type InstrumentRunDataFrameAdapterResult = DataFrameAdapterResult
-export type InstrumentRunStepsAdapterResult = ProtocolStep[]
-export type InstrumentRunScheduleEventsAdapterResult = ScheduleEvent[]
-export type QpcrRowsAdapterResult = Array<Record<string, unknown>>
-export type QpcrColumnsAdapterResult = DataFrameColumn<Record<string, unknown>>[]
-export type QpcrDataFrameAdapterResult = DataFrameAdapterResult
-export type QpcrWellMapAdapterResult = Record<string, Well>
-export type TemplateDataFrameAdapterResult = DataFrameAdapterResult
+export type {
+  QpcrChemistry,
+  QpcrControlKind,
+  QpcrPlateTemplate,
+  QpcrPlateTemplateData,
+  QpcrReaction,
+  QpcrSample,
+  QpcrTarget,
+} from './templateQpcrTypes'
+
+export type {
+  CreateAssayMatrixTemplateOptions,
+  CreateBioTemplatePackCollectionOptions,
+  CreateCalibrationCurveTemplateOptions,
+  CreateDoseResponseTemplateOptions,
+  CreateElisaAssayCollectionOptions,
+  CreateFlowCytometryAssayCollectionOptions,
+  CreateFlowCytometryPanelTemplateOptions,
+  CreateInstrumentRunTemplateOptions,
+  CreateLcmsBatchCollectionOptions,
+  CreatePlateMapTemplateOptions,
+  CreateProtocolStepsTemplateOptions,
+  CreateQpcrExpressionCollectionOptions,
+  CreateQpcrPlateTemplateOptions,
+  CreateReagentListTemplateOptions,
+  CreateSamplePrepTemplateOptions,
+  CreateSampleSheetTemplateOptions,
+  CreateTargetedMetabolomicsCollectionOptions,
+  CreateTimeCourseTemplateOptions,
+  CreateWellPlateScreenCollectionOptions,
+  CreateWesternBlotAssayCollectionOptions,
+} from './templateCreateOptions'
+
+export type {
+  AssayMatrixColumnsAdapterResult,
+  AssayMatrixDataFrameAdapterResult,
+  AssayMatrixRowsAdapterResult,
+  AssayMatrixSampleOptionsAdapterResult,
+  CalibrationCurveColumnsAdapterResult,
+  CalibrationCurveDataFrameAdapterResult,
+  CalibrationCurveRowsAdapterResult,
+  DataFrameAdapterResult,
+  DoseConditionsAdapterResult,
+  FlowPanelColumnsAdapterResult,
+  FlowPanelDataFrameAdapterResult,
+  FlowPanelRowsAdapterResult,
+  InstrumentRunColumnsAdapterResult,
+  InstrumentRunDataFrameAdapterResult,
+  InstrumentRunRowsAdapterResult,
+  InstrumentRunScheduleEventsAdapterResult,
+  InstrumentRunStepsAdapterResult,
+  PlateMapEditorAdapterResult,
+  ProtocolColumnsAdapterResult,
+  ProtocolDataFrameAdapterResult,
+  ProtocolRowsAdapterResult,
+  ProtocolStepsAdapterResult,
+  QpcrColumnsAdapterResult,
+  QpcrDataFrameAdapterResult,
+  QpcrRowsAdapterResult,
+  QpcrWellMapAdapterResult,
+  ReagentColumnsAdapterResult,
+  ReagentDataFrameAdapterResult,
+  ReagentListItemsAdapterResult,
+  ReagentRowsAdapterResult,
+  SampleColumnsAdapterResult,
+  SampleDataFrameAdapterResult,
+  SampleOptionsAdapterResult,
+  SamplePrepColumnsAdapterResult,
+  SamplePrepDataFrameAdapterResult,
+  SamplePrepRowsAdapterResult,
+  SampleRowsAdapterResult,
+  TemplateDataFrameAdapterResult,
+  TimeCourseColumnsAdapterResult,
+  TimeCourseDataFrameAdapterResult,
+  TimeCourseRowsAdapterResult,
+  TimeCourseStepsAdapterResult,
+  WellMapAdapterResult,
+} from './templateAdapterTypes'

package/src/templates/wellPlateScreenCollectionBuilder.ts

@@ -0,0 +1,36 @@
+import { DEFAULT_SAMPLE_COLORS } from './builderDefaults'
+import { createDoseResponseTemplate } from './doseResponseBuilder'
+import { createPlateMapTemplate } from './plateMapBuilder'
+import { createSampleSheetTemplate } from './sampleSheetBuilder'
+import { presetSampleRecords } from './sampleNormalizers'
+import { createTemplateCollection } from './templateEnvelopes'
+import type {
+  CreateWellPlateScreenCollectionOptions,
+  TemplateCollectionEnvelope,
+} from './types'
+
+export function createWellPlateScreenCollection(
+  options: CreateWellPlateScreenCollectionOptions = {}
+): TemplateCollectionEnvelope {
+  const sampleRecords = presetSampleRecords(options.samples ?? ['Control', 'Treatment'])
+  const plate = createPlateMapTemplate({
+    name: options.plateName ?? 'Screen plate',
+    format: options.plateFormat ?? 96,
+    samples: sampleRecords.map((sample, index) => ({
+      id: sample.sampleId,
+      name: sample.name ?? sample.sampleId,
+      color: DEFAULT_SAMPLE_COLORS[index % DEFAULT_SAMPLE_COLORS.length],
+    })),
+  })
+  const sampleSheet = createSampleSheetTemplate({ samples: sampleRecords })
+  const doseResponse = createDoseResponseTemplate({
+    compounds: options.compounds ?? { 'Compound A': [10, 1, 0.1] },
+    unit: options.unit ?? 'uM',
+    replicates: options.replicates ?? 3,
+    layout: plate,
+  })
+  return createTemplateCollection(
+    [plate, sampleSheet, doseResponse],
+    { preset: 'wellplate-screen', ...(options.metadata ?? {}) }
+  )
+}

package/src/templates/westernBlotAssayCollectionBuilder.ts

@@ -0,0 +1,68 @@
+import { createAssayMatrixTemplate } from './assayMatrixBuilder'
+import { idFromName } from './builderIdUtils'
+import { createProtocolStepsTemplate } from './protocolStepsBuilder'
+import { createReagentListTemplate } from './reagentListBuilder'
+import { createSampleSheetTemplate } from './sampleSheetBuilder'
+import { presetSampleRecords } from './sampleNormalizers'
+import { createTemplateCollection } from './templateEnvelopes'
+import type {
+  CreateWesternBlotAssayCollectionOptions,
+  TemplateCollectionEnvelope,
+} from './types'
+
+export function createWesternBlotAssayCollection(
+  options: CreateWesternBlotAssayCollectionOptions = {}
+): TemplateCollectionEnvelope {
+  const sampleRecords = presetSampleRecords(options.samples ?? ['Control', 'Treatment'])
+  const loadingControl = options.loadingControl ?? 'ACTB'
+  const targetNames = (options.targets ?? ['Target protein']).map(target =>
+    typeof target === 'string' ? target : target.name ?? target.id
+  )
+  const featureNames = loadingControl && !targetNames.includes(loadingControl)
+    ? [...targetNames, loadingControl]
+    : targetNames
+  const sampleSheet = createSampleSheetTemplate({ samples: sampleRecords })
+  const reagentList = createReagentListTemplate({
+    reagents: [
+      { id: 'primary-antibody', name: 'Primary antibody', kind: 'antibody', storageCondition: '4C' },
+      { id: 'secondary-antibody', name: 'Secondary antibody', kind: 'antibody', storageCondition: '4C' },
+      { id: 'lysis-buffer', name: 'Lysis buffer', kind: 'buffer', storageCondition: '4C' },
+      { id: 'blocking-buffer', name: 'Blocking buffer', kind: 'buffer', storageCondition: '4C' },
+      { id: 'wash-buffer', name: 'TBST wash buffer', kind: 'buffer', storageCondition: 'RT' },
+      { id: 'substrate', name: 'Detection substrate', kind: 'reagent', storageCondition: '4C' },
+    ],
+    metadata: { assay: 'western-blot' },
+  })
+  const protocol = createProtocolStepsTemplate({
+    steps: [
+      { id: 'lyse-samples', type: 'addition', name: 'Lyse samples', duration: 30 },
+      { id: 'run-gel', type: 'custom', name: 'Run SDS-PAGE', duration: 90 },
+      { id: 'transfer', type: 'transfer', name: 'Transfer to membrane', duration: 60 },
+      { id: 'block', type: 'incubation', name: 'Block membrane', duration: 60 },
+      { id: 'primary-antibody', type: 'incubation', name: 'Primary antibody incubation', duration: 960 },
+      { id: 'secondary-antibody', type: 'incubation', name: 'Secondary antibody incubation', duration: 60 },
+      { id: 'detect', type: 'measurement', name: 'Detect and quantify bands', duration: 30 },
+    ],
+    metadata: { assay: 'western-blot' },
+  })
+  const assayMatrix = createAssayMatrixTemplate({
+    samples: sampleRecords.map(sample => ({
+      sampleId: sample.sampleId,
+      name: sample.name,
+      group: sample.group,
+      metadata: sample.metadata ?? {},
+    })),
+    features: featureNames.map((feature, index) => ({
+      id: idFromName(feature, `feature-${index + 1}`),
+      name: feature,
+      type: 'protein',
+      unit: 'relative intensity',
+      metadata: { loadingControl: feature === loadingControl },
+    })),
+    metadata: { assay: 'western-blot', loadingControl },
+  })
+  return createTemplateCollection(
+    [sampleSheet, reagentList, protocol, assayMatrix],
+    { preset: 'western-blot-assay', ...(options.metadata ?? {}) }
+  )
+}