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

package/src/templates/componentTemplateProps.ts

@@ -0,0 +1,78 @@
+import {
+  toInstrumentRunSteps,
+  toProtocolSteps,
+  toTimeCourseSteps,
+} from './adapters'
+import { doseResponseProps } from './componentDoseResponseProps'
+import {
+  assayMatrixSampleSelectorProps,
+  dataFrameProps,
+  reagentListProps,
+  sampleSelectorProps,
+  scheduleCalendarProps,
+  timelineProps,
+} from './componentGenericProps'
+import { plateMapProps } from './componentPlateMapProps'
+import { qpcrPlateProps } from './componentQpcrPlateProps'
+import type { BioTemplateComponentPropsBinding } from './componentBindings'
+import type {
+  AssayMatrixTemplate,
+  BioTemplateEnvelope,
+  DataFrameTemplate,
+  DoseResponseTemplate,
+  InstrumentRunTemplate,
+  PlateMapTemplate,
+  ProtocolStepsTemplate,
+  QpcrPlateTemplate,
+  ReagentListTemplate,
+  SampleSheetTemplate,
+  TimeCourseTemplate,
+} from './types'
+
+export function propsForTemplate(template: BioTemplateEnvelope<unknown>): BioTemplateComponentPropsBinding[] {
+  switch (template.template_id) {
+    case 'plate-map':
+      return plateMapProps(template as PlateMapTemplate)
+    case 'sample-sheet':
+      return [
+        dataFrameProps(template as DataFrameTemplate),
+        sampleSelectorProps(template as SampleSheetTemplate),
+      ]
+    case 'sample-prep':
+    case 'calibration-curve':
+    case 'flow-cytometry-panel':
+      return [dataFrameProps(template as DataFrameTemplate)]
+    case 'assay-matrix':
+      return [
+        dataFrameProps(template as DataFrameTemplate),
+        assayMatrixSampleSelectorProps(template as AssayMatrixTemplate),
+      ]
+    case 'instrument-run':
+      return [
+        dataFrameProps(template as DataFrameTemplate),
+        scheduleCalendarProps(template as InstrumentRunTemplate),
+        timelineProps(template as InstrumentRunTemplate, toInstrumentRunSteps(template as InstrumentRunTemplate)),
+      ]
+    case 'dose-response':
+      return doseResponseProps(template as DoseResponseTemplate)
+    case 'time-course':
+      return [
+        timelineProps(template as TimeCourseTemplate, toTimeCourseSteps(template as TimeCourseTemplate)),
+        dataFrameProps(template as DataFrameTemplate),
+      ]
+    case 'protocol-steps':
+      return [
+        timelineProps(template as ProtocolStepsTemplate, toProtocolSteps(template as ProtocolStepsTemplate), true),
+        dataFrameProps(template as DataFrameTemplate),
+      ]
+    case 'reagent-list':
+      return [
+        reagentListProps(template as ReagentListTemplate),
+        dataFrameProps(template as DataFrameTemplate),
+      ]
+    case 'qpcr-plate':
+      return qpcrPlateProps(template as QpcrPlateTemplate)
+    default:
+      return []
+  }
+}

package/src/templates/controlSchemaClone.ts

@@ -0,0 +1,32 @@
+import type {
+  BioTemplateControlSchema,
+} from './controlSchemaTypes'
+
+export function cloneSchemaMap<TName extends string>(
+  schemas: Record<TName, BioTemplateControlSchema>
+): Record<TName, BioTemplateControlSchema> {
+  const result = {} as Record<TName, BioTemplateControlSchema>
+  for (const name of Object.keys(schemas) as TName[]) {
+    result[name] = cloneControlSchema(schemas[name])
+  }
+  return result
+}
+
+export function cloneControlSchema(schema: BioTemplateControlSchema): BioTemplateControlSchema {
+  return Object.fromEntries(
+    Object.entries(schema).map(([name, definition]) => [name, cloneControlDefinition(definition)])
+  )
+}
+
+export function cloneControlDefinition(
+  definition: BioTemplateControlSchema[string]
+): BioTemplateControlSchema[string] {
+  return {
+    ...definition,
+    options: definition.options ? [...definition.options] : undefined,
+    props: definition.props ? { ...definition.props } : undefined,
+    sidebar: typeof definition.sidebar === 'object' && definition.sidebar !== null
+      ? { ...definition.sidebar }
+      : definition.sidebar,
+  }
+}

package/src/templates/controlSchemaConstants.ts

@@ -0,0 +1,11 @@
+export const ICONS = {
+  plate: ['M4 4h16v16H4z', 'M8 4v16', 'M12 4v16', 'M16 4v16', 'M4 8h16', 'M4 12h16', 'M4 16h16'],
+  samples: ['M16 21v-2a4 4 0 0 0-8 0v2', 'M12 11a4 4 0 1 0 0-8 4 4 0 0 0 0 8'],
+  dose: ['M10 2v8L4 20h16l-6-10V2', 'M8 2h8', 'M7 14h10'],
+  table: ['M3 5h18', 'M3 12h18', 'M3 19h18', 'M8 5v14', 'M16 5v14'],
+  run: ['M4 17l6-6 4 4 6-8', 'M4 21h16'],
+  settings: ['M12 8a4 4 0 1 0 0 8 4 4 0 0 0 0-8', 'M4 12h2', 'M18 12h2', 'M12 4v2', 'M12 18v2'],
+}
+
+export const PLATE_FORMAT_OPTIONS = [6, 12, 24, 48, 96, 384] as const
+export const CONCENTRATION_UNITS = ['nM', 'uM', 'mM', 'ug/mL', 'mg/mL'] as const

package/src/templates/controlSchemaMerge.ts

@@ -0,0 +1,40 @@
+import {
+  getBioTemplateInfo,
+} from './catalog'
+import {
+  cloneControlDefinition,
+} from './controlSchemaClone'
+import type {
+  BioTemplateControlSchema,
+} from './controlSchemaTypes'
+import type {
+  TemplateId,
+} from './types'
+
+export function mergeTemplateControlSchemas(
+  templateIds: TemplateId[],
+  templateSchemas: Record<TemplateId, BioTemplateControlSchema>
+): BioTemplateControlSchema {
+  const merged: BioTemplateControlSchema = {}
+  for (const templateId of templateIds) {
+    const schema = templateSchemas[templateId]
+    const template = getBioTemplateInfo(templateId)
+    for (const [name, definition] of Object.entries(schema)) {
+      const key = `${camelize(templateId)}${capitalize(name)}`
+      merged[key] = {
+        ...cloneControlDefinition(definition),
+        section: definition.section ?? templateId,
+        sectionLabel: definition.sectionLabel ?? template?.label ?? templateId,
+      }
+    }
+  }
+  return merged
+}
+
+function camelize(value: string): string {
+  return value.replace(/-([a-z0-9])/g, (_, char: string) => char.toUpperCase())
+}
+
+function capitalize(value: string): string {
+  return value.charAt(0).toUpperCase() + value.slice(1)
+}

package/src/templates/controlSchemaTargets.ts

@@ -0,0 +1,87 @@
+import {
+  getBioTemplateInfo,
+} from './catalog'
+import {
+  getBioTemplatePackInfo,
+} from './packs'
+import {
+  getBioTemplatePresetInfo,
+} from './presets'
+import {
+  extractTemplateCollection,
+} from './templateEnvelopes'
+import type {
+  BioTemplateEnvelope,
+  TemplateId,
+  TemplatePresetId,
+} from './types'
+import type {
+  BioTemplateControlTarget,
+} from './controlSchemaTypes'
+
+export type ControlSchemaResolvedTarget =
+  | { kind: 'template'; name: TemplateId }
+  | { kind: 'pack'; templates: TemplateId[] }
+  | { kind: 'preset'; name: TemplatePresetId }
+  | { kind: 'collection'; templates: TemplateId[] }
+
+export function resolveControlSchemaTarget(
+  target: BioTemplateControlTarget
+): ControlSchemaResolvedTarget | undefined {
+  if (typeof target === 'string') {
+    const preset = getBioTemplatePresetInfo(target)
+    if (preset) return { kind: 'preset', name: preset.name }
+    const pack = getBioTemplatePackInfo(target)
+    if (pack) return { kind: 'pack', templates: [...pack.templates] }
+    const template = getBioTemplateInfo(target)
+    if (template) return { kind: 'template', name: template.template_id }
+    return undefined
+  }
+
+  if (isTemplateEnvelope(target)) {
+    const template = getBioTemplateInfo(target.template_id)
+    return template ? { kind: 'template', name: template.template_id } : undefined
+  }
+
+  const presetName = collectionPresetName(target)
+  if (presetName) {
+    const preset = getBioTemplatePresetInfo(presetName)
+    if (preset) return { kind: 'preset', name: preset.name }
+  }
+
+  const packName = collectionPackName(target)
+  if (packName) {
+    const pack = getBioTemplatePackInfo(packName)
+    if (pack) return { kind: 'pack', templates: [...pack.templates] }
+  }
+
+  const collection = extractTemplateCollection(target)
+  const templateIds = Object.keys(collection)
+    .map(id => getBioTemplateInfo(id)?.template_id)
+    .filter((id): id is TemplateId => id !== undefined)
+  return templateIds.length > 0 ? { kind: 'collection', templates: templateIds } : undefined
+}
+
+export function describeControlTarget(target: BioTemplateControlTarget): string {
+  if (typeof target === 'string') return target
+  if (isTemplateEnvelope(target)) return target.template_id
+  return collectionPresetName(target) ?? collectionPackName(target) ?? 'template collection'
+}
+
+function isTemplateEnvelope(value: unknown): value is BioTemplateEnvelope<unknown> {
+  return isRecord(value) && typeof value.template_id === 'string' && 'data' in value
+}
+
+function collectionPresetName(value: unknown): string | undefined {
+  if (!isRecord(value) || !isRecord(value.metadata)) return undefined
+  return typeof value.metadata.preset === 'string' ? value.metadata.preset : undefined
+}
+
+function collectionPackName(value: unknown): string | undefined {
+  if (!isRecord(value) || !isRecord(value.metadata)) return undefined
+  return typeof value.metadata.pack === 'string' ? value.metadata.pack : undefined
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}

package/src/templates/controlSchemaTypes.ts

@@ -0,0 +1,20 @@
+import type {
+  ControlDefinition,
+} from '../composables/controlSchemaTypes'
+import type {
+  BioTemplateEnvelope,
+  TemplateCollectionEnvelope,
+  TemplateId,
+  TemplatePackId,
+  TemplatePresetId,
+} from './types'
+
+export type BioTemplateControlSchema = Record<string, ControlDefinition>
+
+export type BioTemplateControlTarget =
+  | TemplateId
+  | TemplatePackId
+  | TemplatePresetId
+  | string
+  | BioTemplateEnvelope<unknown>
+  | TemplateCollectionEnvelope

package/src/templates/controlSchemas.ts

@@ -0,0 +1,104 @@
+import {
+  controlsToFormSchema,
+  controlsToSectionFormSchemas,
+  controlsToSidebarPanels,
+  getControlDefaults,
+  useControlSchema,
+  type ControlSchemaOptions,
+  type UseControlSchemaReturn,
+} from '../composables/useControlSchema'
+import {
+  cloneControlSchema,
+  cloneSchemaMap,
+} from './controlSchemaClone'
+import {
+  mergeTemplateControlSchemas,
+} from './controlSchemaMerge'
+import {
+  describeControlTarget,
+  resolveControlSchemaTarget,
+} from './controlSchemaTargets'
+import {
+  presetControlSchemas,
+} from './presetControlSchemas'
+import {
+  templateControlSchemas,
+} from './templateControlSchemas'
+import type {
+  TemplateId,
+  TemplatePresetId,
+} from './types'
+import type {
+  BioTemplateControlSchema,
+  BioTemplateControlTarget,
+} from './controlSchemaTypes'
+
+export type {
+  BioTemplateControlSchema,
+  BioTemplateControlTarget,
+} from './controlSchemaTypes'
+
+export function listBioTemplateControlSchemas(): Record<TemplateId, BioTemplateControlSchema> {
+  return cloneSchemaMap(templateControlSchemas)
+}
+
+export function listBioTemplatePresetControlSchemas(): Record<TemplatePresetId, BioTemplateControlSchema> {
+  return cloneSchemaMap(presetControlSchemas)
+}
+
+export function getBioTemplateControlSchema(
+  target: BioTemplateControlTarget
+): BioTemplateControlSchema | undefined {
+  const resolved = resolveControlSchemaTarget(target)
+  if (!resolved) return undefined
+
+  if (resolved.kind === 'template') {
+    return cloneControlSchema(templateControlSchemas[resolved.name])
+  }
+  if (resolved.kind === 'preset') {
+    return cloneControlSchema(presetControlSchemas[resolved.name])
+  }
+  return mergeTemplateControlSchemas(resolved.templates, templateControlSchemas)
+}
+
+export function requireBioTemplateControlSchema(
+  target: BioTemplateControlTarget
+): BioTemplateControlSchema {
+  const schema = getBioTemplateControlSchema(target)
+  if (!schema) {
+    throw new Error(`No built-in control schema found for '${describeControlTarget(target)}'.`)
+  }
+  return schema
+}
+
+export function createBioTemplateControlToolkit(
+  target: BioTemplateControlTarget,
+  options: ControlSchemaOptions = {}
+): UseControlSchemaReturn<BioTemplateControlSchema> {
+  return useControlSchema(requireBioTemplateControlSchema(target), options)
+}
+
+export function bioTemplateControlsToFormSchema(
+  target: BioTemplateControlTarget,
+  options: ControlSchemaOptions = {}
+) {
+  return controlsToFormSchema(requireBioTemplateControlSchema(target), options)
+}
+
+export function bioTemplateControlsToSidebarPanels(
+  target: BioTemplateControlTarget,
+  options: ControlSchemaOptions = {}
+) {
+  return controlsToSidebarPanels(requireBioTemplateControlSchema(target), options)
+}
+
+export function bioTemplateControlsToSectionFormSchemas(
+  target: BioTemplateControlTarget,
+  options: ControlSchemaOptions = {}
+) {
+  return controlsToSectionFormSchemas(requireBioTemplateControlSchema(target), options)
+}
+
+export function getBioTemplateControlDefaults(target: BioTemplateControlTarget) {
+  return getControlDefaults(requireBioTemplateControlSchema(target))
+}

package/src/templates/defaultBioTemplateBuilder.ts

@@ -0,0 +1,124 @@
+import { getBioTemplateInfo } from './catalog'
+import { createAssayMatrixTemplate } from './assayMatrixBuilder'
+import { createCalibrationCurveTemplate } from './calibrationCurveBuilder'
+import { createDoseResponseTemplate } from './doseResponseBuilder'
+import { createFlowCytometryPanelTemplate } from './flowCytometryPanelBuilder'
+import { createInstrumentRunTemplate } from './instrumentRunBuilder'
+import { createPlateMapTemplate } from './plateMapBuilder'
+import { createProtocolStepsTemplate } from './protocolStepsBuilder'
+import { createQpcrPlateTemplate } from './qpcrPlateBuilder'
+import { createReagentListTemplate } from './reagentListBuilder'
+import { createSamplePrepTemplate } from './samplePrepBuilder'
+import { createSampleSheetTemplate } from './sampleSheetBuilder'
+import { createTimeCourseTemplate } from './timeCourseBuilder'
+import type {
+  BioTemplateEnvelope,
+  TemplateId,
+} from './types'
+
+export function createDefaultBioTemplate(templateId: TemplateId | string): BioTemplateEnvelope<unknown> {
+  const template = getBioTemplateInfo(templateId)
+  if (!template) {
+    throw new Error(`Unknown bio template '${templateId}'.`)
+  }
+
+  switch (template.template_id) {
+    case 'plate-map':
+      return createPlateMapTemplate({
+        name: 'Plate 1',
+        samples: ['Control', 'Treatment'],
+      })
+    case 'sample-sheet':
+      return createSampleSheetTemplate({
+        samples: [
+          { sampleId: 'S001', name: 'Control 1', group: 'Control' },
+          { sampleId: 'S002', name: 'Treatment 1', group: 'Treatment' },
+        ],
+      })
+    case 'sample-prep':
+      return createSamplePrepTemplate({
+        samples: ['S001', 'S002'],
+        prepType: 'extraction',
+        outputVolume: 50,
+      })
+    case 'dose-response':
+      return createDoseResponseTemplate({
+        compounds: {
+          'Compound A': [10, 1, 0.1],
+        },
+        unit: 'uM',
+        replicates: 3,
+      })
+    case 'calibration-curve':
+      return createCalibrationCurveTemplate({
+        concentrations: [0.1, 1, 10, 100],
+        analyte: 'Analyte',
+        unit: 'uM',
+      })
+    case 'time-course':
+      return createTimeCourseTemplate({
+        timepoints: [0, 6, 24],
+        unit: 'hour',
+        conditions: ['Control', 'Treatment'],
+        replicates: 3,
+      })
+    case 'protocol-steps':
+      return createProtocolStepsTemplate({
+        steps: [
+          {
+            id: 'seed-cells',
+            type: 'addition',
+            name: 'Seed cells',
+            description: 'Add cells to wells or culture vessels.',
+            duration: 15,
+          },
+          {
+            id: 'incubate-overnight',
+            type: 'incubation',
+            name: 'Incubate overnight',
+            duration: 960,
+            parameters: { temperature: '37 C', co2: '5%' },
+          },
+          {
+            id: 'measure-readout',
+            type: 'measurement',
+            name: 'Measure readout',
+            duration: 45,
+          },
+        ],
+      })
+    case 'assay-matrix':
+      return createAssayMatrixTemplate({
+        samples: ['S001', 'S002'],
+        features: ['Lactate', 'Glucose'],
+        values: {
+          s001: { lactate: 1.2, glucose: 5.4 },
+          s002: { lactate: 2.1, glucose: 4.8 },
+        },
+      })
+    case 'reagent-list':
+      return createReagentListTemplate({
+        reagents: ['DMSO', 'Compound A', 'Anti-HA antibody'],
+      })
+    case 'flow-cytometry-panel':
+      return createFlowCytometryPanelTemplate({
+        markers: ['CD3', 'CD4', 'CD8'],
+        instrument: 'BD LSRFortessa',
+      })
+    case 'instrument-run':
+      return createInstrumentRunTemplate({
+        items: ['S001', 'S002'],
+        instrument: 'LC-MS',
+        method: 'Default method',
+      })
+    case 'qpcr-plate':
+      return createQpcrPlateTemplate({
+        samples: ['Control', 'Treatment'],
+        targets: ['ACTB', 'GAPDH'],
+        replicates: 3,
+        instrument: 'QuantStudio',
+      })
+    default:
+      throw new Error(`Unknown bio template '${templateId}'.`)
+  }
+}

package/src/templates/doseResponseAdapters.ts

@@ -0,0 +1,45 @@
+import type {
+  PlateCondition,
+  PlateMapEditorState,
+} from '../types'
+import { toPlateMapEditorState } from './plateMapAdapters'
+import { getTemplateData } from './templateEnvelopes'
+import { validateDoseResponseData } from './templateValidators'
+import type {
+  DoseConditionsAdapterResult,
+  DoseResponseTemplate,
+  DoseResponseTemplateData,
+} from './types'
+
+const CONDITION_COLORS = [
+  '#3B82F6',
+  '#10B981',
+  '#EF4444',
+  '#F59E0B',
+  '#8B5CF6',
+  '#F97316',
+  '#06B6D4',
+  '#14B8A6',
+  '#6B7280',
+]
+
+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
+}

package/src/templates/doseResponseBuilder.ts

@@ -0,0 +1,44 @@
+import { compoundIdFromName } from './builderIdUtils'
+import {
+  normalizeCompound,
+  normalizeControl,
+} from './calibrationNormalizers'
+import {
+  createTemplateEnvelope,
+  getTemplateData,
+} from './templateEnvelopes'
+import { validateDoseResponseData } from './templateValidators'
+import type {
+  CreateDoseResponseTemplateOptions,
+  DoseResponseTemplate,
+  DoseResponseTemplateData,
+  PlateMapTemplateData,
+} from './types'
+
+export function createDoseResponseTemplate(
+  options: CreateDoseResponseTemplateOptions
+): DoseResponseTemplate {
+  const compounds = Array.isArray(options.compounds)
+    ? options.compounds.map(normalizeCompound)
+    : Object.entries(options.compounds).map(([name, concentrations], index) => normalizeCompound({
+      id: compoundIdFromName(name, index),
+      name,
+      concentrations,
+      metadata: {},
+    }))
+
+  const layout = options.layout
+    ? getTemplateData<PlateMapTemplateData>(options.layout)
+    : undefined
+
+  const data: DoseResponseTemplateData = {
+    compounds,
+    unit: options.unit,
+    replicates: options.replicates ?? 1,
+    controls: (options.controls ?? []).map(normalizeControl),
+    layout,
+    metadata: options.metadata ?? {},
+  }
+  validateDoseResponseData(data)
+  return createTemplateEnvelope('dose-response', data, options.metadata ?? {})
+}

package/src/templates/elisaAssayCollectionBuilder.ts

@@ -0,0 +1,62 @@
+import { createAssayMatrixTemplate } from './assayMatrixBuilder'
+import { DEFAULT_SAMPLE_COLORS } from './builderDefaults'
+import { idFromName } from './builderIdUtils'
+import { createCalibrationCurveTemplate } from './calibrationCurveBuilder'
+import { createPlateMapTemplate } from './plateMapBuilder'
+import { createSampleSheetTemplate } from './sampleSheetBuilder'
+import { presetSampleRecords } from './sampleNormalizers'
+import { createTemplateCollection } from './templateEnvelopes'
+import type {
+  CreateElisaAssayCollectionOptions,
+  TemplateCollectionEnvelope,
+} from './types'
+
+export function createElisaAssayCollection(
+  options: CreateElisaAssayCollectionOptions = {}
+): TemplateCollectionEnvelope {
+  const sampleRecords = presetSampleRecords(options.samples ?? ['Control', 'Treatment'])
+  const analyte = options.analyte ?? 'Analyte'
+  const responseUnit = options.responseUnit ?? 'OD450'
+  const plate = createPlateMapTemplate({
+    name: options.plateName ?? 'ELISA plate',
+    format: options.plateFormat ?? 96,
+    samples: [
+      { id: 'blank', name: 'Blank' },
+      { id: 'standard', name: 'Standards' },
+      { id: 'qc', name: 'QC' },
+      ...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 calibrationCurve = createCalibrationCurveTemplate({
+    concentrations: options.standardConcentrations ?? [1000, 100, 10, 1],
+    analyte,
+    unit: options.unit ?? 'pg/mL',
+    responseUnit,
+    model: 'four-parameter-logistic',
+  })
+  const assayMatrix = createAssayMatrixTemplate({
+    samples: sampleRecords.map(sample => ({
+      sampleId: sample.sampleId,
+      name: sample.name,
+      group: sample.group,
+      metadata: sample.metadata ?? {},
+    })),
+    features: [{
+      id: idFromName(analyte, 'analyte'),
+      name: analyte,
+      type: 'protein',
+      unit: responseUnit,
+      metadata: {},
+    }],
+    metadata: { analyte, responseUnit },
+  })
+  return createTemplateCollection(
+    [plate, sampleSheet, calibrationCurve, assayMatrix],
+    { preset: 'elisa-assay', ...(options.metadata ?? {}) }
+  )
+}