@morscherlab/mint-sdk 1.0.43 → 1.0.45

package/src/components/AutoGroupModal.adapter.ts

@@ -0,0 +1,147 @@
+/**
+ * Pure adapters mapping the `useAutoGroup` engine state to the controlled
+ * Smart Group UI (`SmartGroupFieldRecipe` / `SmartGroupManual`) and back to an
+ * `AutoGroupResult`. Framework-free so the mapping is unit-testable in isolation
+ * from `AutoGroupModal.vue`.
+ */
+import type { AutoGroupResult, ColumnInfo, ColumnRole } from '../types/auto-group'
+import type { SampleGroup } from '../types'
+import type { FieldRecipeGroup, QcRoute, SmartGroupField } from './SmartGroupFieldRecipe.groups'
+import type { ManualSample } from './SmartGroupManual.cohorts'
+import type { SmartGroupSeed } from './SmartGroup.types'
+
+const ROLE_LABELS: Record<ColumnRole, string> = {
+  'constant': 'Constant',
+  'factor': 'Factor',
+  'replicate': 'Replicate',
+  'run-order': 'Run',
+  'numeric': 'Numeric',
+  'class-tag': 'Class tag',
+  'ignore': 'Ignore',
+}
+
+/** Human label for a column role; defaults to `Factor` when unset. */
+export function roleLabel(role?: ColumnRole): string {
+  return role ? ROLE_LABELS[role] : 'Factor'
+}
+
+/**
+ * Columns worth offering as grouping toggles: factors and replicates, plus any
+ * column already enabled in `groupBy` (so a manual group-by choice still shows).
+ * Preserves the engine's column order.
+ */
+export function candidateColumns(columns: ColumnInfo[], enabled: ReadonlySet<number>): ColumnInfo[] {
+  return columns.filter(c => c.role === 'factor' || c.role === 'replicate' || enabled.has(c.index))
+}
+
+/** The candidate column indices in display order, so card index → engine column. */
+export function candidateColumnIndices(columns: ColumnInfo[], enabled: ReadonlySet<number>): number[] {
+  return candidateColumns(columns, enabled).map(c => c.index)
+}
+
+/** Map engine columns to Field Recipe cards + their on/off state (same order). */
+export function engineFieldsToCards(
+  columns: ColumnInfo[],
+  enabled: ReadonlySet<number>,
+): { fields: SmartGroupField[]; enabled: boolean[] } {
+  const candidates = candidateColumns(columns, enabled)
+  return {
+    fields: candidates.map(c => ({
+      key: c.displayName ?? c.name,
+      role: roleLabel(c.role),
+      vals: c.uniqueValues.join(', '),
+      rep: c.role === 'replicate',
+    })),
+    enabled: candidates.map(c => enabled.has(c.index)),
+  }
+}
+
+/** Map engine sample groups to the live preview rail shape. */
+export function engineGroupsToRail(groups: SampleGroup[]): FieldRecipeGroup[] {
+  return groups.map(g => ({ name: g.name, count: g.samples.length, color: g.color }))
+}
+
+const ROUTE_TO_ENGINE: Record<QcRoute, 'overlay' | 'exclude' | 'mix'> = {
+  'Overlay only': 'overlay',
+  'Exclude': 'exclude',
+  'Mix into groups': 'mix',
+}
+const ENGINE_TO_ROUTE: Record<'overlay' | 'exclude' | 'mix', QcRoute> = {
+  overlay: 'Overlay only',
+  exclude: 'Exclude',
+  mix: 'Mix into groups',
+}
+
+/** Map the Field Recipe QC label to the engine's class disposition routing. */
+export function qcRouteToEngine(route: QcRoute): 'overlay' | 'exclude' | 'mix' {
+  return ROUTE_TO_ENGINE[route]
+}
+
+/** Map the engine's QC routing back to the Field Recipe label. */
+export function engineToQcRoute(routing: 'overlay' | 'exclude' | 'mix'): QcRoute {
+  return ENGINE_TO_ROUTE[routing]
+}
+
+/**
+ * Seed the manual cohort builder from existing groups. The hierarchical group
+ * name (`group/sub/sub2`) splits into the three cohort levels; colour carries
+ * over. One seed entry per sample. Names with more than three `/`-segments keep
+ * the remainder in `sub2` (rejoined with `/`) so the round-trip is lossless —
+ * `manualSamplesToResult` re-joins on `/`.
+ */
+export function seedFromGroups(groups: SampleGroup[]): Record<string, SmartGroupSeed> {
+  const seed: Record<string, SmartGroupSeed> = {}
+  for (const group of groups) {
+    const parts = group.name.split('/')
+    const grp = parts[0]
+    const sub = parts[1]
+    const sub2 = parts.length > 3 ? parts.slice(2).join('/') : parts[2]
+    for (const sample of group.samples) {
+      seed[sample] = {
+        group: grp,
+        sub: sub || undefined,
+        sub2: sub2 || undefined,
+        color: group.color,
+      }
+    }
+  }
+  return seed
+}
+
+/**
+ * Convert the manual cohort assignments back into an `AutoGroupResult`.
+ * `baseGroups` (the modal's incoming `groups` prop) are preserved in their
+ * original order and colour — including any that end up empty — so re-opening
+ * the modal and moving samples between cohorts is non-destructive. Newly created
+ * cohorts are appended in first-seen order.
+ */
+export function manualSamplesToResult(
+  samples: ManualSample[],
+  baseGroups: SampleGroup[] = [],
+): AutoGroupResult {
+  const assigned = new Map<string, { color: string; samples: string[] }>()
+  const order: string[] = []
+  for (const sample of samples) {
+    if (!sample.group) continue
+    const name = [sample.group, sample.sub, sample.sub2].filter(Boolean).join('/')
+    if (!assigned.has(name)) {
+      assigned.set(name, { color: sample.color ?? '', samples: [] })
+      order.push(name)
+    }
+    assigned.get(name)!.samples.push(sample.name)
+  }
+
+  const groups: SampleGroup[] = []
+  const consumed = new Set<string>()
+  for (const base of baseGroups) {
+    consumed.add(base.name)
+    groups.push({ name: base.name, color: base.color, samples: assigned.get(base.name)?.samples ?? [] })
+  }
+  for (const name of order) {
+    if (consumed.has(name)) continue
+    const entry = assigned.get(name)!
+    groups.push({ name, color: entry.color, samples: entry.samples })
+  }
+
+  return { groups, experimentalGroups: groups, qcGroups: [], metadata: [], excludedSamples: [] }
+}