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

package/src/templates/componentPropsFactory.ts

@@ -0,0 +1,21 @@
+import { cloneBinding } from './componentBindingHelpers'
+import { templateComponentBindings } from './componentBindingCatalog'
+import type {
+  BioTemplateComponentPropsBinding,
+} from './componentBindings'
+import type { TemplateId } from './types'
+
+export function propsBinding(
+  templateId: TemplateId,
+  component: string,
+  propsObject: Record<string, unknown>
+): BioTemplateComponentPropsBinding {
+  const matched = templateComponentBindings[templateId].find(binding => binding.component === component)
+  if (!matched) {
+    throw new Error(`No component binding registered for '${templateId}' and '${component}'.`)
+  }
+  return {
+    ...cloneBinding(matched),
+    propsObject,
+  }
+}

package/src/templates/componentQpcrPlateProps.ts

@@ -0,0 +1,28 @@
+import type { WellLegendItem } from '../types'
+import { toQpcrWellPlateWells } from './adapters'
+import { colorForIndex } from './componentPlateHelpers'
+import { getTemplateData } from './templateEnvelopes'
+import { dataFrameProps } from './componentGenericProps'
+import { propsBinding } from './componentPropsFactory'
+import type { BioTemplateComponentPropsBinding } from './componentBindings'
+import type { QpcrPlateTemplate } from './types'
+
+export function qpcrPlateProps(template: QpcrPlateTemplate): BioTemplateComponentPropsBinding[] {
+  const data = getTemplateData(template, 'qpcr-plate')
+  const frame = dataFrameProps(template)
+  return [
+    propsBinding('qpcr-plate', 'WellPlate', {
+      format: data.format,
+      wells: toQpcrWellPlateWells(template),
+      sampleColors: Object.fromEntries(data.samples.map((sample, index) => [sample.sampleId, colorForIndex(index)])),
+      legendItems: data.samples.map((sample, index): WellLegendItem => ({
+        type: sample.sampleId,
+        label: sample.name ?? sample.sampleId,
+        color: colorForIndex(index),
+      })),
+      showLegend: true,
+      showSampleTypeIndicator: true,
+    }),
+    frame,
+  ]
+}

package/src/templates/componentTargetResolvers.ts

@@ -0,0 +1,69 @@
+import { extractTemplateCollection } from './templateEnvelopes'
+import { getBioTemplateInfo } from './catalog'
+import { getBioTemplatePackInfo } from './packs'
+import { getBioTemplatePresetInfo } from './presets'
+import type {
+  BioTemplateEnvelope,
+  TemplateCollectionEnvelope,
+  TemplateId,
+  TemplatePackId,
+  TemplatePresetId,
+} from './types'
+
+type BioTemplateComponentTarget =
+  | TemplateId
+  | TemplatePackId
+  | TemplatePresetId
+  | string
+  | BioTemplateEnvelope<unknown>
+  | TemplateCollectionEnvelope
+
+export function resolveComponentTemplateIds(target: BioTemplateComponentTarget): TemplateId[] {
+  if (typeof target === 'string') {
+    const preset = getBioTemplatePresetInfo(target)
+    if (preset) return [...preset.templates]
+    const pack = getBioTemplatePackInfo(target)
+    if (pack) return [...pack.templates]
+    const template = getBioTemplateInfo(target)
+    return template ? [template.template_id] : []
+  }
+
+  if (isTemplateEnvelope(target)) {
+    const template = getBioTemplateInfo(target.template_id)
+    return template ? [template.template_id] : []
+  }
+
+  const presetName = collectionPresetName(target)
+  if (presetName) {
+    const preset = getBioTemplatePresetInfo(presetName)
+    if (preset) return [...preset.templates]
+  }
+
+  const packName = collectionPackName(target)
+  if (packName) {
+    const pack = getBioTemplatePackInfo(packName)
+    if (pack) return [...pack.templates]
+  }
+
+  return Object.keys(extractTemplateCollection(target))
+    .map(templateId => getBioTemplateInfo(templateId)?.template_id)
+    .filter((templateId): templateId is TemplateId => templateId !== undefined)
+}
+
+export 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/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/useControlSchema'
+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