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

package/src/templates/calibrationCurveAdapters.ts

@@ -0,0 +1,59 @@
+import { getTemplateData } from './templateEnvelopes'
+import { validateCalibrationCurveData } from './templateValidators'
+import type {
+  CalibrationCurveColumnsAdapterResult,
+  CalibrationCurveDataFrameAdapterResult,
+  CalibrationCurveRowsAdapterResult,
+  CalibrationCurveTemplate,
+  CalibrationCurveTemplateData,
+} from './types'
+
+export function toCalibrationCurveRows(
+  template: CalibrationCurveTemplate | CalibrationCurveTemplateData
+): CalibrationCurveRowsAdapterResult {
+  const data = getTemplateData(template, 'calibration-curve')
+  validateCalibrationCurveData(data)
+  return [...data.points]
+    .sort((a, b) => a.order - b.order)
+    .map(point => ({
+      id: point.id,
+      order: point.order,
+      role: point.role,
+      level: point.level,
+      concentration: point.concentration,
+      unit: point.unit,
+      expectedResponse: point.expectedResponse,
+      response: point.response,
+      replicate: point.replicate,
+      include: point.include,
+      status: point.status,
+      analyte: data.analyte,
+      model: data.model,
+      ...(point.metadata ?? {}),
+    }))
+}
+
+export function toCalibrationCurveColumns(): CalibrationCurveColumnsAdapterResult {
+  return [
+    { key: 'order', label: 'Order', sortable: true, align: 'right' },
+    { key: 'role', label: 'Role', sortable: true },
+    { key: 'level', label: 'Level', sortable: true },
+    { key: 'concentration', label: 'Concentration', sortable: true, align: 'right' },
+    { key: 'unit', label: 'Unit', sortable: true },
+    { key: 'expectedResponse', label: 'Expected', sortable: true, align: 'right' },
+    { key: 'response', label: 'Response', sortable: true, align: 'right' },
+    { key: 'replicate', label: 'Replicate', sortable: true, align: 'right' },
+    { key: 'include', label: 'Include', sortable: true },
+    { key: 'status', label: 'Status', sortable: true },
+  ]
+}
+
+export function toCalibrationCurveDataFrame(
+  template: CalibrationCurveTemplate | CalibrationCurveTemplateData
+): CalibrationCurveDataFrameAdapterResult {
+  return {
+    data: toCalibrationCurveRows(template),
+    columns: toCalibrationCurveColumns(),
+    rowKey: 'id',
+  }
+}

package/src/templates/calibrationCurveBuilder.ts

@@ -0,0 +1,99 @@
+import { idFromName } from './builderIdUtils'
+import {
+  normalizeCalibrationAcceptance,
+  normalizeCalibrationPoint,
+} from './calibrationNormalizers'
+import { createTemplateEnvelope } from './templateEnvelopes'
+import { validateCalibrationCurveData } from './templateValidators'
+import type {
+  CalibrationCurveTemplate,
+  CalibrationCurveTemplateData,
+  CalibrationPoint,
+  CreateCalibrationCurveTemplateOptions,
+} from './types'
+
+export function createCalibrationCurveTemplate(
+  options: CreateCalibrationCurveTemplateOptions
+): CalibrationCurveTemplate {
+  const unit = options.unit ?? 'uM'
+  const points: CalibrationPoint[] = []
+  let order = 1
+
+  if (options.includeBlank !== false) {
+    points.push({
+      id: 'blank',
+      order,
+      role: 'blank',
+      level: 'Blank',
+      concentration: 0,
+      unit,
+      replicate: 1,
+      include: true,
+      status: 'planned',
+      metadata: {},
+    })
+    order += 1
+  }
+
+  const standardValues: number[] = []
+  for (const [index, concentration] of options.concentrations.entries()) {
+    if (typeof concentration !== 'number') {
+      const point = normalizeCalibrationPoint(concentration, unit, order, index)
+      points.push(point)
+      if (point.role === 'standard') standardValues.push(point.concentration)
+      order = Math.max(order, point.order + 1)
+      continue
+    }
+    standardValues.push(concentration)
+    points.push({
+      id: `std-${index + 1}`,
+      order,
+      role: 'standard',
+      level: `Standard ${index + 1}`,
+      concentration,
+      unit,
+      replicate: 1,
+      include: true,
+      status: 'planned',
+      metadata: {},
+    })
+    order += 1
+  }
+
+  if (options.includeQc !== false) {
+    const positiveValues = [...standardValues].filter(value => value > 0).sort((a, b) => a - b)
+    const qcValues = positiveValues.length === 0
+      ? []
+      : positiveValues[0] === positiveValues[positiveValues.length - 1]
+        ? [positiveValues[0]]
+        : [positiveValues[0], positiveValues[positiveValues.length - 1]]
+    for (const [index, concentration] of qcValues.entries()) {
+      const level = index === 0 ? 'QC low' : 'QC high'
+      points.push({
+        id: idFromName(level, `qc-${index + 1}`),
+        order,
+        role: 'qc',
+        level,
+        concentration,
+        unit,
+        replicate: 1,
+        include: true,
+        status: 'planned',
+        metadata: {},
+      })
+      order += 1
+    }
+  }
+
+  const data: CalibrationCurveTemplateData = {
+    analyte: options.analyte ?? 'Analyte',
+    model: options.model ?? 'linear',
+    xUnit: unit,
+    responseUnit: options.responseUnit ?? 'response',
+    points,
+    acceptance: normalizeCalibrationAcceptance(options.acceptance, options.includeBlank !== false),
+    metadata: options.metadata ?? {},
+  }
+  validateCalibrationCurveData(data)
+  return createTemplateEnvelope('calibration-curve', data, options.metadata ?? {})
+}

package/src/templates/calibrationNormalizers.ts

@@ -0,0 +1,60 @@
+import type {
+  CalibrationAcceptance,
+  CalibrationPoint,
+  CalibrationPointInput,
+  CompoundDoseSeries,
+  ControlDefinition,
+} from './types'
+import { idFromName } from './builderIdUtils'
+
+export function normalizeCompound(compound: CompoundDoseSeries): CompoundDoseSeries {
+  return {
+    ...compound,
+    concentrations: [...compound.concentrations].sort((a, b) => b - a),
+    metadata: compound.metadata ?? {},
+  }
+}
+
+export function normalizeCalibrationAcceptance(
+  acceptance?: Partial<CalibrationAcceptance>,
+  requireBlank = true
+): CalibrationAcceptance {
+  return {
+    minRSquared: acceptance?.minRSquared ?? 0.99,
+    standardTolerancePercent: acceptance?.standardTolerancePercent ?? 15,
+    qcTolerancePercent: acceptance?.qcTolerancePercent ?? 20,
+    requireBlank: acceptance?.requireBlank ?? requireBlank,
+    metadata: acceptance?.metadata ?? {},
+  }
+}
+
+export function normalizeCalibrationPoint(
+  point: CalibrationPointInput,
+  unit: string,
+  order: number,
+  index: number
+): CalibrationPoint {
+  const role = point.role ?? 'standard'
+  const level = point.level || `${role.charAt(0).toUpperCase()}${role.slice(1)} ${index + 1}`
+  return {
+    id: point.id || idFromName(level, `${role}-${index + 1}`),
+    order: point.order ?? order,
+    role,
+    level,
+    concentration: point.concentration ?? 0,
+    unit: point.unit || unit,
+    expectedResponse: point.expectedResponse,
+    response: point.response,
+    replicate: point.replicate ?? 1,
+    include: point.include ?? true,
+    status: point.status ?? 'planned',
+    metadata: point.metadata ?? {},
+  }
+}
+
+export function normalizeControl(control: ControlDefinition): ControlDefinition {
+  return {
+    ...control,
+    metadata: control.metadata ?? {},
+  }
+}

package/src/templates/componentBindingCatalog.ts

@@ -0,0 +1,90 @@
+import type { TemplateId } from './types'
+
+interface ComponentBinding {
+  id: string
+  template_id: TemplateId
+  component: string
+  adapters: readonly string[]
+  props: readonly string[]
+  description: string
+  importPath: '@morscherlab/mint-sdk'
+}
+
+export const templateComponentBindings = {
+  'plate-map': [
+    binding('plate-map', 'PlateMapEditor', ['toPlateMapEditorState'], ['modelValue', 'format', 'samples'], 'Edit plate layouts from plate-map template data.'),
+    binding('plate-map', 'WellPlate', ['toWellPlateWells'], ['format', 'wells', 'sampleColors', 'legendItems'], 'Render the active plate as a well grid.'),
+  ],
+  'sample-sheet': [
+    binding('sample-sheet', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render sample metadata as a sortable table.'),
+    binding('sample-sheet', 'SampleSelector', ['toSampleOptions'], ['samples', 'modelValue'], 'Select samples from sample-sheet records.'),
+  ],
+  'sample-prep': [
+    binding('sample-prep', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render preparation steps as a table.'),
+  ],
+  'dose-response': [
+    binding('dose-response', 'DoseCalculator', ['toDoseConditions'], ['mode', 'targetWells'], 'Configure serial dilution and apply concentrations to wells.'),
+    binding('dose-response', 'WellPlate', ['toDoseLayoutState'], ['format', 'wells', 'sampleColors', 'legendItems'], 'Render the optional dose-response plate layout.'),
+  ],
+  'calibration-curve': [
+    binding('calibration-curve', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render standards, QC, blanks, and response values.'),
+  ],
+  'time-course': [
+    binding('time-course', 'ExperimentTimeline', ['toTimeCourseSteps'], ['modelValue', 'orientation'], 'Render time points as an ordered timeline.'),
+    binding('time-course', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render longitudinal samples as a table.'),
+  ],
+  'protocol-steps': [
+    binding('protocol-steps', 'ExperimentTimeline', ['toProtocolSteps'], ['modelValue', 'orientation', 'editable'], 'Render protocol steps as an editable timeline.'),
+    binding('protocol-steps', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render protocol steps as a table.'),
+  ],
+  'assay-matrix': [
+    binding('assay-matrix', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render sample-by-feature measurements.'),
+    binding('assay-matrix', 'SampleSelector', ['toAssayMatrixSampleOptions'], ['samples', 'modelValue'], 'Select samples from assay-matrix records.'),
+  ],
+  'reagent-list': [
+    binding('reagent-list', 'ReagentList', ['toReagentListItems'], ['modelValue'], 'Render reagents with lot, storage, and stock metadata.'),
+    binding('reagent-list', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render reagents as a table.'),
+  ],
+  'flow-cytometry-panel': [
+    binding('flow-cytometry-panel', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render markers, fluorophores, detectors, and controls.'),
+  ],
+  'instrument-run': [
+    binding('instrument-run', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render acquisition queues, methods, QC, and run status.'),
+    binding(
+      'instrument-run',
+      'ScheduleCalendar',
+      ['toInstrumentRunScheduleEvents'],
+      ['modelValue', 'events', 'view', 'readonly', 'showNavigation', 'showViewToggle'],
+      'Render acquisition queues as a scheduled run calendar.',
+    ),
+    binding(
+      'instrument-run',
+      'ExperimentTimeline',
+      ['toInstrumentRunSteps'],
+      ['modelValue', 'orientation', 'showDuration', 'editable'],
+      'Render acquisition queues as an ordered run timeline.',
+    ),
+  ],
+  'qpcr-plate': [
+    binding('qpcr-plate', 'WellPlate', ['toQpcrWellPlateWells'], ['format', 'wells', 'sampleColors', 'legendItems'], 'Render qPCR reactions on a well plate.'),
+    binding('qpcr-plate', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render qPCR reactions, targets, controls, and Cq values.'),
+  ],
+} satisfies Record<TemplateId, readonly ComponentBinding[]>
+
+function binding(
+  templateId: TemplateId,
+  component: string,
+  adapters: readonly string[],
+  props: readonly string[],
+  description: string
+): ComponentBinding {
+  return {
+    id: `${templateId}:${component}`,
+    template_id: templateId,
+    component,
+    adapters,
+    props,
+    description,
+    importPath: '@morscherlab/mint-sdk',
+  }
+}

package/src/templates/componentBindingHelpers.ts

@@ -0,0 +1,93 @@
+interface CloneableComponentBinding {
+  adapters: readonly string[]
+  props: readonly string[]
+}
+
+interface NamedComponentBinding {
+  template_id: string
+  component: string
+}
+
+interface ComponentImportStatement {
+  statement: string
+}
+
+export function cloneBindingMap<TName extends string, TBinding extends CloneableComponentBinding>(
+  bindings: Record<TName, readonly TBinding[]>
+): Record<TName, TBinding[]> {
+  const result = {} as Record<TName, TBinding[]>
+  for (const name of Object.keys(bindings) as TName[]) {
+    result[name] = cloneBindings(bindings[name])
+  }
+  return result
+}
+
+export function cloneBindings<TBinding extends CloneableComponentBinding>(
+  bindings: readonly TBinding[]
+): TBinding[] {
+  return bindings.map(cloneBinding)
+}
+
+export function cloneBinding<TBinding extends CloneableComponentBinding>(binding: TBinding): TBinding {
+  return {
+    ...binding,
+    adapters: [...binding.adapters],
+    props: [...binding.props],
+  }
+}
+
+export function uniquePropsName(
+  binding: NamedComponentBinding,
+  usedNames: Map<string, number>
+): string {
+  const base = toCamelIdentifier(`${binding.template_id} ${binding.component} props`)
+  const count = usedNames.get(base) ?? 0
+  usedNames.set(base, count + 1)
+  return count === 0 ? base : `${base}${count + 1}`
+}
+
+function toCamelIdentifier(value: string): string {
+  const words = value
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+
+  if (words.length === 0) return 'componentProps'
+
+  return words
+    .map((word, index) => {
+      const lower = word.toLowerCase()
+      return index === 0 ? lower : lower.charAt(0).toUpperCase() + lower.slice(1)
+    })
+    .join('')
+}
+
+export function toVueSfc(
+  imports: readonly ComponentImportStatement[],
+  setupLines: readonly string[],
+  template: string,
+  includeTargetTypeImport: boolean
+): string {
+  const importLines = [
+    ...imports.map(item => item.statement),
+    "import { toBioTemplateComponentProps } from '@morscherlab/mint-sdk/templates'",
+    ...(includeTargetTypeImport
+      ? ["import type { BioTemplateEnvelope, TemplateCollectionEnvelope } from '@morscherlab/mint-sdk/templates'"]
+      : []),
+  ]
+  const templateLines = template
+    ? template.split('\n').map(line => `  ${line}`).join('\n')
+    : ''
+
+  return [
+    '<script setup lang="ts">',
+    ...importLines,
+    '',
+    ...setupLines,
+    '</script>',
+    '',
+    '<template>',
+    templateLines,
+    '</template>',
+  ].join('\n')
+}