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

package/src/templates/componentTemplateProps.ts

@@ -1,78 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

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