@morscherlab/mint-sdk 1.1.9 → 1.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morscherlab/mint-sdk",
-  "version": "1.1.9",
+  "version": "1.1.10",
   "description": "MINT Platform SDK — Vue 3 components, composables, and types for plugin development. MINT = Mass-spec INtegrated Toolkit.",
   "type": "module",
   "main": "./dist/index.js",

package/src/__tests__/components/AutoGroupModal.adapter.test.ts

@@ -3,13 +3,14 @@ import {
   candidateColumns,
   engineFieldsToCards,
   engineGroupsToRail,
+  engineSchemasToCards,
   engineToQcRoute,
   manualSamplesToResult,
   qcRouteToEngine,
   roleLabel,
   seedFromGroups,
 } from '../../components/AutoGroupModal.adapter'
-import type { ColumnInfo } from '../../types/auto-group'
+import type { ClassSchema, ColumnInfo } from '../../types/auto-group'
 import type { SampleGroup } from '../../types'
 import type { ManualSample } from '../../components/SmartGroupManual.cohorts'
 
@@ -85,6 +86,35 @@ describe('engineFieldsToCards', () => {
   })
 })
 
+describe('engineSchemasToCards', () => {
+  it('should expose enabled fields from another schema when the active schema has none enabled', () => {
+    const schemas: Record<string, ClassSchema> = {
+      active: {
+        classKind: 'unknown',
+        columns: [col({ index: 0, name: 'Token 1', role: 'factor', uniqueValues: ['5916', '5918'] })],
+        groupBy: [],
+      },
+      other: {
+        classKind: 'unknown',
+        columns: [
+          col({ index: 0, name: 'Token 1', role: 'constant', uniqueValues: ['sample'] }),
+          col({ index: 1, name: 'Token 2', role: 'factor', uniqueValues: ['1x', '2x'] }),
+        ],
+        groupBy: [1],
+      },
+    }
+
+    expect(engineSchemasToCards(schemas, 'active')).toEqual({
+      fields: [
+        { key: 'Token 1', role: 'Factor', vals: '5916, 5918', rep: false },
+        { key: 'Token 2', role: 'Factor', vals: '1x, 2x', rep: false },
+      ],
+      enabled: [false, true],
+      layers: [null, 1],
+    })
+  })
+})
+
 describe('engineGroupsToRail', () => {
   it('should map groups to {name, count, color} using sample length', () => {
     const groups: SampleGroup[] = [{ name: 'Control', color: '#111', samples: ['a', 'b'] }]

package/src/__tests__/components/SampleSelector.test.ts

@@ -246,6 +246,41 @@ describe('AutoGroupModal manual workflow', () => {
   })
 })
 
+describe('AutoGroupModal multi-schema auto workflow', () => {
+  it('should keep apply enabled when another sample schema still has a grouping field', async () => {
+    const samples = [
+      ...['5916', '5918', '5919', '5920', '5921'].map((id, index) =>
+        `${id}_batch_project_matrix_subject_${String(index + 1).padStart(3, '0')}`,
+      ),
+      ...Array.from({ length: 5 }, (_, index) =>
+        `sample_1x_${String(index + 1).padStart(3, '0')}`,
+      ),
+      ...Array.from({ length: 5 }, (_, index) =>
+        `sample_2x_${String(index + 6).padStart(3, '0')}`,
+      ),
+      'IQC_Pool_001',
+      'IQC_Pool_002',
+      'IQC_Pool_003',
+    ]
+    const wrapper = mount(AutoGroupModal, {
+      props: {
+        modelValue: true,
+        samples,
+      },
+      global: {
+        plugins: [createPinia()],
+        stubs: {
+          Teleport: true,
+        },
+      },
+    })
+
+    await wrapper.find('.sg-switch').trigger('click')
+
+    expect(wrapper.find('.sg-foot .mint-button--primary').attributes('disabled')).toBeUndefined()
+  })
+})
+
 describe('SampleSelector — QC overlay regression', () => {
   it('keeps QC samples in the emitted groups via the concat compat rule', async () => {
     const exp: SampleGroup[] = [

package/src/__tests__/composables/autoGroup/groupByOrder.test.ts

@@ -115,6 +115,16 @@ describe('useAutoGroup — field edits span every class exposing the field', ()
     expect(Object.values(auto.schemas.value).map(s => s.groupBy)).toEqual([[2, 1], [2, 1]])
   })
 
+  it('should move a field from a non-active schema when the active schema has it disabled', () => {
+    const auto = twoClassEngine()
+    const activeKey = auto.activeClassKey.value
+    auto.toggleGroupBy(activeKey, 2)
+
+    auto.moveGroupByField('Token 3', 'up')
+
+    expect(Object.values(auto.schemas.value).map(schema => schema.groupBy)).toEqual([[1], [2, 1]])
+  })
+
   it('should converge previously divergent class orders to the active schema order', () => {
     const auto = threeFactorClassEngine()
     const inactiveKey = Object.keys(auto.schemas.value).find(k => k !== auto.activeClassKey.value)!
@@ -178,12 +188,12 @@ describe('useAutoGroup — field edits span every class exposing the field', ()
     expect(Object.values(auto.schemas.value).map(s => s.groupBy)).toEqual([[2], [2]])
   })
 
-  it('should drive every class to the active class state rather than flipping each independently', () => {
+  it('should disable a batch field when any class still has it enabled', () => {
     const auto = twoClassEngine()
     // Diverge the classes: disable Timepoint in the non-active class only.
     const inactiveKey = Object.keys(auto.schemas.value).find(k => k !== auto.activeClassKey.value)!
     auto.toggleGroupBy(inactiveKey, 1)
-    // The card reads ON (from the active class), so toggling means OFF everywhere.
+    // The batch card reads ON while either class uses Timepoint.
     auto.toggleGroupByField('Timepoint')
     expect(Object.values(auto.schemas.value).every(s => !s.groupBy.includes(1))).toBe(true)
   })
@@ -195,6 +205,25 @@ describe('useAutoGroup — field edits span every class exposing the field', ()
     expect(Object.values(auto.schemas.value).map(s => s.groupBy)).toEqual([[2, 1], [2, 1]])
   })
 
+  it('should not enable a same-named constant column when re-enabling a batch field', () => {
+    const auto = twoClassEngine()
+    const activeKey = auto.activeClassKey.value
+    const active = auto.schemas.value[activeKey]
+    auto.schemas.value = {
+      ...auto.schemas.value,
+      [activeKey]: {
+        ...active,
+        columns: active.columns.map(column => column.index === 2 ? { ...column, role: 'constant' } : column),
+        groupBy: active.groupBy.filter(index => index !== 2),
+      },
+    }
+
+    auto.toggleGroupByField('Token 3')
+    auto.toggleGroupByField('Token 3')
+
+    expect(Object.values(auto.schemas.value).map(schema => schema.groupBy)).toEqual([[1], [1, 2]])
+  })
+
   it('should ignore a field name that no class exposes', () => {
     const auto = twoClassEngine()
     auto.moveGroupByField('Nonexistent', 'up')

package/src/components/AutoGroupModal.adapter.ts

@@ -4,7 +4,7 @@
  * `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 { AutoGroupResult, ClassSchema, 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'
@@ -61,6 +61,57 @@ export function engineFieldsToCards(
   }
 }
 
+/**
+ * Build the batch-wide field recipe from every class schema. The active schema
+ * stays first for a stable card order; fields and enabled hierarchy layers that
+ * only exist in another token-length/class split are appended instead of being
+ * hidden from the controlled UI.
+ */
+export function engineSchemasToCards(
+  schemas: Record<string, ClassSchema>,
+  activeClassKey: string,
+): { fields: SmartGroupField[]; enabled: boolean[]; layers: (number | null)[] } {
+  const entries = Object.entries(schemas)
+  const active = entries.find(([key]) => key === activeClassKey)
+  const ordered = active
+    ? [active, ...entries.filter(([key]) => key !== activeClassKey)]
+    : entries
+  const candidates = new Map<string, ColumnInfo>()
+  const enabledOrder: string[] = []
+  const enabled = new Set<string>()
+
+  for (const [, schema] of ordered) {
+    for (const index of schema.groupBy) {
+      const column = schema.columns.find(candidate => candidate.index === index)
+      if (!column) continue
+      const identity = column.displayName ?? column.name
+      if (!enabled.has(identity)) {
+        enabled.add(identity)
+        enabledOrder.push(identity)
+      }
+    }
+    for (const column of candidateColumns(schema.columns, schema.groupBy)) {
+      const identity = column.displayName ?? column.name
+      if (!candidates.has(identity)) candidates.set(identity, column)
+    }
+  }
+
+  const cards = [...candidates.entries()]
+  return {
+    fields: cards.map(([key, column]) => ({
+      key,
+      role: roleLabel(column.role),
+      vals: column.uniqueValues.join(', '),
+      rep: column.role === 'replicate',
+    })),
+    enabled: cards.map(([key]) => enabled.has(key)),
+    layers: cards.map(([key]) => {
+      const position = enabledOrder.indexOf(key)
+      return position === -1 ? null : position + 1
+    }),
+  }
+}
+
 /** 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 }))

package/src/components/AutoGroupModal.vue

@@ -17,8 +17,8 @@ import { useAutoGroup, parseCSV } from '../composables/useAutoGroup'
 import { useApi } from '../composables/useApi'
 import { readFileAsText } from '../composables/useFileImport'
 import {
-  engineFieldsToCards,
   engineGroupsToRail,
+  engineSchemasToCards,
   engineToQcRoute,
   manualSamplesToResult,
   qcRouteToEngine,
@@ -82,9 +82,11 @@ function setQcRouting(value: QcRouting) {
 }
 
 // ── Auto mode (Field Recipe) ─────────────────────────────────────────
-// The schema's ordered groupBy IS the hierarchy layer order (layer 1 first).
-const groupByOrder = computed(() => autoGroup.activeSchema.value?.groupBy ?? [])
-const fieldCards = computed(() => engineFieldsToCards(autoGroup.fields.value, groupByOrder.value))
+// The recipe represents the whole batch, including fields that only exist in
+// another class or token-length schema split.
+const fieldCards = computed(() =>
+  engineSchemasToCards(autoGroup.schemas.value, autoGroup.activeClassKey.value),
+)
 const railGroups = computed(() =>
   engineGroupsToRail(autoGroup.result.value.experimentalGroups ?? autoGroup.groups.value),
 )

package/src/composables/useAutoGroup.ts

@@ -311,7 +311,10 @@ export function useAutoGroup() {
   // the same field at a different position.
   function schemasExposing(fieldKey: string): { key: string; index: number }[] {
     return Object.entries(schemas.value).flatMap(([key, schema]) => {
-      const col = schema.columns.find(c => (c.displayName ?? c.name) === fieldKey)
+      const col = schema.columns.find(c =>
+        (c.displayName ?? c.name) === fieldKey
+        && (c.role === 'factor' || c.role === 'replicate' || schema.groupBy.includes(c.index)),
+      )
       return col ? [{ key, index: col.index }] : []
     })
   }
@@ -322,15 +325,14 @@ export function useAutoGroup() {
   }
 
   /**
-   * Toggle a grouping field across every class exposing it. The target state
-   * comes from the active class (what the card shows), so already-diverged
-   * classes converge instead of flipping in opposite directions.
+   * Toggle a grouping field across every class exposing it. The batch card is
+   * on when any schema groups by the field, so clicking it disables all such
+   * schemas; only a fully disabled field is enabled across the batch.
    */
   function toggleGroupByField(fieldKey: string) {
     const targets = schemasExposing(fieldKey)
     if (targets.length === 0) return
-    const active = targets.find(t => t.key === activeClassKey.value) ?? targets[0]
-    const enable = !(schemas.value[active.key]?.groupBy.includes(active.index) ?? false)
+    const enable = !targets.some(({ key, index }) => schemas.value[key]?.groupBy.includes(index))
     for (const { key, index } of targets) {
       const schema = schemas.value[key]
       if (!schema || schema.groupBy.includes(index) === enable) continue
@@ -347,7 +349,9 @@ export function useAutoGroup() {
   function moveGroupByField(fieldKey: string, direction: 'up' | 'down') {
     const targets = schemasExposing(fieldKey)
     if (targets.length === 0) return
-    const active = targets.find(target => target.key === activeClassKey.value) ?? targets[0]
+    const active = targets.find(target =>
+      target.key === activeClassKey.value && schemas.value[target.key]?.groupBy.includes(target.index),
+    ) ?? targets.find(target => schemas.value[target.key]?.groupBy.includes(target.index)) ?? targets[0]
     const activeSchema = schemas.value[active.key]
     if (!activeSchema) return
     const from = activeSchema.groupBy.indexOf(active.index)