@morscherlab/mint-sdk 1.0.0-rc.4 → 1.0.0-rc.5

package/src/composables/autoGroupGrouping.ts

@@ -0,0 +1,148 @@
+import type {
+  AutoGroupResult,
+  ColumnInfo,
+  MetadataRow,
+  OutlierAction,
+  ParsedCsvData,
+} from '../types/auto-group'
+import type { SampleGroup } from '../types/components'
+import { DEFAULT_COLORS } from './autoGroupConstants'
+
+export function computeGroups(
+  allSamples: string[],
+  columns: ColumnInfo[],
+  enabledFields: Set<number>,
+  outlierActions: Map<number, OutlierAction>,
+  delimiter: string,
+  minFieldCount: number,
+): AutoGroupResult {
+  const excludedSamples: string[] = []
+  const qcSamples: string[] = []
+  const conformingSamples: string[] = []
+
+  for (let i = 0; i < allSamples.length; i++) {
+    const action = outlierActions.get(i)
+    if (action === 'exclude') {
+      excludedSamples.push(allSamples[i])
+    } else if (action === 'qc') {
+      qcSamples.push(allSamples[i])
+    } else {
+      conformingSamples.push(allSamples[i])
+    }
+  }
+
+  // Build group map
+  const groupMap = new Map<string, string[]>()
+  const metadata: MetadataRow[] = []
+  const enabledIndices = [...enabledFields].sort((a, b) => a - b)
+  const suffixCount = minFieldCount - 1
+
+  for (const sample of conformingSamples) {
+    const parts = sample.split(delimiter)
+    const splitAt = Math.max(1, parts.length - suffixCount)
+    const row = [
+      parts.slice(0, splitAt).join(delimiter),
+      ...parts.slice(splitAt),
+    ]
+
+    // Build group key from enabled columns
+    const keyParts: string[] = []
+    for (const idx of enabledIndices) {
+      if (idx < row.length && idx < columns.length) {
+        keyParts.push(row[idx])
+      }
+    }
+    const groupKey = keyParts.join(' / ')
+
+    const group = groupMap.get(groupKey)
+    if (group) {
+      group.push(sample)
+    } else {
+      groupMap.set(groupKey, [sample])
+    }
+
+    // Build metadata row with ALL columns
+    const fields: Record<string, string> = {}
+    for (const col of columns) {
+      if (col.index < row.length) {
+        fields[col.name] = row[col.index]
+      }
+    }
+    metadata.push({ sampleName: sample, fields, group: groupKey })
+  }
+
+  // Convert to SampleGroup[]
+  const groups: SampleGroup[] = []
+  let colorIdx = 0
+  for (const [name, samples] of groupMap) {
+    groups.push({
+      name,
+      color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
+      samples,
+    })
+    colorIdx++
+  }
+
+  // QC group
+  if (qcSamples.length > 0) {
+    groups.push({
+      name: 'QC',
+      color: '#6B7280',
+      samples: qcSamples,
+    })
+    for (const sample of qcSamples) {
+      metadata.push({ sampleName: sample, fields: {}, group: 'QC' })
+    }
+  }
+
+  return { groups, metadata, excludedSamples }
+}
+
+export function computeGroupsFromCsv(
+  csvData: ParsedCsvData,
+  columns: ColumnInfo[],
+  enabledFields: Set<number>,
+): AutoGroupResult {
+  const groupMap = new Map<string, string[]>()
+  const metadata: MetadataRow[] = []
+  const enabledCols = columns
+    .filter(c => enabledFields.has(c.index))
+    .sort((a, b) => a.index - b.index)
+
+  for (const row of csvData.rows) {
+    const sampleName = row[csvData.sampleColumn]
+
+    // Build group key from enabled CSV column values
+    // Use originalName for CSV row lookup (survives user renames), display name for group key
+    const keyParts = enabledCols.map(col => row[col.originalName ?? col.name])
+    const groupKey = keyParts.join(' / ')
+
+    const group = groupMap.get(groupKey)
+    if (group) {
+      group.push(sampleName)
+    } else {
+      groupMap.set(groupKey, [sampleName])
+    }
+
+    // Build metadata row with ALL columns - use display name as key, original for lookup
+    const fields: Record<string, string> = {}
+    for (const col of columns) {
+      fields[col.name] = row[col.originalName ?? col.name]
+    }
+    metadata.push({ sampleName, fields, group: groupKey })
+  }
+
+  // Convert to SampleGroup[]
+  const groups: SampleGroup[] = []
+  let colorIdx = 0
+  for (const [name, samples] of groupMap) {
+    groups.push({
+      name,
+      color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
+      samples,
+    })
+    colorIdx++
+  }
+
+  return { groups, metadata, excludedSamples: [] }
+}

package/src/composables/controlComponentBindings.ts

@@ -6,7 +6,7 @@ import type {
   ControlComponentBindingsConfig,
   ControlComponentPropsMap,
   ControlComponentPropSource,
-} from './useControlSchema'
+} from './controlSchemaTypes'
 
 /** Map control workspace values into component props for direct `v-bind` usage. */
 export function controlValuesToComponentProps<TValues extends Record<string, unknown>>(

package/src/composables/controlSchemaAdapters.ts

@@ -27,7 +27,7 @@ import type {
   ControlFormSchema,
   ControlSchema,
   ControlSchemaOptions,
-} from './useControlSchema'
+} from './controlSchemaTypes'
 
 /** Convert a compact control schema into a FormBuilder schema. */
 export function controlsToFormSchema(

package/src/composables/controlSchemaDoseDesign.ts

@@ -0,0 +1,215 @@
+import type {
+  ControlComponentBindingsConfig,
+  ControlComponentPropSource,
+  ControlComponentPropsByIdMap,
+  ControlComponentPropsMap,
+  ControlModelBinding,
+  ControlSchema,
+  DoseCalculatorControlPropsOptions,
+  DoseDesignControlModelOptions,
+  WellPlateControlPropsOptions,
+  WellPlateDoseControlPropsOptions,
+} from './controlSchemaTypes'
+import type { WellConcentration } from './useDoseCalculator'
+import {
+  defineControlModel,
+} from './controlSchemaModel'
+import {
+  recordValue,
+} from './controlSchemaUtils'
+
+/** Return a default WellPlate prop mapping for generated control workspaces. */
+export function defineWellPlateControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(
+  options: WellPlateControlPropsOptions<TValues> = {},
+): ControlComponentPropsMap<TValues> {
+  const selectedWells = options.selectedWells ?? sourceKey<TValues>('selectedWells')
+  const onUpdateModelValue = options.onUpdateModelValue === false
+    ? undefined
+    : options.onUpdateModelValue ?? updateControlValueSource(selectedWells)
+
+  return compactComponentPropsMap<TValues>({
+    modelValue: selectedWells,
+    'onUpdate:modelValue': onUpdateModelValue,
+    format: options.format ?? sourceKey<TValues>('plateFormat'),
+    wells: options.wells ?? sourceKey<TValues>('wells'),
+    disabled: options.disabled ?? sourceKey<TValues>('disabled'),
+    readonly: options.readonly ?? sourceKey<TValues>('readonly'),
+    showLegend: options.showLegend,
+    showSampleTypeIndicator: options.showSampleTypeIndicator,
+  })
+}
+
+/** Return a default DoseCalculator prop mapping for generated control workspaces. */
+export function defineDoseCalculatorControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(
+  options: DoseCalculatorControlPropsOptions<TValues> = {},
+): ControlComponentPropsMap<TValues> {
+  const targetWells = options.targetWells ?? sourceKey<TValues>('selectedWells')
+  const wells = options.wells ?? sourceKey<TValues>('wells')
+  const onApplyToWells = options.onApplyToWells === false
+    ? undefined
+    : options.onApplyToWells ?? defaultDoseApplyHandler(wells, targetWells)
+
+  return compactComponentPropsMap<TValues>({
+    mode: options.mode ?? sourceKey<TValues>('doseMode'),
+    targetWells,
+    disabled: options.disabled ?? sourceKey<TValues>('disabled'),
+    molecularWeight: options.molecularWeight,
+    onApplyToWells,
+  })
+}
+
+/** Return named WellPlate + DoseCalculator prop mappings for one dose-design control model. */
+export function defineWellPlateDoseControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(
+  options: WellPlateDoseControlPropsOptions<TValues> = {},
+): ControlComponentPropsByIdMap<TValues> {
+  return {
+    [options.plateId ?? 'plate']: defineWellPlateControlProps(options.plate),
+    [options.doseId ?? 'dose']: defineDoseCalculatorControlProps(options.dose),
+  }
+}
+
+/** Return named WellPlate + DoseCalculator component bindings for one dose-design control model. */
+export function defineWellPlateDoseComponentBindings<TValues extends Record<string, unknown> = Record<string, unknown>>(
+  options: WellPlateDoseControlPropsOptions<TValues> = {},
+): ControlComponentBindingsConfig<TValues> {
+  return [
+    {
+      id: options.plateId ?? 'plate',
+      component: 'WellPlate',
+      props: defineWellPlateControlProps(options.plate),
+    },
+    {
+      id: options.doseId ?? 'dose',
+      component: 'DoseCalculator',
+      props: defineDoseCalculatorControlProps(options.dose),
+    },
+  ]
+}
+
+/** Return a complete ControlWorkspaceView model for WellPlate + DoseCalculator dose design. */
+export function defineDoseDesignControlModel(
+  options: DoseDesignControlModelOptions = {},
+): ControlModelBinding {
+  const viewId = options.viewId ?? 'design'
+  const sectionId = options.sectionId ?? 'dose'
+  const doseControls: ControlSchema = {
+    selectedWells: {
+      type: 'tags',
+      label: 'Selected wells',
+      default: [...(options.selectedWells ?? ['A1', 'A2'])],
+    },
+    plateFormat: {
+      label: 'Plate format',
+      default: options.plateFormat ?? 96,
+      options: options.plateFormats ?? [96, 384],
+    },
+    doseMode: {
+      label: 'Dose mode',
+      default: options.doseMode ?? 'serial',
+      options: options.doseModes ?? ['serial', 'dilution', 'conversion'],
+    },
+    disabled: {
+      label: 'Disable tools',
+      default: options.disabled ?? false,
+    },
+  }
+
+  if (options.includeMolecularWeight) {
+    doseControls.molecularWeight = {
+      type: 'number',
+      label: 'Molecular weight',
+      default: options.molecularWeight ?? 300,
+      min: 0,
+    }
+  }
+
+  const componentProps: WellPlateDoseControlPropsOptions = {
+    ...options.componentProps,
+    dose: {
+      ...(options.componentProps?.dose ?? {}),
+      ...(options.includeMolecularWeight && options.componentProps?.dose?.molecularWeight === undefined
+        ? { molecularWeight: 'molecularWeight' }
+        : {}),
+    },
+  }
+
+  return defineControlModel({
+    componentBindings: defineWellPlateDoseComponentBindings(componentProps),
+    componentPropsById: defineWellPlateDoseControlProps(componentProps),
+    views: {
+      [viewId]: {
+        label: options.viewLabel ?? 'Design',
+        sections: {
+          [sectionId]: {
+            label: options.sectionLabel ?? 'Dose design',
+            description: options.sectionDescription ?? 'Well selection and dose calculator controls',
+            controls: doseControls,
+          },
+        },
+      },
+    },
+  })
+}
+
+function compactComponentPropsMap<TValues extends Record<string, unknown>>(
+  mapping: Record<string, ControlComponentPropSource<TValues> | undefined>,
+): ControlComponentPropsMap<TValues> {
+  return Object.fromEntries(
+    Object.entries(mapping).filter((entry): entry is [string, ControlComponentPropSource<TValues>] =>
+      entry[1] !== undefined
+    ),
+  )
+}
+
+function sourceKey<TValues extends Record<string, unknown>>(key: string): keyof TValues & string {
+  return key as keyof TValues & string
+}
+
+function updateControlValueSource<TValues extends Record<string, unknown>>(
+  source: ControlComponentPropSource<TValues>,
+): ((values: TValues) => (value: string[]) => void) | undefined {
+  if (typeof source !== 'string') return undefined
+  return values => (value: string[]) => {
+    const writableValues = values as Record<string, unknown>
+    writableValues[source] = value
+  }
+}
+
+function defaultDoseApplyHandler<TValues extends Record<string, unknown>>(
+  wells: ControlComponentPropSource<TValues>,
+  targetWells: ControlComponentPropSource<TValues>,
+): ((values: TValues) => (results: WellConcentration[]) => void) | undefined {
+  if (wells === targetWells) return undefined
+  return updateWellsFromDoseResults(wells)
+}
+
+function updateWellsFromDoseResults<TValues extends Record<string, unknown>>(
+  source: ControlComponentPropSource<TValues>,
+): ((values: TValues) => (results: WellConcentration[]) => void) | undefined {
+  if (typeof source !== 'string') return undefined
+  return values => (results: WellConcentration[]) => {
+    const writableValues = values as Record<string, unknown>
+    const currentWells = recordValue(writableValues[source])
+    const nextWells: Record<string, Record<string, unknown>> = {}
+    for (const [wellId, well] of Object.entries(currentWells)) {
+      nextWells[wellId] = recordValue(well)
+    }
+
+    for (const result of results) {
+      const existing = recordValue(nextWells[result.wellId])
+      const metadata = recordValue(existing.metadata)
+      nextWells[result.wellId] = {
+        ...existing,
+        state: 'filled',
+        value: result.concentration.value,
+        metadata: {
+          ...metadata,
+          concentration: result.concentration,
+          ...(result.volume === undefined ? {} : { volume: result.volume }),
+        },
+      }
+    }
+
+    writableValues[source] = nextWells
+  }
+}

package/src/composables/controlSchemaFormFields.ts

@@ -13,7 +13,7 @@ import {
 } from './controlSchemaUtils'
 import type {
   ControlDefinition,
-} from './useControlSchema'
+} from './controlSchemaTypes'
 
 export function controlToFormField(control: NormalizedControl): FormFieldSchema {
   const { name, definition, type } = control

package/src/composables/controlSchemaLayout.ts

@@ -12,7 +12,7 @@ import type {
   ControlSchemaOptions,
   ControlSectionConfig,
   ControlSidebarConfig,
-} from './useControlSchema'
+} from './controlSchemaTypes'
 
 export function sectionConfig(
   sectionId: string,

package/src/composables/controlSchemaModel.ts

@@ -0,0 +1,163 @@
+import type {
+  ControlModel,
+  ControlModelBinding,
+  ControlModelSectionConfig,
+  ControlSchema,
+  ControlSectionConfig,
+  ControlSidebarConfig,
+  ControlViewConfig,
+  ControlWorkspaceOptions,
+} from './controlSchemaTypes'
+import {
+  normalizeControlDefinition,
+} from './controlSchemaNormalize'
+import {
+  omitUndefined,
+} from './controlSchemaUtils'
+
+export function isControlModelBinding<TBinding extends ControlModelBinding = ControlModelBinding>(
+  model: unknown,
+): model is TBinding {
+  return (
+    typeof model === 'object'
+    && model !== null
+    && 'controls' in model
+    && 'controlOptions' in model
+  )
+}
+
+export function resolveControlModel(
+  model: ControlModel | ControlModelBinding | undefined,
+): ControlModelBinding | undefined {
+  if (model === undefined) return undefined
+  return isControlModelBinding(model) ? model : defineControlModel(model)
+}
+
+/** Create a complete workspace component binding from a simple controls data model for ControlWorkspaceView, generated forms, and sidebars. */
+export function defineControlModel(model: ControlModel): ControlModelBinding {
+  const {
+    controls: rootControls,
+    sections: rootSections,
+    views: modelViews,
+    components,
+    componentBindings,
+    componentProps,
+    componentPropsById,
+    ...baseOptions
+  } = model
+  const resolvedComponentBindings = componentBindings ?? components
+  const controls: ControlSchema = {}
+  const views: Record<string, ControlViewConfig> = {}
+  const sections: Record<string, ControlSectionConfig> = {}
+
+  const defaultViewId = model.view ?? 'default'
+  const defaultSectionId = model.section ?? 'controls'
+
+  if (rootControls) {
+    registerSectionOptions(sections, defaultSectionId, {
+      id: defaultSectionId,
+      label: model.sectionLabel,
+      title: model.sectionLabel,
+      columns: model.columns,
+    })
+    appendModelControls(controls, rootControls, defaultViewId, defaultSectionId)
+  }
+
+  for (const [sectionId, section] of Object.entries(rootSections ?? {})) {
+    registerSectionOptions(sections, sectionId, controlModelSectionOptions(section))
+    appendModelControls(controls, section.controls, defaultViewId, sectionId, section.sidebar)
+  }
+
+  for (const [viewId, view] of Object.entries(modelViews ?? {})) {
+    const {
+      controls: viewControls,
+      sections: viewSections,
+      section,
+      sectionLabel,
+      sectionDescription,
+      ...viewConfig
+    } = view
+
+    views[viewId] = omitUndefined(viewConfig)
+
+    if (viewControls) {
+      const sectionId = section ?? `${viewId}-controls`
+      const label = sectionLabel ?? view.label
+      registerSectionOptions(sections, sectionId, {
+        id: sectionId,
+        label,
+        title: label,
+        description: sectionDescription,
+        columns: model.columns,
+      })
+      appendModelControls(controls, viewControls, viewId, sectionId)
+    }
+
+    for (const [sectionKey, sectionConfig] of Object.entries(viewSections ?? {})) {
+      const sectionId = sectionConfig.id ?? `${viewId}-${sectionKey}`
+      registerSectionOptions(sections, sectionId, controlModelSectionOptions(sectionConfig))
+      appendModelControls(controls, sectionConfig.controls, viewId, sectionId, sectionConfig.sidebar)
+    }
+  }
+
+  const controlOptions: ControlWorkspaceOptions = {
+    ...baseOptions,
+  }
+
+  if (Object.keys(views).length > 0) {
+    controlOptions.views = views
+  }
+
+  if (Object.keys(sections).length > 0) {
+    controlOptions.sections = sections
+  }
+
+  return {
+    controls,
+    controlOptions,
+    ...(resolvedComponentBindings === undefined ? {} : { componentBindings: resolvedComponentBindings }),
+    ...(componentProps === undefined ? {} : { componentProps }),
+    ...(componentPropsById === undefined ? {} : { componentPropsById }),
+  }
+}
+
+function appendModelControls(
+  target: ControlSchema,
+  source: ControlSchema,
+  viewId: string,
+  sectionId: string,
+  sidebar?: boolean | ControlSidebarConfig,
+): void {
+  for (const [name, input] of Object.entries(source)) {
+    if (Object.prototype.hasOwnProperty.call(target, name)) {
+      throw new Error(
+        `Duplicate control "${name}" in defineControlModel(). Control names must be unique across views and sections.`,
+      )
+    }
+
+    const definition = normalizeControlDefinition(input)
+    target[name] = omitUndefined({
+      ...definition,
+      view: definition.view ?? viewId,
+      section: definition.section ?? sectionId,
+      sidebar: definition.sidebar ?? sidebar,
+    })
+  }
+}
+
+function controlModelSectionOptions(section: ControlModelSectionConfig): ControlSectionConfig {
+  const { controls: _controls, sidebar: _sidebar, ...options } = section
+  return omitUndefined(options)
+}
+
+function registerSectionOptions(
+  target: Record<string, ControlSectionConfig>,
+  sectionId: string,
+  options: ControlSectionConfig,
+): void {
+  target[sectionId] = omitUndefined({
+    ...(target[sectionId] ?? {}),
+    ...options,
+    id: sectionId,
+  })
+}

package/src/composables/controlSchemaNormalize.ts

@@ -17,7 +17,7 @@ import type {
   ControlOptionValue,
   ControlSchema,
   ControlSchemaOptions,
-} from './useControlSchema'
+} from './controlSchemaTypes'
 
 export interface NormalizedControl {
   name: string