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

package/src/templates/templateEnvelopes.ts

@@ -1,137 +0,0 @@
-import type {
-  BioTemplateEnvelope,
-  TemplateCollection,
-  TemplateCollectionEnvelope,
-  TemplateId,
-} from './types'
-import { isRecord } from './builderReadUtils'
-
-export const TEMPLATE_COLLECTION_KEY = 'templates'
-
-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,
-  }
-}
-
-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 }
-}
-
-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
-}
-
-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
-}
-
-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)}'.`)
-  }
-}
-
-export function ensureTemplateEnvelope<TTemplate extends BioTemplateEnvelope<unknown>>(
-  value: unknown,
-  templateId: TemplateId | string
-): TTemplate {
-  assertTemplateEnvelope(value, templateId)
-  return value as TTemplate
-}
-
-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,23 +0,0 @@
-import { getBioTemplatePackInfo } from './packs'
-import { createDefaultBioTemplate } from './defaultBioTemplateBuilder'
-import { createTemplateCollection } from './templateEnvelopes'
-import type {
-  CreateBioTemplatePackCollectionOptions,
-  TemplateCollectionEnvelope,
-  TemplatePackId,
-} from './types'
-
-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,139 +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'
-
-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}'.`)
-}
-
-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>