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

package/src/composables/autoGroup/compose.ts

@@ -0,0 +1,156 @@
+import type {
+  AutoGroupResult,
+  ClassSchema,
+  ColumnInfo,
+  MetadataRow,
+  NumericBinning,
+  SampleClass,
+} from '../../types/auto-group'
+import type { SampleGroup } from '../../types/components'
+import { DEFAULT_COLORS, QC_OVERLAY_COLOR } from './colors'
+import { classKey } from './classKey'
+
+export interface ComposeInput {
+  tokenizedSamples: string[][]
+  sampleNames: string[]
+  schemas: Record<string, ClassSchema>
+  classes: SampleClass[]
+}
+
+/** Apply the operation pipeline to a single raw token value:
+ *   numeric-parse → alias → exclude → bin
+ *  Returns null if the row is excluded.
+ */
+function applyOps(col: ColumnInfo, raw: string): string | null {
+  let value = raw
+
+  // alias (operates on raw source value)
+  if (col.ops?.alias && raw in col.ops.alias) {
+    value = col.ops.alias[raw]
+  }
+
+  // exclude (post-alias)
+  if (col.ops?.exclude?.includes(raw) || col.ops?.exclude?.includes(value)) {
+    return null
+  }
+
+  // bin (only when role === 'numeric' and binning.mode === 'binned')
+  if (col.role === 'numeric' && col.binning?.mode === 'binned') {
+    const parsed = col.numeric?.byValue[raw]
+    if (parsed && col.binning.edges) {
+      const bin = pickBin(parsed.value, col.binning)
+      if (bin !== null) value = bin
+    }
+  }
+
+  return value
+}
+
+function pickBin(value: number, b: NumericBinning): string | null {
+  if (!b.edges || b.edges.length === 0) return null
+  for (let i = 0; i < b.edges.length; i++) {
+    if (value < b.edges[i]) {
+      return b.labels?.[i] ?? `< ${b.edges[i]}`
+    }
+  }
+  const last = b.edges[b.edges.length - 1]
+  return b.labels?.[b.edges.length] ?? `> ${last}`
+}
+
+export function composeGroups(input: ComposeInput): AutoGroupResult {
+  const experimentalGroups: SampleGroup[] = []
+  const qcGroups: SampleGroup[] = []
+  const excludedSamples: string[] = []
+  const metadata: MetadataRow[] = []
+  let colorIdx = 0
+
+  for (const cls of input.classes) {
+    const schema = input.schemas[classKey(cls)]
+    if (!schema) continue
+
+    if (cls.disposition === 'exclude') {
+      for (const m of cls.members) excludedSamples.push(input.sampleNames[m])
+      continue
+    }
+
+    // Per-class group map. group key built from enabled (groupBy) columns,
+    // joined with ' / ' for hierarchical display.
+    const groupMap = new Map<string, { name: string; samples: string[] }>()
+    const colByIdx = new Map(schema.columns.map(c => [c.index, c]))
+
+    for (const m of cls.members) {
+      const tokens = input.tokenizedSamples[m]
+      const rowName = input.sampleNames[m]
+      let excluded = false
+      const fieldValues: Record<string, string> = {}
+
+      for (const col of schema.columns) {
+        const sourceValues = col.sourceIndices.map(idx => tokens[idx] ?? '')
+        const raw = sourceValues.join('_') // merged columns join their source tokens
+        const display = applyOps(col, raw)
+        if (display === null) {
+          excluded = true
+          break
+        }
+        fieldValues[col.displayName ?? col.name] = display
+      }
+
+      if (excluded) {
+        excludedSamples.push(rowName)
+        continue
+      }
+
+      const keyParts: string[] =
+        cls.disposition === 'group'
+          ? schema.groupBy.map(idx => {
+              const col = colByIdx.get(idx)!
+              return fieldValues[col.displayName ?? col.name]
+            })
+          : [cls.label]
+
+      // Prepend the class label to the factor-key parts so group names carry
+      // class context (e.g. "Biological / Tissues / POS / 5min" instead of a
+      // bare "5min" that collides with another class's "5min").
+      //
+      // Only fires for disposition === 'group' classes with actual factor
+      // keyParts: overlay/exclude classes already use cls.label AS their
+      // single key part, so prefixing again would produce "IQC / IQC". The
+      // Unknown class also opts out — its label ("Unknown") adds no signal.
+      const useClassPrefix =
+        cls.disposition === 'group' && cls.kind !== 'unknown' && keyParts.length > 0
+      const groupKey = useClassPrefix
+        ? `${cls.label} / ${keyParts.join(' / ')}`
+        : keyParts.length > 0
+          ? keyParts.join(' / ')
+          : cls.label
+
+      const bucket = groupMap.get(groupKey)
+      if (bucket) {
+        bucket.samples.push(rowName)
+      } else {
+        groupMap.set(groupKey, { name: groupKey, samples: [rowName] })
+      }
+
+      metadata.push({ sampleName: rowName, fields: fieldValues, group: groupKey })
+    }
+
+    for (const { name, samples } of groupMap.values()) {
+      const color =
+        cls.disposition === 'overlay'
+          ? QC_OVERLAY_COLOR
+          : DEFAULT_COLORS[colorIdx++ % DEFAULT_COLORS.length]
+      const g: SampleGroup = { name, color, samples }
+      if (cls.disposition === 'overlay') qcGroups.push(g)
+      else experimentalGroups.push(g)
+    }
+  }
+
+  return {
+    groups: [...experimentalGroups, ...qcGroups],
+    experimentalGroups,
+    qcGroups,
+    metadata,
+    excludedSamples,
+    schemas: Object.values(input.schemas),
+  }
+}

package/src/composables/autoGroup/cooccurrence.ts

@@ -0,0 +1,46 @@
+import type { ClassSchema, MergeSuggestion } from '../../types/auto-group'
+
+const THRESHOLD = 0.95
+const MIN_CLASS_SIZE = 4
+
+function functionalDependency(rows: string[][], srcIdx: number, dstIdx: number): number {
+  const map = new Map<string, Set<string>>()
+  for (const row of rows) {
+    const a = row[srcIdx] ?? ''
+    const b = row[dstIdx] ?? ''
+    const set = map.get(a)
+    if (set) set.add(b)
+    else map.set(a, new Set([b]))
+  }
+  if (map.size === 0) return 0
+  let functional = 0
+  for (const set of map.values()) if (set.size === 1) functional++
+  return functional / map.size
+}
+
+export function findMerges(schema: ClassSchema, rows: string[][]): MergeSuggestion[] {
+  if (rows.length < MIN_CLASS_SIZE) return []
+
+  const out: MergeSuggestion[] = []
+  for (let i = 0; i < schema.columns.length - 1; i++) {
+    const a = schema.columns[i]
+    const b = schema.columns[i + 1]
+    if (a.role !== 'factor' && b.role !== 'factor') continue
+
+    const forward = functionalDependency(rows, a.index, b.index)
+    const backward = functionalDependency(rows, b.index, a.index)
+    if (forward < THRESHOLD || backward < THRESHOLD) continue
+
+    const merged = new Set(rows.map(r => `${r[a.index] ?? ''}_${r[b.index] ?? ''}`))
+    if (merged.size < 2) continue
+
+    out.push({
+      classKind: schema.classKind,
+      subKind: schema.subKind,
+      columnIndices: [a.index, b.index],
+      proposedName: `Column ${a.index + 1}–${b.index + 1}`,
+      confidence: Math.min(forward, backward),
+    })
+  }
+  return out
+}

package/src/composables/autoGroup/csv-shim.ts

@@ -0,0 +1,44 @@
+import type { ParsedCsvData } from '../../types/auto-group'
+
+function parseCSVLine(line: string, delimiter: string = ','): string[] {
+  const result: string[] = []
+  let current = ''
+  let inQuotes = false
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i]
+    if (char === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"'
+        i++
+      } else {
+        inQuotes = !inQuotes
+      }
+    } else if (char === delimiter && !inQuotes) {
+      result.push(current.trim())
+      current = ''
+    } else {
+      current += char
+    }
+  }
+  result.push(current.trim())
+  return result
+}
+
+export function parseCSV(text: string): ParsedCsvData {
+  const lines = text.trim().split('\n')
+  if (lines.length < 2) throw new Error('CSV must have at least a header and one data row')
+  const firstLine = lines[0]
+  const csvDelimiter = firstLine.includes('\t') ? '\t' : ','
+  const headers = parseCSVLine(firstLine, csvDelimiter)
+  const rows: Record<string, string>[] = []
+  for (let i = 1; i < lines.length; i++) {
+    const values = parseCSVLine(lines[i], csvDelimiter)
+    if (values.length !== headers.length) continue
+    const row: Record<string, string> = {}
+    headers.forEach((h, idx) => { row[h] = values[idx] })
+    rows.push(row)
+  }
+  const sampleKeywords = ['sample', 'name', 'id', 'sample_name', 'samplename', 'file name', 'filename', 'file_name']
+  const sampleColumn = headers.find(h => sampleKeywords.includes(h.toLowerCase())) ?? headers[0]
+  return { columns: headers, rows, sampleColumn, delimiter: csvDelimiter }
+}

package/src/composables/autoGroup/fingerprint.ts

@@ -0,0 +1,49 @@
+import type { ClassSchema, SchemaFingerprint } from '../../types/auto-group'
+
+export function serializeFingerprint(schemas: ClassSchema[]): SchemaFingerprint {
+  return {
+    version: 1,
+    classes: schemas.map(s => ({
+      kind: s.classKind,
+      subKind: s.subKind,
+      columns: s.columns.map(c => ({
+        name: c.displayName ?? c.name,
+        role: c.role ?? 'factor',
+        sourceIndices: c.sourceIndices,
+        binning: c.binning,
+        ops: c.ops,
+      })),
+      groupBy: s.groupBy,
+    })),
+  }
+}
+
+export function restoreFingerprint(
+  fp: SchemaFingerprint,
+  current: ClassSchema[],
+): ClassSchema[] {
+  return fp.classes.map(snap => {
+    const target = current.find(c => c.classKind === snap.kind && c.subKind === snap.subKind)
+    if (!target) {
+      throw new Error(
+        `Fingerprint class not present in current input: ${snap.kind}${snap.subKind ? '/' + snap.subKind : ''}`,
+      )
+    }
+    if (target.columns.length !== snap.columns.length) {
+      throw new Error(
+        `Saved schema expects ${snap.columns.length} columns, current data has ${target.columns.length} for class ${snap.kind}${snap.subKind ? '/' + snap.subKind : ''}. column count mismatch`,
+      )
+    }
+    return {
+      ...target,
+      groupBy: snap.groupBy,
+      columns: target.columns.map((col, i) => ({
+        ...col,
+        displayName: snap.columns[i].name,
+        role: snap.columns[i].role,
+        binning: snap.columns[i].binning,
+        ops: snap.columns[i].ops,
+      })),
+    }
+  })
+}

package/src/composables/autoGroup/index.ts

@@ -0,0 +1,20 @@
+export { splitMulti, pickPrimaryDelimiter } from './tokenize'
+export type { Delimiter } from './tokenize'
+export { detectClass, classVocab } from './classify'
+export type { ClassVocab, DetectClassOptions } from './classify'
+export { inferRole, parseNumeric, buildClassSchema } from './columns'
+export type { InferRoleInput } from './columns'
+export { findMerges } from './cooccurrence'
+export { composeGroups } from './compose'
+export type { ComposeInput } from './compose'
+export { serializeFingerprint, restoreFingerprint } from './fingerprint'
+export { composeTemplate } from './template'
+export type { TemplateOptions } from './template'
+export { DEFAULT_COLORS, QC_OVERLAY_COLOR } from './colors'
+export { classKey } from './classKey'
+export {
+  stripReplicateTokens,
+  preGroupReplicates,
+  expandGroupsWithReplicates,
+} from './replicatePreGroup'
+export type { ReplicatePreGrouping } from './replicatePreGroup'

package/src/composables/autoGroup/replicatePreGroup.ts

@@ -0,0 +1,90 @@
+/**
+ * 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 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]
+    }),
+  }))
+}

package/src/composables/autoGroup/template.ts

@@ -0,0 +1,126 @@
+import type { ClassSchema, ColumnInfo, SampleClass } from '../../types/auto-group'
+import { classKey } from './classKey'
+
+export interface TemplateOptions {
+  mode: 'blank' | 'prefilled'
+  format: 'csv' | 'tsv'
+  /** For prefilled mode. Indexed parallel to `samples`. */
+  tokenizedSamples?: string[][]
+  /** Used to compute the filename; omitted → falls back to `sample_metadata_<date>`. */
+  experimentCode?: string
+  /** Override the blank-mode suggested headers. Defaults to ['group','class','replicate','notes']. */
+  suggestedColumns?: string[]
+}
+
+const DEFAULT_BLANK_HEADERS = ['group', 'class', 'replicate', 'notes']
+
+function rfc4180Quote(cell: string): string {
+  if (/[",\n]/.test(cell)) {
+    return `"${cell.replace(/"/g, '""')}"`
+  }
+  return cell
+}
+
+function joinRow(cells: string[], sep: string): string {
+  return sep === ','
+    ? cells.map(rfc4180Quote).join(',')
+    : cells.join('\t')
+}
+
+function today(): string {
+  return new Date().toISOString().slice(0, 10)
+}
+
+export function composeTemplate(
+  samples: string[],
+  schemas: ClassSchema[] | null,
+  classes: SampleClass[] | null,
+  options: TemplateOptions,
+): { content: string; filename: string } {
+  const sep = options.format === 'tsv' ? '\t' : ','
+  const ext = options.format === 'tsv' ? 'tsv' : 'csv'
+
+  const stem = options.experimentCode ? `${options.experimentCode}_metadata` : 'sample_metadata'
+  const filename = `${stem}_${today()}.${ext}`
+
+  if (options.mode === 'blank' || !schemas || !classes) {
+    const headers = ['sample_name', ...(options.suggestedColumns ?? DEFAULT_BLANK_HEADERS)]
+    const rows = samples.map(s => {
+      const r = [s, ...Array(headers.length - 1).fill('')]
+      return joinRow(r, sep)
+    })
+    return { content: [joinRow(headers, sep), ...rows].join('\n'), filename }
+  }
+
+  // Prefilled mode: union of all class columns, wide layout.
+  const tokenized = options.tokenizedSamples ?? []
+  const allColumns: { schemaKey: string; colName: string }[] = []
+
+  // Hoist: build lookup maps before the per-sample loop.
+  const sampleToClass = new Map<number, SampleClass>()
+  for (const cls of classes) for (const m of cls.members) sampleToClass.set(m, cls)
+
+  const schemaByKey = new Map<string, ClassSchema>()
+  for (const s of schemas) {
+    const k = s.subKind ? `${s.classKind}:${s.subKind}` : s.classKind
+    schemaByKey.set(k, s)
+  }
+
+  const colByNameByKey = new Map<string, Map<string, ColumnInfo>>()
+  const groupBySetByKey = new Map<string, Set<number>>()
+  for (const s of schemas) {
+    const k = s.subKind ? `${s.classKind}:${s.subKind}` : s.classKind
+    const m = new Map<string, ColumnInfo>()
+    for (const c of s.columns) m.set(c.displayName ?? c.name, c)
+    colByNameByKey.set(k, m)
+    groupBySetByKey.set(k, new Set(s.groupBy))
+    // Collect allColumns with dedup via Set
+    const seenColNames = new Set<string>()
+    for (const c of s.columns) {
+      const name = c.displayName ?? c.name
+      if (!seenColNames.has(name)) {
+        seenColNames.add(name)
+        if (!allColumns.some(x => x.colName === name)) {
+          allColumns.push({ schemaKey: k, colName: name })
+        }
+      }
+    }
+  }
+
+  const headers = ['sample_name', 'class', ...allColumns.map(c => c.colName), 'group', 'notes']
+
+  const rows: string[] = []
+  for (let i = 0; i < samples.length; i++) {
+    const cls = sampleToClass.get(i)
+    const classLabel = cls?.label ?? ''
+    const tokens = tokenized[i] ?? []
+    const cells: string[] = [samples[i], classLabel]
+
+    if (cls) {
+      const k = classKey(cls)
+      const groupBySet = groupBySetByKey.get(k)
+      const colByName: Map<string, ColumnInfo> | undefined = colByNameByKey.get(k)
+      const keyParts: string[] = []
+      for (const col of allColumns) {
+        if (col.schemaKey === k && colByName) {
+          const schemaCol = colByName.get(col.colName)
+          const raw =
+            schemaCol?.sourceIndices.map(idx => tokens[idx] ?? '').join('_') ?? ''
+          cells.push(raw)
+          if (schemaCol && groupBySet?.has(schemaCol.index)) keyParts.push(raw)
+        } else {
+          cells.push('')
+        }
+      }
+      cells.push(keyParts.join(' / '))
+    } else {
+      for (const _ of allColumns) cells.push('')
+      cells.push('')
+    }
+
+    cells.push('') // notes
+    rows.push(joinRow(cells, sep))
+  }
+
+  return { content: [joinRow(headers, sep), ...rows].join('\n'), filename }
+}

package/src/composables/autoGroup/tokenize.ts

@@ -0,0 +1,41 @@
+const DELIMITER_CANDIDATES = ['_', '-', '.'] as const
+export type Delimiter = (typeof DELIMITER_CANDIDATES)[number]
+
+/** Pick the delimiter whose split produces the most consistent field count across `lines`. */
+export function pickPrimaryDelimiter(lines: string[]): Delimiter {
+  if (lines.length === 0) return '_'
+
+  let best: Delimiter = '_'
+  let bestScore = -1
+
+  for (const candidate of DELIMITER_CANDIDATES) {
+    const counts = lines.map(l => l.split(candidate).length)
+    const frequency = new Map<number, number>()
+    for (const c of counts) frequency.set(c, (frequency.get(c) ?? 0) + 1)
+
+    // Mode and its frequency
+    let mode = 1
+    let modeFreq = 0
+    for (const [c, f] of frequency) {
+      if (f > modeFreq || (f === modeFreq && c > mode)) {
+        mode = c
+        modeFreq = f
+      }
+    }
+
+    // A delimiter that produces field count 1 didn't split anything — score 0.
+    const score = mode > 1 ? modeFreq / lines.length : 0
+    if (score > bestScore) {
+      best = candidate
+      bestScore = score
+    }
+  }
+
+  return best
+}
+
+/** Split a single sample name on `delimiter`. Empty input returns `['']` so callers
+ *  always receive at least one token. */
+export function splitMulti(name: string, delimiter: Delimiter): string[] {
+  return name.split(delimiter)
+}

package/src/composables/autoGroup/vocab.json

@@ -0,0 +1,67 @@
+{
+  "$schema": "./vocab.schema.json",
+  "_doc": {
+    "purpose": "Sample-name classification vocabulary for the auto-group pipeline. Edit this file to teach the classifier new sample types or matrices without changing TypeScript. All matching is case-insensitive unless a pattern's regex flags say otherwise.",
+    "patterns": "Regex source strings (no surrounding slashes). Compiled with the `i` flag at load time.",
+    "standardAllow": "Tokens that should be classified as Standard even when they don't match `patterns.standard`. Case-sensitive — use the exact spelling that appears in your filenames.",
+    "matrixVocab": "Lowercase token → canonical display name. Tokens are normalised to lowercase before lookup, so adding 'tissues' handles 'Tissues' / 'TISSUES' / 'tissues' uniformly. Multiple aliases map to one canonical (e.g. cell + cells → Cells).",
+    "ionizationModes": "Lowercase polarity tokens (pos / positive / neg / negative). Suffixed to the subKind so POS and NEG acquisitions get independent schemas.",
+    "tissueParentTokens": "Tokens that flag the immediately-following token as the organ subKind (so `tissues / kidney` becomes Biological/Tissues, tagging both positions).",
+    "replicateStripPatterns": "Regex sources stripped from each sample name during the replicate pre-grouping pass. Samples whose stripped (base) names match are treated as replicates of one another and grouped together before tokenisation. Default set covers: trailing run-order numbers, _T<n>, _B<n>, and _Rep<n> markers."
+  },
+
+  "patterns": {
+    "blank":    "^(blank|blk|solv?blank|matrix.?blank)$",
+    "iqc":      "^iqc$",
+    "eqc":      "^eqc$",
+    "standard": "^(standard|std\\d*|cal(?:ibrator)?\\d*|.+standard)$",
+    "spikeIn":  "spike.?in",
+    "stock":    "^stock$"
+  },
+
+  "standardAllow": [
+    "ExtractionS",
+    "IS",
+    "internal.standard",
+    "PQC",
+    "pooledQC"
+  ],
+
+  "matrixVocab": {
+    "plasma":  "Plasma",
+    "serum":   "Serum",
+    "tissue":  "Tissue",
+    "tissues": "Tissues",
+    "kidney":  "Kidney",
+    "liver":   "Liver",
+    "tumor":   "Tumor",
+    "urine":   "Urine",
+    "brain":   "Brain",
+    "muscle":  "Muscle",
+    "adipose": "Adipose",
+    "csf":     "CSF",
+    "feces":   "Feces",
+    "faeces":  "Faeces",
+    "cells":   "Cells",
+    "cell":    "Cells",
+    "media":   "Media",
+    "medium":  "Medium",
+    "extract": "Extract"
+  },
+
+  "ionizationModes": {
+    "pos":      "POS",
+    "positive": "POS",
+    "neg":      "NEG",
+    "negative": "NEG"
+  },
+
+  "tissueParentTokens": ["tissue", "tissues"],
+
+  "replicateStripPatterns": [
+    "[_-]\\d{2,4}[A-Za-z]?$",
+    "[_-]T\\d+(?=[_-]|$)",
+    "[_-]B\\d+(?=[_-]|$)",
+    "[_-](?:rep(?:licate)?)\\d+(?=[_-]|$)"
+  ]
+}

package/src/composables/autoGroupConstants.ts

@@ -0,0 +1,4 @@
+export const DEFAULT_COLORS = [
+  '#3B82F6', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6',
+  '#EC4899', '#06B6D4', '#84CC16', '#F97316', '#6366F1',
+]