@morscherlab/mint-sdk 1.0.44 → 1.0.46

package/src/__tests__/components/SmartGroupManual.cohorts.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest'
+import {
+  assignSamples,
+  buildCohortTree,
+  filterSamples,
+  type ManualSample,
+} from '../../components/SmartGroupManual.cohorts'
+
+/** Mirrors the design prototype's seeded default sample list. */
+function seededSamples(): ManualSample[] {
+  const blank = { group: null, sub: null, sub2: null, color: null } as const
+  const seed: Record<string, Partial<ManualSample>> = {
+    Pt001_TumorA_d7_rep1: { group: 'Responder', sub: 'Day 7', sub2: 'Batch 1', color: 'c-teal' },
+    Pt001_TumorA_d14_rep1: { group: 'Responder', sub: 'Day 14', color: 'c-teal' },
+    Pt002_TumorB_d7_rep1: { group: 'Non-responder', sub: 'Day 7', sub2: 'Batch 2', color: 'c-rose' },
+  }
+  return ['Pt001_TumorA_d7_rep1', 'Pt001_TumorA_d14_rep1', 'Pt002_TumorB_d7_rep1', 'QC_pool_01'].map(
+    name => ({ name, ...blank, ...(seed[name] ?? {}) }),
+  )
+}
+
+describe('buildCohortTree', () => {
+  const tree = buildCohortTree(seededSamples())
+
+  it('should ignore unassigned samples', () => {
+    expect(tree.size).toBe(2)
+    expect(tree.has('Responder')).toBe(true)
+    expect(tree.has('Non-responder')).toBe(true)
+  })
+
+  it('should total Responder across its two subgroups', () => {
+    const responder = tree.get('Responder')!
+    expect(responder.total).toBe(2)
+    expect(responder.subs.get('Day 7')!.total).toBe(1)
+    expect(responder.subs.get('Day 7')!.subs2.get('Batch 1')).toBe(1)
+    expect(responder.subs.get('Day 14')!.total).toBe(1)
+    expect(responder.subs.get('Day 14')!.subs2.get('—')).toBe(1)
+  })
+
+  it('should nest Non-responder under Day 7 / Batch 2', () => {
+    const nonResponder = tree.get('Non-responder')!
+    expect(nonResponder.total).toBe(1)
+    expect(nonResponder.subs.get('Day 7')!.subs2.get('Batch 2')).toBe(1)
+  })
+})
+
+describe('filterSamples', () => {
+  const samples = seededSamples()
+
+  it('should match names case-insensitively on a substring query', () => {
+    const matches = filterSamples(samples, 'tumorb', 'all')
+    expect(matches.map(m => m.sample.name)).toEqual(['Pt002_TumorB_d7_rep1'])
+  })
+
+  it('should preserve the original index for each match', () => {
+    const matches = filterSamples(samples, 'QC', 'all')
+    expect(matches).toEqual([{ sample: samples[3], index: 3 }])
+  })
+
+  it('should show only unassigned samples when filtered to unassigned', () => {
+    const matches = filterSamples(samples, '', 'unassigned')
+    expect(matches.map(m => m.sample.name)).toEqual(['QC_pool_01'])
+  })
+
+  it('should show only assigned samples when filtered to assigned', () => {
+    const matches = filterSamples(samples, '', 'assigned')
+    expect(matches).toHaveLength(3)
+    expect(matches.every(m => !!m.sample.group)).toBe(true)
+  })
+})
+
+describe('assignSamples', () => {
+  const samples = seededSamples()
+
+  it('should assign group and colour to the selected indices only', () => {
+    const next = assignSamples(samples, new Set([3]), {
+      grp: 'Pooled',
+      sub: '',
+      sub2: '',
+      color: 'c-slate',
+    })
+    expect(next[3]).toMatchObject({ group: 'Pooled', color: 'c-slate' })
+    expect(next[0]).toEqual(samples[0])
+  })
+
+  it('should null out blank subgroup and sub-subgroup values', () => {
+    const next = assignSamples(samples, new Set([3]), {
+      grp: '  Pooled  ',
+      sub: '   ',
+      sub2: '',
+      color: 'c-slate',
+    })
+    expect(next[3].group).toBe('Pooled')
+    expect(next[3].sub).toBeNull()
+    expect(next[3].sub2).toBeNull()
+  })
+})

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: [] }
+}