@morscherlab/mint-sdk 1.3.11 → 1.4.0-beta.10

package/src/templates/componentBindingCatalog.ts

@@ -1,90 +0,0 @@
-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', 'PlateEditor', ['toPlateMapEditorState', 'racksFromPlateState'], ['modelValue', 'activeRackId', 'groups', 'formats', 'wellFields'], 'Edit plate layouts and assign sample groups 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

@@ -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,279 +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
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function listBioTemplateComponentBindings(): Record<TemplateId, BioTemplateComponentBinding[]> {
-  return cloneBindingMap(templateComponentBindings)
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function getBioTemplateComponentBindings(
-  target: BioTemplateComponentTarget
-): BioTemplateComponentBinding[] {
-  const templateIds = resolveComponentTemplateIds(target)
-  return templateIds.flatMap(templateId => cloneBindings(templateComponentBindings[templateId]))
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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.
- *
- * @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins.
- */
-export function toBioTemplateComponentBindings(
-  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
-): BioTemplateResolvedComponentBinding[] {
-  return toBioTemplateComponentProps(target).map(toResolvedComponentBinding)
-}
-
-/**
- * Return resolved component bindings keyed by stable template component id.
- *
- * @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins.
- */
-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.
- *
- * @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins.
- */
-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.
- *
- * @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins.
- */
-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.
- *
- * @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins.
- */
-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,
-  }
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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}'`,
-  }))
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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}" />`,
-    }
-  })
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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,41 +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,
-    }))
-  }
-
-  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,52 +0,0 @@
-import type {
-  PlateMapEditorState,
-  Rack,
-  Well,
-  WellLegendItem,
-} from '../types'
-import { SAMPLE_COLOR_SCALE, SLOT_ORDER } from '../utils/color'
-
-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 {
-  // The gray tail of the scale is reserved for "other"; component plates cycle the eight hues.
-  const colors = SAMPLE_COLOR_SCALE.slice(0, 8)
-  return colors[index % colors.length]
-}
-
-/**
- * Plates as PlateEditor racks: slots assigned in order, a well's sample id moved to its group (the stored
- * plate map keeps it in `sampleType`). Plate maps carry no injection volume.
- * @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins.
- */
-export function racksFromPlateState(state: PlateMapEditorState): Rack[] {
-  const sampleIds = new Set(state.samples.map(sample => sample.id))
-  const asRackWell = (well: Well): Partial<Well> =>
-    well.sampleType && sampleIds.has(well.sampleType) ? { ...well, sampleType: 'sample', group: well.sampleType } : well
-  return state.plates.map((plate, index) => ({
-    id: plate.id,
-    name: plate.name,
-    format: plate.format,
-    slot: SLOT_ORDER[index % SLOT_ORDER.length],
-    injectionVolume: 0,
-    wells: Object.fromEntries(Object.entries(plate.wells).map(([id, well]) => [id, asRackWell(well)])),
-  }))
-}

package/src/templates/componentPlateMapProps.ts

@@ -1,34 +0,0 @@
-import {
-  toPlateMapEditorState,
-  toWellPlateWells,
-} from './adapters'
-import {
-  activePlateFromState,
-  legendItemsFromPlateState,
-  racksFromPlateState,
-  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', 'PlateEditor', {
-      modelValue: racksFromPlateState(state),
-      activeRackId: plate.id,
-      groups: state.samples,
-      formats: [plate.format],
-      wellFields: false,
-    }),
-    propsBinding('plate-map', 'WellPlate', {
-      format: plate.format,
-      wells: toWellPlateWells(template),
-      sampleColors: sampleColorsFromPlateState(state),
-      legendItems: legendItemsFromPlateState(state),
-      showLegend: 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,
-  }
-}