@morscherlab/mint-sdk 1.3.8 → 1.4.0-beta.1

package/src/templates/instrumentRunAdapterHelpers.ts

@@ -1,94 +0,0 @@
-import type {
-  ProtocolStepStatus,
-  ProtocolStepType,
-  ScheduleEventStatus,
-} from '../types'
-import type {
-  InstrumentRunItem,
-  InstrumentRunItemKind,
-  InstrumentRunStatus,
-} from './types'
-
-export function instrumentRunStepType(kind: InstrumentRunItemKind): ProtocolStepType {
-  switch (kind) {
-    case 'wash':
-      return 'wash'
-    case 'blank':
-    case 'qc':
-    case 'standard':
-    case 'calibration':
-    case 'sample':
-      return 'measurement'
-    default:
-      return 'custom'
-  }
-}
-
-export function instrumentRunStepStatus(status: InstrumentRunStatus): ProtocolStepStatus {
-  switch (status) {
-    case 'running':
-      return 'in_progress'
-    case 'completed':
-      return 'completed'
-    case 'failed':
-      return 'failed'
-    case 'skipped':
-      return 'skipped'
-    case 'planned':
-    case 'queued':
-    default:
-      return 'pending'
-  }
-}
-
-export function instrumentRunScheduleStatus(status: InstrumentRunStatus): ScheduleEventStatus {
-  switch (status) {
-    case 'running':
-      return 'in-progress'
-    case 'completed':
-      return 'confirmed'
-    case 'failed':
-    case 'skipped':
-      return 'cancelled'
-    case 'planned':
-    case 'queued':
-    default:
-      return 'pending'
-  }
-}
-
-export function instrumentRunScheduleColor(kind: InstrumentRunItem['kind']): string {
-  switch (kind) {
-    case 'blank':
-      return '#64748b'
-    case 'qc':
-      return '#8b5cf6'
-    case 'standard':
-    case 'calibration':
-      return '#f59e0b'
-    case 'wash':
-      return '#06b6d4'
-    case 'sample':
-      return '#2563eb'
-    default:
-      return '#475569'
-  }
-}
-
-export function dateFromMetadata(
-  metadata: Record<string, unknown> | undefined,
-  keys: readonly string[]
-): Date | undefined {
-  if (!metadata) return undefined
-  for (const key of keys) {
-    const value = metadata[key]
-    if (!(typeof value === 'string' || value instanceof Date)) continue
-    const date = new Date(value)
-    if (!Number.isNaN(date.getTime())) return date
-  }
-  return undefined
-}
-
-export function addMinutes(date: Date, minutes: number): Date {
-  return new Date(date.getTime() + minutes * 60_000)
-}

package/src/templates/instrumentRunAdapters.ts

@@ -1,174 +0,0 @@
-import type {
-  ProtocolStep,
-  ScheduleEvent,
-} from '../types'
-import { getTemplateData } from './templateEnvelopes'
-import { validateInstrumentRunData } from './templateValidators'
-import type {
-  InstrumentRunColumnsAdapterResult,
-  InstrumentRunDataFrameAdapterResult,
-  InstrumentRunRowsAdapterResult,
-  InstrumentRunScheduleEventsAdapterResult,
-  InstrumentRunStepsAdapterResult,
-  InstrumentRunTemplate,
-  InstrumentRunTemplateData,
-} from './types'
-import {
-  addMinutes,
-  dateFromMetadata,
-  instrumentRunScheduleColor,
-  instrumentRunScheduleStatus,
-  instrumentRunStepStatus,
-  instrumentRunStepType,
-} from './instrumentRunAdapterHelpers'
-
-/** @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 toInstrumentRunRows(
-  template: InstrumentRunTemplate | InstrumentRunTemplateData
-): InstrumentRunRowsAdapterResult {
-  const data = getTemplateData(template, 'instrument-run')
-  validateInstrumentRunData(data)
-  const methods = new Map(data.methods.map(method => [method.id, method]))
-  return [...data.items]
-    .sort((a, b) => a.order - b.order)
-    .map(item => {
-      const method = methods.get(item.methodId)
-      return {
-        id: item.id,
-        order: item.order,
-        kind: item.kind,
-        sampleId: item.sampleId,
-        name: item.name ?? item.sampleId ?? item.kind,
-        method: method?.name ?? item.methodId,
-        vial: item.vial,
-        plateId: item.plateId,
-        wellId: item.wellId,
-        injectionVolume: item.injectionVolume,
-        expectedDurationMin: item.expectedDurationMin,
-        status: item.status,
-        instrument: data.instrument ?? method?.instrument,
-        ...(item.metadata ?? {}),
-      }
-    })
-}
-
-/** @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 toInstrumentRunColumns(): InstrumentRunColumnsAdapterResult {
-  return [
-    { key: 'order', label: 'Order', sortable: true, align: 'right' },
-    { key: 'kind', label: 'Kind', sortable: true },
-    { key: 'sampleId', label: 'Sample ID', sortable: true },
-    { key: 'name', label: 'Name', sortable: true },
-    { key: 'method', label: 'Method', sortable: true },
-    { key: 'vial', label: 'Vial', sortable: true },
-    { key: 'wellId', label: 'Well', sortable: true },
-    { key: 'injectionVolume', label: 'Injection', sortable: true, align: 'right' },
-    { key: 'expectedDurationMin', label: 'Duration', sortable: true, align: 'right' },
-    { key: 'status', label: 'Status', sortable: true },
-    { key: 'instrument', label: 'Instrument', sortable: true },
-  ]
-}
-
-/** @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 toInstrumentRunDataFrame(
-  template: InstrumentRunTemplate | InstrumentRunTemplateData
-): InstrumentRunDataFrameAdapterResult {
-  return {
-    data: toInstrumentRunRows(template),
-    columns: toInstrumentRunColumns(),
-    rowKey: 'id',
-  }
-}
-
-/**
- * Convert an instrument-run template into ExperimentTimeline protocol steps for acquisition queue previews.
- *
- * @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 toInstrumentRunSteps(
-  template: InstrumentRunTemplate | InstrumentRunTemplateData
-): InstrumentRunStepsAdapterResult {
-  const data = getTemplateData(template, 'instrument-run')
-  validateInstrumentRunData(data)
-  const methods = new Map(data.methods.map(method => [method.id, method]))
-  return [...data.items]
-    .sort((a, b) => a.order - b.order)
-    .map((item): ProtocolStep => {
-      const method = methods.get(item.methodId)
-      const name = item.name ?? item.sampleId ?? item.kind
-      return {
-        id: item.id,
-        type: instrumentRunStepType(item.kind),
-        name,
-        description: [
-          item.kind,
-          method?.name,
-          item.vial ? `Vial ${item.vial}` : undefined,
-          item.wellId ? `Well ${item.wellId}` : undefined,
-        ]
-          .filter(Boolean)
-          .join(' / '),
-        duration: item.expectedDurationMin,
-        status: instrumentRunStepStatus(item.status),
-        parameters: {
-          kind: item.kind,
-          sampleId: item.sampleId,
-          methodId: item.methodId,
-          method: method?.name,
-          vial: item.vial,
-          plateId: item.plateId,
-          wellId: item.wellId,
-          injectionVolume: item.injectionVolume,
-          instrument: data.instrument ?? method?.instrument,
-        },
-        order: item.order,
-      }
-    })
-}
-
-/**
- * Convert an instrument-run template into readonly ScheduleCalendar events ordered by run queue timing.
- *
- * @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 toInstrumentRunScheduleEvents(
-  template: InstrumentRunTemplate | InstrumentRunTemplateData
-): InstrumentRunScheduleEventsAdapterResult {
-  const data = getTemplateData(template, 'instrument-run')
-  validateInstrumentRunData(data)
-  const methods = new Map(data.methods.map(method => [method.id, method]))
-  let cursor = dateFromMetadata(data.metadata, ['scheduledStart', 'runStart', 'start', 'startedAt'])
-    ?? new Date('2024-01-01T08:00:00.000Z')
-
-  return [...data.items]
-    .sort((a, b) => a.order - b.order)
-    .map((item): ScheduleEvent => {
-      const method = methods.get(item.methodId)
-      const start = dateFromMetadata(item.metadata, ['scheduledStart', 'start', 'startedAt']) ?? cursor
-      const end = dateFromMetadata(item.metadata, ['scheduledEnd', 'end', 'completedAt'])
-        ?? addMinutes(start, Math.max(item.expectedDurationMin ?? 10, 1))
-      cursor = end
-
-      return {
-        id: item.id,
-        title: item.name ?? item.sampleId ?? item.kind,
-        start: start.toISOString(),
-        end: end.toISOString(),
-        color: instrumentRunScheduleColor(item.kind),
-        status: instrumentRunScheduleStatus(item.status),
-        draggable: false,
-        resizable: false,
-        metadata: {
-          kind: item.kind,
-          sampleId: item.sampleId,
-          methodId: item.methodId,
-          method: method?.name,
-          vial: item.vial,
-          plateId: item.plateId,
-          wellId: item.wellId,
-          injectionVolume: item.injectionVolume,
-          instrument: data.instrument ?? method?.instrument,
-        },
-      }
-    })
-}

package/src/templates/instrumentRunBuilder.ts

@@ -1,98 +0,0 @@
-import { idFromName } from './builderIdUtils'
-import {
-  normalizeInstrumentMethod,
-  normalizeInstrumentRunItem,
-} from './runNormalizers'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import { validateInstrumentRunData } from './templateValidators'
-import type {
-  CreateInstrumentRunTemplateOptions,
-  InstrumentRunItem,
-  InstrumentRunTemplate,
-  InstrumentRunTemplateData,
-} from './types'
-
-/** @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 createInstrumentRunTemplate(
-  options: CreateInstrumentRunTemplateOptions
-): InstrumentRunTemplate {
-  const method = typeof options.method === 'string' || options.method === undefined
-    ? {
-        id: idFromName(options.method ?? 'Default method', 'method-1'),
-        name: options.method ?? 'Default method',
-        instrument: options.instrument,
-        metadata: {},
-      }
-    : normalizeInstrumentMethod(options.method, options.instrument)
-  const items: InstrumentRunItem[] = []
-  let order = 1
-
-  if (options.includeBlanks !== false) {
-    items.push({
-      id: 'blank-start',
-      order,
-      kind: 'blank',
-      name: 'Blank start',
-      methodId: method.id,
-      status: 'planned',
-      metadata: {},
-    })
-    order += 1
-  }
-
-  if (options.includeQc !== false) {
-    items.push({
-      id: 'qc-start',
-      order,
-      kind: 'qc',
-      name: 'QC start',
-      methodId: method.id,
-      status: 'planned',
-      metadata: {},
-    })
-    order += 1
-  }
-
-  for (const [index, item] of options.items.entries()) {
-    if (typeof item !== 'string') {
-      const normalized = normalizeInstrumentRunItem(item, method.id, order, index)
-      items.push(normalized)
-      order = Math.max(order, normalized.order + 1)
-      continue
-    }
-    const sampleId = idFromName(item, `sample-${index + 1}`)
-    items.push({
-      id: `${sampleId}-run`,
-      order,
-      kind: 'sample',
-      sampleId,
-      name: item,
-      methodId: method.id,
-      status: 'planned',
-      metadata: {},
-    })
-    order += 1
-  }
-
-  if (options.includeQc !== false) {
-    items.push({
-      id: 'qc-end',
-      order,
-      kind: 'qc',
-      name: 'QC end',
-      methodId: method.id,
-      status: 'planned',
-      metadata: {},
-    })
-  }
-
-  const data: InstrumentRunTemplateData = {
-    runId: 'run-1',
-    instrument: options.instrument,
-    methods: [method],
-    items,
-    metadata: options.metadata ?? {},
-  }
-  validateInstrumentRunData(data)
-  return createTemplateEnvelope('instrument-run', data, options.metadata ?? {})
-}

package/src/templates/lcmsBatchCollectionBuilder.ts

@@ -1,39 +0,0 @@
-import { createAssayMatrixTemplate } from './assayMatrixBuilder'
-import { createInstrumentRunTemplate } from './instrumentRunBuilder'
-import { createSampleSheetTemplate } from './sampleSheetBuilder'
-import { presetSampleRecords } from './sampleNormalizers'
-import { createTemplateCollection } from './templateEnvelopes'
-import type {
-  CreateLcmsBatchCollectionOptions,
-  TemplateCollectionEnvelope,
-} from './types'
-
-/** @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 createLcmsBatchCollection(
-  options: CreateLcmsBatchCollectionOptions = {}
-): TemplateCollectionEnvelope {
-  const sampleRecords = presetSampleRecords(options.samples ?? ['S001', 'S002'])
-  const sampleSheet = createSampleSheetTemplate({ samples: sampleRecords })
-  const instrumentRun = createInstrumentRunTemplate({
-    items: sampleRecords.map(sample => ({
-      sampleId: sample.sampleId,
-      name: sample.name ?? sample.sampleId,
-    })),
-    method: options.method ?? 'Default method',
-    instrument: options.instrument ?? 'LC-MS',
-    includeQc: options.includeQc,
-  })
-  const assayMatrix = createAssayMatrixTemplate({
-    samples: sampleRecords.map(sample => ({
-      sampleId: sample.sampleId,
-      name: sample.name,
-      group: sample.group,
-      metadata: sample.metadata ?? {},
-    })),
-    features: options.features ?? ['Glucose', 'Lactate'],
-  })
-  return createTemplateCollection(
-    [sampleSheet, instrumentRun, assayMatrix],
-    { preset: 'lcms-batch', ...(options.metadata ?? {}) }
-  )
-}

package/src/templates/lookup.ts

@@ -1,18 +0,0 @@
-/** Normalize human-facing template lookup terms so spaces, hyphens, and underscores behave the same. */
-export function normalizeTemplateLookupKey(value: string): string {
-  return value.trim().toLowerCase().replace(/[\s_-]+/g, '-')
-}
-
-export function templateIdentifierMatches(query: string, identifiers: readonly string[]): boolean {
-  const normalizedQuery = normalizeTemplateLookupKey(query)
-  return identifiers.some(value => normalizeTemplateLookupKey(value) === normalizedQuery)
-}
-
-export function templateSearchMatches(query: string, values: readonly string[]): boolean {
-  const lowerQuery = query.trim().toLowerCase()
-  const normalizedQuery = normalizeTemplateLookupKey(query)
-  return values.some(value =>
-    value.toLowerCase().includes(lowerQuery)
-    || normalizeTemplateLookupKey(value).includes(normalizedQuery),
-  )
-}

package/src/templates/packs.ts

@@ -1,166 +0,0 @@
-import { bioTemplateCatalog } from './catalog'
-import type { TemplateId, TemplatePackId } from './types'
-
-import { templateIdentifierMatches, templateSearchMatches } from './lookup'
-
-export interface BioTemplatePackEntry {
-  name: TemplatePackId
-  label: string
-  category: 'bio-template-pack'
-  purpose: string
-  templates: readonly TemplateId[]
-  aliases: readonly string[]
-  frontend_adapters: readonly string[]
-  components: readonly string[]
-  add_command: string
-  docs_command: string
-}
-
-interface BioTemplatePackDefinition {
-  name: TemplatePackId
-  label: string
-  purpose: string
-  templates: readonly TemplateId[]
-  aliases: readonly string[]
-}
-
-const templateInfoById = new Map(
-  bioTemplateCatalog.map(entry => [entry.template_id, entry]),
-)
-
-function collectTemplateField(
-  templateIds: readonly TemplateId[],
-  field: 'frontend_adapters' | 'components',
-): readonly string[] {
-  const values: string[] = []
-  for (const templateId of templateIds) {
-    const entry = templateInfoById.get(templateId)
-    if (!entry) {
-      throw new Error(`Unknown bio template in pack catalog: ${templateId}`)
-    }
-    for (const value of entry[field]) {
-      if (!values.includes(value)) {
-        values.push(value)
-      }
-    }
-  }
-  return values
-}
-
-function createPack(definition: BioTemplatePackDefinition): BioTemplatePackEntry {
-  return {
-    ...definition,
-    category: 'bio-template-pack',
-    frontend_adapters: collectTemplateField(definition.templates, 'frontend_adapters'),
-    components: collectTemplateField(definition.templates, 'components'),
-    add_command: `mint add data-template-pack ${definition.name} --page`,
-    docs_command: `mint docs template-pack ${definition.name}`,
-  }
-}
-
-const bioTemplatePackDefinitions = [
-  {
-    name: 'cell-culture-screen',
-    label: 'Cell culture screen',
-    purpose: 'Plate layout, sample metadata, sample prep, reagents, protocol, dose-response, and flow-panel setup.',
-    templates: [
-      'sample-sheet',
-      'sample-prep',
-      'plate-map',
-      'reagent-list',
-      'protocol-steps',
-      'dose-response',
-      'flow-cytometry-panel',
-    ],
-    aliases: ['cell culture', 'screen', 'drug screen', 'plate screen'],
-  },
-  {
-    name: 'omics-assay',
-    label: 'Omics assay',
-    purpose: 'Sample metadata, sample prep, reagents, protocol, instrument run queue, calibration curve, and measurement matrix.',
-    templates: [
-      'sample-sheet',
-      'sample-prep',
-      'reagent-list',
-      'protocol-steps',
-      'instrument-run',
-      'calibration-curve',
-      'assay-matrix',
-    ],
-    aliases: [
-      'omics',
-      'metabolomics',
-      'metabolism',
-      'metabolite profiling',
-      'proteomics',
-      'assay matrix',
-      'lcms',
-      'standard curve',
-    ],
-  },
-  {
-    name: 'longitudinal-study',
-    label: 'Longitudinal study',
-    purpose: 'Sample metadata, time-course schedule, protocol, and measurement matrix.',
-    templates: [
-      'sample-sheet',
-      'time-course',
-      'protocol-steps',
-      'assay-matrix',
-    ],
-    aliases: ['time series', 'time-course study', 'kinetics', 'longitudinal'],
-  },
-  {
-    name: 'molecular-assay',
-    label: 'Molecular assay',
-    purpose: 'Sample metadata, sample prep, reagents, protocol, instrument run queue, calibration curve, and qPCR/ddPCR plate setup.',
-    templates: [
-      'sample-sheet',
-      'sample-prep',
-      'reagent-list',
-      'protocol-steps',
-      'instrument-run',
-      'calibration-curve',
-      'qpcr-plate',
-    ],
-    aliases: ['molecular', 'qpcr', 'qPCR', 'gene expression', 'rt-qpcr', 'ddpcr'],
-  },
-] as const satisfies readonly BioTemplatePackDefinition[]
-
-/** @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 const bioTemplatePacks = bioTemplatePackDefinitions.map(createPack) as readonly BioTemplatePackEntry[]
-
-/** @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 listBioTemplatePacks(): readonly BioTemplatePackEntry[] {
-  return bioTemplatePacks
-}
-
-/** @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 getBioTemplatePackInfo(name: string): BioTemplatePackEntry | undefined {
-  return bioTemplatePacks.find(entry => {
-    const identifiers = [
-      entry.name,
-      entry.label,
-      ...entry.aliases,
-    ]
-    return templateIdentifierMatches(name, identifiers)
-  })
-}
-
-/** @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 searchBioTemplatePacks(query: string): readonly BioTemplatePackEntry[] {
-  const normalized = query.trim().toLowerCase()
-  if (!normalized) return bioTemplatePacks
-
-  return bioTemplatePacks.filter(entry => templateSearchMatches(normalized, [
-    entry.name,
-    entry.label,
-    entry.purpose,
-    entry.add_command,
-    entry.docs_command,
-    ...entry.templates,
-    ...entry.aliases,
-    ...entry.frontend_adapters,
-    ...entry.components,
-  ]))
-}

package/src/templates/plateMapAdapters.ts

@@ -1,38 +0,0 @@
-import type {
-  PlateMapEditorState,
-} from '../types'
-import { getTemplateData } from './templateEnvelopes'
-import { validatePlateMapData } from './templateValidators'
-import type {
-  PlateMapEditorAdapterResult,
-  PlateMapTemplate,
-  PlateMapTemplateData,
-  WellMapAdapterResult,
-} from './types'
-
-/** @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 toPlateMapEditorState(
-  template: PlateMapTemplate | PlateMapTemplateData
-): PlateMapEditorAdapterResult {
-  const data = getTemplateData(template, 'plate-map')
-  validatePlateMapData(data)
-  const activePlateId = data.activePlateId ?? data.plates[0].id
-  return {
-    plates: data.plates,
-    activePlateId,
-    samples: data.samples,
-    selectedWells: data.selectedWells ?? [],
-    activeSampleId: data.activeSampleId,
-  } satisfies PlateMapEditorState
-}
-
-/** @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 toWellPlateWells(
-  template: PlateMapTemplate | PlateMapTemplateData,
-  plateId?: string
-): WellMapAdapterResult {
-  const state = toPlateMapEditorState(template)
-  const plate = state.plates.find(candidate => candidate.id === (plateId ?? state.activePlateId))
-    ?? state.plates[0]
-  return plate.wells
-}

package/src/templates/plateMapBuilder.ts

@@ -1,44 +0,0 @@
-import { SAMPLE_COLOR_SCALE } from '../utils/color'
-import { sampleIdFromName } from './builderIdUtils'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import type {
-  CreatePlateMapTemplateOptions,
-  PlateMapTemplate,
-  TemplateSample,
-} from './types'
-
-/** @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 createPlateMapTemplate(
-  options: CreatePlateMapTemplateOptions = {}
-): PlateMapTemplate {
-  const {
-    id = 'plate-1',
-    name = 'Plate 1',
-    format = 96,
-    samples = [],
-    metadata = {},
-  } = options
-
-  const sampleDefinitions = samples.map((sample, index): TemplateSample => {
-    if (typeof sample !== 'string') return sample
-    return {
-      id: sampleIdFromName(sample, index),
-      name: sample,
-      color: SAMPLE_COLOR_SCALE[index % SAMPLE_COLOR_SCALE.length],
-    }
-  })
-
-  return createTemplateEnvelope('plate-map', {
-    plates: [
-      {
-        id,
-        name,
-        format,
-        wells: {},
-      },
-    ],
-    samples: sampleDefinitions,
-    activePlateId: id,
-    selectedWells: [],
-  }, metadata)
-}