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

package/src/templates/templateCreateOptions.ts

@@ -1,208 +0,0 @@
-import type { WellPlateFormat } from '../types'
-import type {
-  AssayFeature,
-  AssaySample,
-  CalibrationAcceptanceInput,
-  CalibrationModel,
-  CalibrationPointInput,
-  CompoundDoseSeries,
-  ControlDefinition,
-  FlowPanelControl,
-  FlowPanelMarker,
-  InstrumentMethodInput,
-  InstrumentRunItemInput,
-  PlateMapTemplate,
-  PlateMapTemplateData,
-  ProtocolStepRecord,
-  ReagentTemplateInput,
-  SampleColumn,
-  SampleGroupDefinition,
-  SamplePrepStepInput,
-  SamplePrepStepType,
-  SampleRecord,
-  TemplateSample,
-  TimeCourseCondition,
-  TimePoint,
-  TimeUnit,
-} from './types'
-import type {
-  QpcrChemistry,
-  QpcrSample,
-  QpcrTarget,
-} from './templateQpcrTypes'
-
-export interface CreateBioTemplatePackCollectionOptions {
-  metadata?: Record<string, unknown>
-}
-
-export interface CreatePlateMapTemplateOptions {
-  name?: string
-  id?: string
-  format?: WellPlateFormat
-  samples?: Array<string | TemplateSample>
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateSampleSheetTemplateOptions {
-  samples: SampleRecord[]
-  columns?: SampleColumn[]
-  groups?: SampleGroupDefinition[]
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateSamplePrepTemplateOptions {
-  samples: Array<string | SamplePrepStepInput>
-  prepType?: SamplePrepStepType
-  protocolName?: string
-  volumeUnit?: string
-  inputVolume?: number
-  outputVolume?: number
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateDoseResponseTemplateOptions {
-  compounds: Record<string, number[]> | CompoundDoseSeries[]
-  unit: string
-  replicates?: number
-  controls?: ControlDefinition[]
-  layout?: PlateMapTemplate | PlateMapTemplateData
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateCalibrationCurveTemplateOptions {
-  concentrations: Array<number | CalibrationPointInput>
-  analyte?: string
-  unit?: string
-  responseUnit?: string
-  model?: CalibrationModel
-  includeBlank?: boolean
-  includeQc?: boolean
-  acceptance?: CalibrationAcceptanceInput
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateTimeCourseTemplateOptions {
-  timepoints: Array<number | TimePoint>
-  unit: TimeUnit
-  conditions: Array<string | TimeCourseCondition>
-  replicates?: number
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateAssayMatrixTemplateOptions {
-  samples: Array<string | AssaySample>
-  features: Array<string | AssayFeature>
-  values?: Record<string, Record<string, number | null | undefined>>
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateProtocolStepsTemplateOptions {
-  steps: Array<string | (Partial<ProtocolStepRecord> & { name: string })>
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateReagentListTemplateOptions {
-  reagents: Array<string | ReagentTemplateInput>
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateFlowCytometryPanelTemplateOptions {
-  markers: Array<string | (Partial<FlowPanelMarker> & { marker: string })>
-  controls?: Array<string | (Partial<FlowPanelControl> & { name: string })>
-  instrument?: string
-  includeDefaultControls?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateInstrumentRunTemplateOptions {
-  items: Array<string | InstrumentRunItemInput>
-  method?: string | InstrumentMethodInput
-  instrument?: string
-  includeBlanks?: boolean
-  includeQc?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateQpcrPlateTemplateOptions {
-  samples: Array<string | QpcrSample>
-  targets: Array<string | QpcrTarget>
-  format?: WellPlateFormat
-  replicates?: number
-  includeNoTemplateControls?: boolean
-  instrument?: string
-  chemistry?: QpcrChemistry
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateWellPlateScreenCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  compounds?: Record<string, number[]> | CompoundDoseSeries[]
-  unit?: string
-  replicates?: number
-  plateName?: string
-  plateFormat?: WellPlateFormat
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateQpcrExpressionCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  targets?: Array<string | QpcrTarget>
-  chemistry?: QpcrChemistry
-  includeNoTemplateControls?: boolean
-  format?: WellPlateFormat
-  replicates?: number
-  instrument?: string
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateLcmsBatchCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  features?: Array<string | AssayFeature>
-  instrument?: string
-  method?: string | InstrumentMethodInput
-  includeQc?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateTargetedMetabolomicsCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  metabolites?: Array<string | AssayFeature>
-  internalStandards?: Array<string | ReagentTemplateInput>
-  standardConcentrations?: number[]
-  concentrationUnit?: string
-  responseUnit?: string
-  calibrationAnalyte?: string
-  instrument?: string
-  method?: string | InstrumentMethodInput
-  prepType?: SamplePrepStepType
-  outputVolume?: number
-  includeQc?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateElisaAssayCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  analyte?: string
-  standardConcentrations?: number[]
-  unit?: string
-  responseUnit?: string
-  plateName?: string
-  plateFormat?: WellPlateFormat
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateFlowCytometryAssayCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  markers?: CreateFlowCytometryPanelTemplateOptions['markers']
-  features?: Array<string | AssayFeature>
-  instrument?: string
-  includeDefaultControls?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface CreateWesternBlotAssayCollectionOptions {
-  samples?: Array<string | SampleRecord>
-  targets?: Array<string | AssayFeature>
-  loadingControl?: string
-  metadata?: Record<string, unknown>
-}

package/src/templates/templateEnvelopes.ts

@@ -1,145 +0,0 @@
-import type {
-  BioTemplateEnvelope,
-  TemplateCollection,
-  TemplateCollectionEnvelope,
-  TemplateId,
-} from './types'
-import { isRecord } from './builderReadUtils'
-
-/** @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 TEMPLATE_COLLECTION_KEY = 'templates'
-
-/** @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 createTemplateEnvelope<TData>(
-  templateId: TemplateId,
-  data: TData,
-  metadata: Record<string, unknown> = {},
-  templateVersion = '1.0'
-): BioTemplateEnvelope<TData> {
-  return {
-    template_id: templateId,
-    template_version: templateVersion,
-    kind: 'experiment-design',
-    data,
-    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 createTemplateCollection(
-  templates: Array<BioTemplateEnvelope<unknown>>,
-  metadata?: Record<string, unknown>
-): TemplateCollectionEnvelope {
-  const collection: TemplateCollection = {}
-  for (const template of templates) {
-    assertGenericTemplateEnvelope(template)
-    const templateId = template.template_id
-    if (collection[templateId]) {
-      throw new Error(`Duplicate template_id '${templateId}' in template collection.`)
-    }
-    collection[templateId] = template
-  }
-
-  return metadata === undefined
-    ? { [TEMPLATE_COLLECTION_KEY]: collection }
-    : { [TEMPLATE_COLLECTION_KEY]: collection, 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 extractTemplateCollection(value: unknown): TemplateCollection {
-  if (isEnvelope<unknown>(value)) {
-    assertGenericTemplateEnvelope(value)
-    return { [value.template_id]: value }
-  }
-  if (!isRecord(value)) {
-    throw new Error('Template collection payload must be an object.')
-  }
-
-  const rawCollection = value[TEMPLATE_COLLECTION_KEY]
-  if (rawCollection === undefined) {
-    return {}
-  }
-  if (!isRecord(rawCollection)) {
-    throw new Error('Template collection must be an object.')
-  }
-
-  const collection: TemplateCollection = {}
-  for (const [templateId, template] of Object.entries(rawCollection)) {
-    assertGenericTemplateEnvelope(template)
-    if (template.template_id !== templateId) {
-      throw new Error(
-        `Template collection key '${templateId}' does not match envelope template_id '${template.template_id}'.`
-      )
-    }
-    collection[templateId] = template
-  }
-  return collection
-}
-
-/** @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 ensureTemplateFromCollection<TTemplate extends BioTemplateEnvelope<unknown>>(
-  value: unknown,
-  templateId: TemplateId | string
-): TTemplate {
-  const collection = extractTemplateCollection(value)
-  const template = collection[templateId]
-  if (!template) {
-    throw new Error(`Template '${templateId}' was not found in template collection.`)
-  }
-  assertTemplateEnvelope(template, templateId)
-  return template as TTemplate
-}
-
-/** @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 assertTemplateEnvelope<TData>(
-  value: unknown,
-  templateId: TemplateId | string
-): asserts value is BioTemplateEnvelope<TData> {
-  assertGenericTemplateEnvelope(value)
-  if (value.template_id !== templateId) {
-    throw new Error(`Expected template_id '${templateId}', got '${String(value.template_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 ensureTemplateEnvelope<TTemplate extends BioTemplateEnvelope<unknown>>(
-  value: unknown,
-  templateId: TemplateId | string
-): TTemplate {
-  assertTemplateEnvelope(value, templateId)
-  return value as TTemplate
-}
-
-/** @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 getTemplateData<TData>(
-  template: BioTemplateEnvelope<TData> | TData,
-  templateId?: TemplateId | string
-): TData {
-  if (isEnvelope<TData>(template)) {
-    if (templateId) assertTemplateEnvelope<TData>(template, templateId)
-    return template.data
-  }
-  return template
-}
-
-function assertGenericTemplateEnvelope(value: unknown): asserts value is BioTemplateEnvelope<unknown> {
-  if (!isRecord(value)) {
-    throw new Error('Template envelope must be an object.')
-  }
-  if (typeof value.template_id !== 'string' || value.template_id.length === 0) {
-    throw new Error('Template envelope requires a template_id string.')
-  }
-  if (typeof value.template_version !== 'string' || value.template_version.length === 0) {
-    throw new Error('Template envelope requires a template_version string.')
-  }
-  if (!isRecord(value.data)) {
-    throw new Error('Template envelope data must be an object.')
-  }
-  if ('metadata' in value && !isRecord(value.metadata)) {
-    throw new Error('Template envelope metadata must be an object.')
-  }
-}
-
-function isEnvelope<TData>(value: unknown): value is BioTemplateEnvelope<TData> {
-  return isRecord(value) && 'template_id' in value && 'data' in value
-}

package/src/templates/templatePackCollectionBuilder.ts

@@ -1,24 +0,0 @@
-import { getBioTemplatePackInfo } from './packs'
-import { createDefaultBioTemplate } from './defaultBioTemplateBuilder'
-import { createTemplateCollection } from './templateEnvelopes'
-import type {
-  CreateBioTemplatePackCollectionOptions,
-  TemplateCollectionEnvelope,
-  TemplatePackId,
-} 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 createBioTemplatePackCollection(
-  name: TemplatePackId | string,
-  options: CreateBioTemplatePackCollectionOptions = {},
-): TemplateCollectionEnvelope {
-  const pack = getBioTemplatePackInfo(name)
-  if (!pack) {
-    throw new Error(`Unknown template pack '${name}'.`)
-  }
-
-  return createTemplateCollection(
-    pack.templates.map(templateId => createDefaultBioTemplate(templateId)),
-    { pack: pack.name, ...(options.metadata ?? {}) },
-  )
-}

package/src/templates/templatePresetCollectionBuilder.ts

@@ -1,141 +0,0 @@
-import { bioTemplatePresetControlValuesToOptions } from './builderPresetControls'
-import type { BioTemplateControlValues } from './builderPresetControls'
-import { createElisaAssayCollection } from './elisaAssayCollectionBuilder'
-import { createFlowCytometryAssayCollection } from './flowCytometryAssayCollectionBuilder'
-import { createLcmsBatchCollection } from './lcmsBatchCollectionBuilder'
-import { getBioTemplatePresetInfo } from './presets'
-import { createQpcrExpressionCollection } from './qpcrExpressionCollectionBuilder'
-import { createTargetedMetabolomicsCollection } from './targetedMetabolomicsCollectionBuilder'
-import { createWellPlateScreenCollection } from './wellPlateScreenCollectionBuilder'
-import { createWesternBlotAssayCollection } from './westernBlotAssayCollectionBuilder'
-import type {
-  CreateElisaAssayCollectionOptions,
-  CreateFlowCytometryAssayCollectionOptions,
-  CreateLcmsBatchCollectionOptions,
-  CreateQpcrExpressionCollectionOptions,
-  CreateTargetedMetabolomicsCollectionOptions,
-  CreateWellPlateScreenCollectionOptions,
-  CreateWesternBlotAssayCollectionOptions,
-  TemplateCollectionEnvelope,
-  TemplatePresetId,
-} 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 createBioTemplatePresetCollection(
-  name: 'wellplate-screen',
-  options?: CreateWellPlateScreenCollectionOptions
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollection(
-  name: 'qpcr-expression',
-  options?: CreateQpcrExpressionCollectionOptions
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollection(
-  name: 'lcms-batch',
-  options?: CreateLcmsBatchCollectionOptions
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollection(
-  name: 'targeted-metabolomics',
-  options?: CreateTargetedMetabolomicsCollectionOptions
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollection(
-  name: 'elisa-assay',
-  options?: CreateElisaAssayCollectionOptions
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollection(
-  name: 'flow-cytometry-assay',
-  options?: CreateFlowCytometryAssayCollectionOptions
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollection(
-  name: 'western-blot-assay',
-  options?: CreateWesternBlotAssayCollectionOptions
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollection(
-  name: string,
-  options?:
-    | CreateWellPlateScreenCollectionOptions
-    | CreateQpcrExpressionCollectionOptions
-    | CreateLcmsBatchCollectionOptions
-    | CreateTargetedMetabolomicsCollectionOptions
-    | CreateElisaAssayCollectionOptions
-    | CreateFlowCytometryAssayCollectionOptions
-    | CreateWesternBlotAssayCollectionOptions
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollection(
-  name: TemplatePresetId | string,
-  options:
-    | CreateWellPlateScreenCollectionOptions
-    | CreateQpcrExpressionCollectionOptions
-    | CreateLcmsBatchCollectionOptions
-    | CreateTargetedMetabolomicsCollectionOptions
-    | CreateElisaAssayCollectionOptions
-    | CreateFlowCytometryAssayCollectionOptions
-    | CreateWesternBlotAssayCollectionOptions = {}
-): TemplateCollectionEnvelope {
-  const preset = getBioTemplatePresetInfo(name)
-  if (!preset) {
-    throw new Error(`Unknown template preset '${name}'.`)
-  }
-  if (preset.name === 'wellplate-screen') {
-    return createWellPlateScreenCollection(options as CreateWellPlateScreenCollectionOptions)
-  }
-  if (preset.name === 'qpcr-expression') {
-    return createQpcrExpressionCollection(options as CreateQpcrExpressionCollectionOptions)
-  }
-  if (preset.name === 'lcms-batch') {
-    return createLcmsBatchCollection(options as CreateLcmsBatchCollectionOptions)
-  }
-  if (preset.name === 'targeted-metabolomics') {
-    return createTargetedMetabolomicsCollection(options as CreateTargetedMetabolomicsCollectionOptions)
-  }
-  if (preset.name === 'elisa-assay') {
-    return createElisaAssayCollection(options as CreateElisaAssayCollectionOptions)
-  }
-  if (preset.name === 'flow-cytometry-assay') {
-    return createFlowCytometryAssayCollection(options as CreateFlowCytometryAssayCollectionOptions)
-  }
-  if (preset.name === 'western-blot-assay') {
-    return createWesternBlotAssayCollection(options as CreateWesternBlotAssayCollectionOptions)
-  }
-  throw new Error(`Unknown template preset '${name}'.`)
-}
-
-/** @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 createBioTemplatePresetCollectionFromControls(
-  name: 'wellplate-screen',
-  values: BioTemplateControlValues
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollectionFromControls(
-  name: 'qpcr-expression',
-  values: BioTemplateControlValues
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollectionFromControls(
-  name: 'lcms-batch',
-  values: BioTemplateControlValues
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollectionFromControls(
-  name: 'targeted-metabolomics',
-  values: BioTemplateControlValues
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollectionFromControls(
-  name: 'elisa-assay',
-  values: BioTemplateControlValues
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollectionFromControls(
-  name: 'flow-cytometry-assay',
-  values: BioTemplateControlValues
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollectionFromControls(
-  name: 'western-blot-assay',
-  values: BioTemplateControlValues
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollectionFromControls(
-  name: TemplatePresetId | string,
-  values: BioTemplateControlValues
-): TemplateCollectionEnvelope
-export function createBioTemplatePresetCollectionFromControls(
-  name: TemplatePresetId | string,
-  values: BioTemplateControlValues
-): TemplateCollectionEnvelope {
-  const options = bioTemplatePresetControlValuesToOptions(name, values)
-  return createBioTemplatePresetCollection(name, options)
-}

package/src/templates/templateQpcrTypes.ts

@@ -1,48 +0,0 @@
-import type { WellPlateFormat } from '../types'
-import type { BioTemplateEnvelope } from './types'
-
-export type QpcrChemistry = 'sybr' | 'taqman' | 'probe' | 'evagreen' | 'other'
-export type QpcrControlKind = 'sample' | 'no-template' | 'no-rt' | 'positive' | 'standard' | 'calibrator'
-
-export interface QpcrSample {
-  sampleId: string
-  name?: string
-  group?: string
-  metadata?: Record<string, unknown>
-}
-
-export interface QpcrTarget {
-  id: string
-  name: string
-  assayId?: string
-  reporter?: string
-  quencher?: string
-  ampliconBp?: number
-  metadata?: Record<string, unknown>
-}
-
-export interface QpcrReaction {
-  id: string
-  wellId: string
-  sampleId?: string
-  targetId: string
-  replicate: number
-  controlKind: QpcrControlKind
-  cq?: number | null
-  quantity?: number | null
-  flags: string[]
-  metadata?: Record<string, unknown>
-}
-
-export interface QpcrPlateTemplateData {
-  plateId: string
-  format: WellPlateFormat
-  samples: QpcrSample[]
-  targets: QpcrTarget[]
-  reactions: QpcrReaction[]
-  instrument?: string
-  chemistry: QpcrChemistry
-  metadata: Record<string, unknown>
-}
-
-export type QpcrPlateTemplate = BioTemplateEnvelope<QpcrPlateTemplateData>