@morscherlab/mint-sdk 1.3.0 → 1.3.1

package/src/composables/autoGroup/replicatePreGroup.ts

@@ -1,124 +0,0 @@
-/**
- * Replicate pre-grouping.
- *
- * Strip the replicate / injection-number markers from each sample's name, then
- * collapse samples that share a base name. Those samples ARE replicates of one
- * another by definition; the remaining unique base names are what the rest of
- * the pipeline (tokenize → classify → schema → compose) should operate on.
- *
- * This pre-pass replaces the older "treat every sample as independent, then
- * infer replicate columns" approach. Identifying replicate-equivalence by name
- * before tokenisation removes a class of fragile cardinality heuristics.
- */
-
-import type { TreeNode } from '../../types/componentLabTypes'
-import vocabData from './vocab.json'
-
-const STRIP_PATTERNS: RegExp[] = (vocabData.replicateStripPatterns as string[]).map(
-  src => new RegExp(src, 'gi'),
-)
-
-/**
- * Iteratively strip every replicate / injection-number marker from `name`.
- * Each pattern is applied repeatedly until it stops matching, so a sample like
- * `study_T1_Rep2_004` collapses to `study` in one call.
- */
-export function stripReplicateTokens(name: string): string {
-  let base = name
-  for (const re of STRIP_PATTERNS) {
-    let prev
-    do {
-      prev = base
-      base = base.replace(re, '')
-      re.lastIndex = 0
-    } while (base !== prev)
-  }
-  return base
-}
-
-export interface ReplicatePreGrouping {
-  /** Unique base names in first-seen order. Length === `originalSamples.length` only if every sample has a distinct base. */
-  baseNames: string[]
-  /**
-   * `membersByBase[i]` = original-sample indices that collapsed onto `baseNames[i]`.
-   * Length of each entry is the replicate count for that base.
-   */
-  membersByBase: number[][]
-  /** Original sample names indexed by their position in `samples`. Retained so the compose layer can expand groups back to originals. */
-  originalSamples: string[]
-}
-
-export function preGroupReplicates(samples: string[]): ReplicatePreGrouping {
-  const map = new Map<string, number[]>()
-  const baseOrder: string[] = []
-  for (let i = 0; i < samples.length; i++) {
-    const base = stripReplicateTokens(samples[i])
-    const bucket = map.get(base)
-    if (bucket) {
-      bucket.push(i)
-    } else {
-      map.set(base, [i])
-      baseOrder.push(base)
-    }
-  }
-  return {
-    baseNames: baseOrder,
-    membersByBase: baseOrder.map(b => map.get(b)!),
-    originalSamples: samples,
-  }
-}
-
-/**
- * Expand groups produced over base names back to groups of original sample
- * names. Each entry in `group.samples` is treated as a base name and replaced
- * by the list of original samples that collapsed onto it.
- */
-export function expandGroupsWithReplicates<G extends { samples: string[] }>(
-  groups: G[],
-  preGrouping: ReplicatePreGrouping,
-): G[] {
-  const baseToMembers = new Map<string, number[]>()
-  for (let i = 0; i < preGrouping.baseNames.length; i++) {
-    baseToMembers.set(preGrouping.baseNames[i], preGrouping.membersByBase[i])
-  }
-  return groups.map(g => ({
-    ...g,
-    samples: g.samples.flatMap(baseName => {
-      const indices = baseToMembers.get(baseName)
-      return indices ? indices.map(i => preGrouping.originalSamples[i]) : [baseName]
-    }),
-  }))
-}
-
-/**
- * Expand a group hierarchy (built over base names) back to original samples.
- * Each leaf node's `label` is a base name; it is replaced by one leaf per
- * original sample that collapsed onto it (sharing the leaf's injection badge,
- * since collapsed replicates have identical base tokens). Every ancestor's
- * `badge` (sample count) is recomputed from the expanded leaf count so the tree
- * agrees with the flat groups produced by `expandGroupsWithReplicates`.
- */
-export function expandTreeWithReplicates(
-  nodes: TreeNode[],
-  preGrouping: ReplicatePreGrouping,
-): TreeNode[] {
-  const baseToOriginals = new Map<string, string[]>()
-  for (let i = 0; i < preGrouping.baseNames.length; i++) {
-    baseToOriginals.set(
-      preGrouping.baseNames[i],
-      preGrouping.membersByBase[i].map(m => preGrouping.originalSamples[m]),
-    )
-  }
-  const leafCount = (n: TreeNode): number =>
-    n.children && n.children.length ? n.children.reduce((acc, c) => acc + leafCount(c), 0) : 1
-  const expand = (node: TreeNode): TreeNode[] => {
-    if (node.children && node.children.length) {
-      const children = node.children.flatMap(expand)
-      return [{ ...node, children, badge: children.reduce((acc, c) => acc + leafCount(c), 0) }]
-    }
-    const originals = baseToOriginals.get(node.label)
-    if (!originals || originals.length === 0) return [node]
-    return originals.map((name, k) => ({ ...node, id: `${node.id}
${k}`, label: name }))
-  }
-  return nodes.flatMap(expand)
-}