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

package/src/templates/componentBindingHelpers.ts

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

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

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

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

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

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

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

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

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