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

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')
+}

package/src/templates/componentBindings.ts

@@ -0,0 +1,253 @@
+import { extractTemplateCollection } from './templateEnvelopes'
+import {
+  isTemplateEnvelope,
+  resolveComponentTemplateIds,
+} from './componentTargetResolvers'
+import {
+  cloneBinding,
+  cloneBindingMap,
+  cloneBindings,
+  toVueSfc,
+  uniquePropsName,
+} from './componentBindingHelpers'
+import { templateComponentBindings } from './componentBindingCatalog'
+import { propsForTemplate } from './componentTemplateProps'
+import type {
+  BioTemplateEnvelope,
+  TemplateCollectionEnvelope,
+  TemplateId,
+  TemplatePackId,
+  TemplatePresetId,
+} from './types'
+
+export type BioTemplateComponentTarget =
+  | TemplateId
+  | TemplatePackId
+  | TemplatePresetId
+  | string
+  | BioTemplateEnvelope<unknown>
+  | TemplateCollectionEnvelope
+
+export interface BioTemplateComponentBinding {
+  id: string
+  template_id: TemplateId
+  component: string
+  adapters: readonly string[]
+  props: readonly string[]
+  description: string
+  importPath: '@morscherlab/mint-sdk'
+}
+
+export interface BioTemplateComponentPropsBinding extends BioTemplateComponentBinding {
+  propsObject: Record<string, unknown>
+}
+
+export interface BioTemplateResolvedComponentBinding extends Omit<BioTemplateComponentBinding, 'props'> {
+  /** Prop names advertised by the static template/component compatibility catalog. */
+  propNames: readonly string[]
+  /** Concrete props ready for direct `v-bind="componentBindingsById[id].props"` use. */
+  props: Record<string, unknown>
+  /** Backward-compatible alias for callers that already consume componentProps entries. */
+  propsObject: Record<string, unknown>
+}
+
+export type BioTemplateComponentBindingsById = Record<string, BioTemplateResolvedComponentBinding>
+export type BioTemplateComponentPropsById = Record<string, Record<string, unknown>>
+export type BioTemplateComponentPropsByComponent = Record<string, Record<string, unknown>[]>
+
+export interface BioTemplateComponentPropsLookupOptions {
+  templateId?: TemplateId
+  id?: string
+}
+
+export interface BioTemplateComponentImport {
+  importPath: BioTemplateComponentBinding['importPath']
+  components: string[]
+  statement: string
+}
+
+export interface BioTemplateComponentSnippet extends BioTemplateComponentBinding {
+  propsName: string
+  propsExpression: string
+  template: string
+}
+
+export interface BioTemplateComponentSnippetOptions {
+  propsVariable?: string
+}
+
+export interface BioTemplateComponentUsageOptions extends BioTemplateComponentSnippetOptions {
+  targetExpression?: string
+  targetPropName?: string
+}
+
+export interface BioTemplateComponentUsage {
+  imports: BioTemplateComponentImport[]
+  componentProps: BioTemplateComponentPropsBinding[]
+  snippets: BioTemplateComponentSnippet[]
+  propsDeclarations: string[]
+  scriptSetup: string
+  template: string
+  sfc: string
+}
+
+export function listBioTemplateComponentBindings(): Record<TemplateId, BioTemplateComponentBinding[]> {
+  return cloneBindingMap(templateComponentBindings)
+}
+
+export function getBioTemplateComponentBindings(
+  target: BioTemplateComponentTarget
+): BioTemplateComponentBinding[] {
+  const templateIds = resolveComponentTemplateIds(target)
+  return templateIds.flatMap(templateId => cloneBindings(templateComponentBindings[templateId]))
+}
+
+export function toBioTemplateComponentProps(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope
+): BioTemplateComponentPropsBinding[] {
+  if (isTemplateEnvelope(target)) {
+    return propsForTemplate(target)
+  }
+
+  const collection = extractTemplateCollection(target)
+  return Object.values(collection).flatMap(template => propsForTemplate(template))
+}
+
+/** Return resolved component bindings with concrete props for direct slot rendering. */
+export function toBioTemplateComponentBindings(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
+): BioTemplateResolvedComponentBinding[] {
+  return toBioTemplateComponentProps(target).map(toResolvedComponentBinding)
+}
+
+/** Return resolved component bindings keyed by stable template component id. */
+export function toBioTemplateComponentBindingsById(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
+): BioTemplateComponentBindingsById {
+  return Object.fromEntries(
+    toBioTemplateComponentBindings(target).map(binding => [binding.id, binding]),
+  )
+}
+
+/** Return component props keyed by stable binding id for direct `v-bind="componentPropsById[id]"` use. */
+export function toBioTemplateComponentPropsById(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
+): BioTemplateComponentPropsById {
+  return Object.fromEntries(
+    toBioTemplateComponentProps(target).map(binding => [binding.id, binding.propsObject]),
+  )
+}
+
+/** Return component props grouped by SDK component name for direct WellPlate/DoseCalculator binding. */
+export function toBioTemplateComponentPropsByComponent(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
+): BioTemplateComponentPropsByComponent {
+  const grouped: BioTemplateComponentPropsByComponent = {}
+  for (const binding of toBioTemplateComponentProps(target)) {
+    const props = grouped[binding.component] ?? []
+    props.push(binding.propsObject)
+    grouped[binding.component] = props
+  }
+  return grouped
+}
+
+/** Return the first props object for an SDK component, optionally restricted by template id or binding id. */
+export function getBioTemplateComponentProps(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
+  component: string,
+  options: BioTemplateComponentPropsLookupOptions = {},
+): Record<string, unknown> | undefined {
+  return toBioTemplateComponentProps(target).find((binding) => {
+    if (binding.component !== component) return false
+    if (options.id !== undefined && binding.id !== options.id) return false
+    if (options.templateId !== undefined && binding.template_id !== options.templateId) return false
+    return true
+  })?.propsObject
+}
+
+function toResolvedComponentBinding(
+  binding: BioTemplateComponentPropsBinding,
+): BioTemplateResolvedComponentBinding {
+  const { props: propNames, propsObject, ...rest } = binding
+  return {
+    ...rest,
+    propNames,
+    props: propsObject,
+    propsObject,
+  }
+}
+
+export function toBioTemplateComponentImports(
+  target: BioTemplateComponentTarget
+): BioTemplateComponentImport[] {
+  const groups = new Map<BioTemplateComponentBinding['importPath'], string[]>()
+
+  for (const binding of getBioTemplateComponentBindings(target)) {
+    const components = groups.get(binding.importPath) ?? []
+    if (!components.includes(binding.component)) components.push(binding.component)
+    groups.set(binding.importPath, components)
+  }
+
+  return Array.from(groups.entries()).map(([importPath, components]) => ({
+    importPath,
+    components,
+    statement: `import { ${components.join(', ')} } from '${importPath}'`,
+  }))
+}
+
+export function toBioTemplateComponentSnippets(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
+  options: BioTemplateComponentSnippetOptions = {}
+): BioTemplateComponentSnippet[] {
+  const propsVariable = options.propsVariable ?? 'componentProps'
+  const usedNames = new Map<string, number>()
+
+  return toBioTemplateComponentProps(target).map((binding, index) => {
+    const propsName = uniquePropsName(binding, usedNames)
+    const propsExpression = `${propsVariable}[${index}].propsObject`
+    return {
+      ...cloneBinding(binding),
+      propsName,
+      propsExpression,
+      template: `<${binding.component} v-bind="${propsExpression}" />`,
+    }
+  })
+}
+
+export function toBioTemplateComponentUsage(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
+  options: BioTemplateComponentUsageOptions = {}
+): BioTemplateComponentUsage {
+  const propsVariable = options.propsVariable ?? 'componentProps'
+  const usesGeneratedTargetProp = options.targetExpression === undefined
+  const targetPropName = options.targetPropName ?? 'templateCollection'
+  const targetExpression = options.targetExpression ?? `props.${targetPropName}`
+  const componentProps = toBioTemplateComponentProps(target)
+  const snippets = toBioTemplateComponentSnippets(target, { propsVariable }).map(snippet => ({
+    ...snippet,
+    propsExpression: snippet.propsName,
+    template: `<${snippet.component} v-bind="${snippet.propsName}" />`,
+  }))
+  const propsDeclarations = snippets.map(
+    (snippet, index) => `const ${snippet.propsName} = ${propsVariable}[${index}].propsObject`
+  )
+  const setupLines = [
+    ...(usesGeneratedTargetProp
+      ? [`const props = defineProps<{ ${targetPropName}: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope }>()`]
+      : []),
+    `const ${propsVariable} = toBioTemplateComponentProps(${targetExpression})`,
+    ...propsDeclarations,
+  ]
+  const imports = toBioTemplateComponentImports(target)
+  const template = snippets.map(snippet => snippet.template).join('\n')
+
+  return {
+    imports,
+    componentProps,
+    snippets,
+    propsDeclarations,
+    scriptSetup: setupLines.join('\n'),
+    template,
+    sfc: toVueSfc(imports, setupLines, template, usesGeneratedTargetProp),
+  }
+}

package/src/templates/componentDoseResponseProps.ts

@@ -0,0 +1,42 @@
+import {
+  toDoseConditions,
+  toDoseLayoutState,
+} from './adapters'
+import {
+  activePlateFromState,
+  sampleColorsFromPlateState,
+} from './componentPlateHelpers'
+import { propsBinding } from './componentPropsFactory'
+import type { BioTemplateComponentPropsBinding } from './componentBindings'
+import type { DoseResponseTemplate } from './types'
+
+export function doseResponseProps(template: DoseResponseTemplate): BioTemplateComponentPropsBinding[] {
+  const conditions = toDoseConditions(template)
+  const layout = toDoseLayoutState(template)
+  const targetWells = layout ? Object.keys(activePlateFromState(layout).wells) : []
+  const props = [
+    propsBinding('dose-response', 'DoseCalculator', {
+      mode: 'serial',
+      targetWells,
+      disabled: conditions.length === 0,
+    }),
+  ]
+
+  if (layout) {
+    const plate = activePlateFromState(layout)
+    props.push(propsBinding('dose-response', 'WellPlate', {
+      format: plate.format,
+      wells: plate.wells,
+      sampleColors: sampleColorsFromPlateState(layout),
+      legendItems: conditions.map(condition => ({
+        type: condition.label,
+        label: condition.label,
+        color: condition.color,
+      })),
+      showLegend: true,
+      showSampleTypeIndicator: true,
+    }))
+  }
+
+  return props
+}

package/src/templates/componentGenericProps.ts

@@ -0,0 +1,77 @@
+import {
+  toAssayMatrixSampleOptions,
+  toInstrumentRunScheduleEvents,
+  toReagentListItems,
+  toSampleOptions,
+  toTemplateDataFrame,
+} from './adapters'
+import { propsBinding } from './componentPropsFactory'
+import type { BioTemplateComponentPropsBinding } from './componentBindings'
+import type {
+  AssayMatrixTemplate,
+  DataFrameTemplate,
+  InstrumentRunTemplate,
+  ProtocolStepsTemplate,
+  ReagentListTemplate,
+  SampleSheetTemplate,
+  TemplateId,
+  TimeCourseTemplate,
+} from './types'
+
+export function dataFrameProps(template: DataFrameTemplate): BioTemplateComponentPropsBinding {
+  const frame = toTemplateDataFrame(template)
+  return propsBinding(template.template_id as TemplateId, 'DataFrame', {
+    ...frame,
+    searchable: true,
+    sortable: true,
+    size: 'sm',
+  })
+}
+
+export function sampleSelectorProps(template: SampleSheetTemplate): BioTemplateComponentPropsBinding {
+  const options = toSampleOptions(template)
+  return propsBinding('sample-sheet', 'SampleSelector', {
+    samples: options.map(option => option.label),
+    modelValue: [],
+  })
+}
+
+export function assayMatrixSampleSelectorProps(template: AssayMatrixTemplate): BioTemplateComponentPropsBinding {
+  const options = toAssayMatrixSampleOptions(template)
+  return propsBinding('assay-matrix', 'SampleSelector', {
+    samples: options.map(option => option.label),
+    modelValue: [],
+  })
+}
+
+export function timelineProps(
+  template: TimeCourseTemplate | ProtocolStepsTemplate | InstrumentRunTemplate,
+  steps: unknown[],
+  editable = false
+): BioTemplateComponentPropsBinding {
+  return propsBinding(template.template_id as TemplateId, 'ExperimentTimeline', {
+    modelValue: steps,
+    orientation: 'vertical',
+    editable,
+  })
+}
+
+export function scheduleCalendarProps(template: InstrumentRunTemplate): BioTemplateComponentPropsBinding {
+  const events = toInstrumentRunScheduleEvents(template)
+  return propsBinding('instrument-run', 'ScheduleCalendar', {
+    modelValue: events[0]?.start,
+    events,
+    view: 'day',
+    readonly: true,
+    showNavigation: false,
+    showViewToggle: false,
+  })
+}
+
+export function reagentListProps(template: ReagentListTemplate): BioTemplateComponentPropsBinding {
+  return propsBinding('reagent-list', 'ReagentList', {
+    modelValue: toReagentListItems(template),
+    searchable: true,
+    sortable: true,
+  })
+}

package/src/templates/componentPlateHelpers.ts

@@ -0,0 +1,29 @@
+import type {
+  PlateMapEditorState,
+  WellLegendItem,
+} from '../types'
+
+export function activePlateFromState(state: PlateMapEditorState) {
+  return state.plates.find(plate => plate.id === state.activePlateId) ?? state.plates[0]
+}
+
+export function sampleColorsFromPlateState(state: PlateMapEditorState): Record<string, string> {
+  return Object.fromEntries(
+    state.samples
+      .filter(sample => sample.color)
+      .map(sample => [sample.id, sample.color as string])
+  )
+}
+
+export function legendItemsFromPlateState(state: PlateMapEditorState): WellLegendItem[] {
+  return state.samples.map((sample, index) => ({
+    type: sample.id,
+    label: sample.name,
+    color: sample.color ?? colorForIndex(index),
+  }))
+}
+
+export function colorForIndex(index: number): string {
+  const colors = ['#3B82F6', '#10B981', '#EF4444', '#F59E0B', '#8B5CF6', '#F97316', '#06B6D4', '#14B8A6']
+  return colors[index % colors.length]
+}

package/src/templates/componentPlateMapProps.ts

@@ -0,0 +1,32 @@
+import {
+  toPlateMapEditorState,
+  toWellPlateWells,
+} from './adapters'
+import {
+  activePlateFromState,
+  legendItemsFromPlateState,
+  sampleColorsFromPlateState,
+} from './componentPlateHelpers'
+import { propsBinding } from './componentPropsFactory'
+import type { BioTemplateComponentPropsBinding } from './componentBindings'
+import type { PlateMapTemplate } from './types'
+
+export function plateMapProps(template: PlateMapTemplate): BioTemplateComponentPropsBinding[] {
+  const state = toPlateMapEditorState(template)
+  const plate = activePlateFromState(state)
+  return [
+    propsBinding('plate-map', 'PlateMapEditor', {
+      modelValue: state,
+      format: plate.format,
+      samples: state.samples,
+    }),
+    propsBinding('plate-map', 'WellPlate', {
+      format: plate.format,
+      wells: toWellPlateWells(template),
+      sampleColors: sampleColorsFromPlateState(state),
+      legendItems: legendItemsFromPlateState(state),
+      showLegend: true,
+      showSampleTypeIndicator: true,
+    }),
+  ]
+}

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
+}