@morscherlab/mint-sdk 1.2.0-beta.1 → 1.2.0-beta.3

package/src/components/AuditTrail.story.vue

@@ -1,163 +0,0 @@
-<script setup lang="ts">
-import AuditTrail from './AuditTrail.vue'
-
-const now = new Date()
-
-function minutesAgo(mins: number): Date {
-  return new Date(now.getTime() - mins * 60 * 1000)
-}
-
-function hoursAgo(hrs: number): Date {
-  return new Date(now.getTime() - hrs * 60 * 60 * 1000)
-}
-
-function daysAgo(days: number): Date {
-  return new Date(now.getTime() - days * 24 * 60 * 60 * 1000)
-}
-
-const mockEntries = [
-  {
-    id: 'e1',
-    type: 'create' as const,
-    action: 'Created experiment "Cisplatin Dose Response"',
-    detail: 'Initial setup with 96-well plate format, 8 concentration points.',
-    user: 'Elena Morscher',
-    timestamp: minutesAgo(5),
-    metadata: { 'Plate format': '96-well', 'Compounds': '1' },
-  },
-  {
-    id: 'e2',
-    type: 'update' as const,
-    action: 'Updated sample assignments',
-    detail: 'Assigned HeLa cells to wells A1-A12 and MCF-7 to wells B1-B12.',
-    user: 'Elena Morscher',
-    timestamp: minutesAgo(45),
-  },
-  {
-    id: 'e3',
-    type: 'update' as const,
-    action: 'Modified protocol step "Incubation"',
-    detail: 'Changed incubation time from 24h to 48h.',
-    user: 'Thomas Weber',
-    timestamp: hoursAgo(2),
-    metadata: { 'Previous': '24h', 'New': '48h' },
-  },
-  {
-    id: 'e4',
-    type: 'system' as const,
-    action: 'Plate reader measurement completed',
-    detail: 'Luminescence readout finished for plate 1. 96/96 wells measured successfully.',
-    user: undefined,
-    timestamp: hoursAgo(6),
-  },
-  {
-    id: 'e5',
-    type: 'delete' as const,
-    action: 'Removed blank wells from analysis',
-    detail: 'Wells H1-H12 excluded from dose-response curve fitting.',
-    user: 'Elena Morscher',
-    timestamp: daysAgo(1),
-  },
-  {
-    id: 'e6',
-    type: 'create' as const,
-    action: 'Generated analysis report',
-    detail: 'IC50 curve fitting completed. Report exported as PDF.',
-    user: 'Thomas Weber',
-    timestamp: daysAgo(2),
-    metadata: { 'IC50': '3.2 uM', 'R-squared': '0.98' },
-  },
-  {
-    id: 'e7',
-    type: 'system' as const,
-    action: 'Experiment status changed to "Completed"',
-    user: undefined,
-    timestamp: daysAgo(3),
-  },
-]
-
-function initState() {
-  return {
-    entries: mockEntries,
-    showFilters: false,
-    emptyMessage: 'No activity yet',
-    order: 'newest' as const,
-    size: 'md' as const,
-  }
-}
-</script>
-
-<template>
-  <Story title="Workflow/AuditTrail">
-    <Variant title="Playground" :init-state="initState">
-      <template #default="{ state }">
-        <div style="padding: 2rem; max-width: 600px;">
-          <AuditTrail
-            :entries="state.entries"
-            :show-filters="state.showFilters"
-            :empty-message="state.emptyMessage"
-            :order="state.order"
-            :size="state.size"
-          />
-        </div>
-      </template>
-      <template #controls="{ state }">
-        <HstCheckbox v-model="state.showFilters" title="Show Filters" />
-        <HstText v-model="state.emptyMessage" title="Empty Message" />
-        <HstSelect
-          v-model="state.order"
-          title="Order"
-          :options="[
-            { value: 'newest', label: 'Newest First' },
-            { value: 'oldest', label: 'Oldest First' },
-          ]"
-        />
-        <HstSelect
-          v-model="state.size"
-          title="Size"
-          :options="[
-            { value: 'sm', label: 'Small' },
-            { value: 'md', label: 'Medium' },
-            { value: 'lg', label: 'Large' },
-          ]"
-        />
-      </template>
-    </Variant>
-
-    <Variant title="With Filters">
-      <div style="padding: 2rem; max-width: 600px;">
-        <AuditTrail
-          :entries="mockEntries"
-          show-filters
-        />
-      </div>
-    </Variant>
-
-    <Variant title="With Max Height">
-      <div style="padding: 2rem; max-width: 600px;">
-        <AuditTrail
-          :entries="mockEntries"
-          max-height="300px"
-        />
-      </div>
-    </Variant>
-
-    <Variant title="Oldest First">
-      <div style="padding: 2rem; max-width: 600px;">
-        <AuditTrail
-          :entries="mockEntries"
-          order="oldest"
-        />
-      </div>
-    </Variant>
-
-    <Variant title="Empty">
-      <div style="padding: 2rem; max-width: 600px;">
-        <AuditTrail
-          :entries="[]"
-          empty-message="No audit events recorded"
-        />
-      </div>
-    </Variant>
-  </Story>
-</template>

package/src/components/AuditTrail.vue

@@ -1,151 +0,0 @@
-<script setup lang="ts">
-/** Filterable, sortable timeline of audit entries for tracking experiment or resource history. */
-import { computed, ref } from 'vue'
-import type { AuditEntryType, AuditEntry } from '../types'
-
-interface Props {
-  entries: AuditEntry[]
-  maxHeight?: string
-  showFilters?: boolean
-  emptyMessage?: string
-  order?: 'newest' | 'oldest'
-  size?: 'sm' | 'md' | 'lg'
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  showFilters: false,
-  emptyMessage: 'No activity yet',
-  order: 'newest',
-  size: 'md',
-})
-
-const emit = defineEmits<{
-  'entry-click': [entry: AuditEntry]
-}>()
-
-const filterType = ref<AuditEntryType | ''>('')
-const filterUser = ref('')
-
-const uniqueTypes = computed(() => {
-  const types = new Set(props.entries.map(e => e.type))
-  return Array.from(types)
-})
-
-const uniqueUsers = computed(() => {
-  const users = new Set(props.entries.flatMap(e => e.user ? [e.user] : []))
-  return Array.from(users)
-})
-
-const filteredEntries = computed(() => {
-  let result = props.entries
-  if (filterType.value) {
-    result = result.filter(e => e.type === filterType.value)
-  }
-  if (filterUser.value) {
-    result = result.filter(e => e.user === filterUser.value)
-  }
-  return result
-})
-
-const sortedEntries = computed(() => {
-  const entries = [...filteredEntries.value]
-  entries.sort((a, b) => {
-    const timeA = new Date(a.timestamp).getTime()
-    const timeB = new Date(b.timestamp).getTime()
-    return props.order === 'newest' ? timeB - timeA : timeA - timeB
-  })
-  return entries
-})
-
-function getInitials(name: string): string {
-  const words = name.trim().split(/\s+/)
-  if (words.length >= 2) {
-    return (words[0][0] + words[1][0]).toUpperCase()
-  }
-  return (words[0]?.[0] ?? '').toUpperCase()
-}
-
-const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' })
-
-function formatTimestamp(timestamp: Date | string): string {
-  const date = timestamp instanceof Date ? timestamp : new Date(timestamp)
-  const now = Date.now()
-  const diffMs = date.getTime() - now
-  const diffSec = Math.round(diffMs / 1000)
-  const diffMin = Math.round(diffSec / 60)
-  const diffHr = Math.round(diffMin / 60)
-  const diffDay = Math.round(diffHr / 24)
-  const diffWeek = Math.round(diffDay / 7)
-
-  if (Math.abs(diffSec) < 60) return rtf.format(diffSec, 'second')
-  if (Math.abs(diffMin) < 60) return rtf.format(diffMin, 'minute')
-  if (Math.abs(diffHr) < 24) return rtf.format(diffHr, 'hour')
-  if (Math.abs(diffDay) < 7) return rtf.format(diffDay, 'day')
-  if (Math.abs(diffWeek) < 5) return rtf.format(diffWeek, 'week')
-  return date.toLocaleDateString()
-}
-
-function handleEntryClick(entry: AuditEntry) {
-  emit('entry-click', entry)
-}
-</script>
-
-<template>
-  <div :class="['mint-audit-trail', `mint-audit-trail--${size}`]">
-    <div v-if="showFilters" class="mint-audit-trail__filters">
-      <select v-model="filterType" class="mint-audit-trail__filter-select">
-        <option value="">All types</option>
-        <option v-for="t in uniqueTypes" :key="t" :value="t">{{ t }}</option>
-      </select>
-      <select v-model="filterUser" class="mint-audit-trail__filter-select">
-        <option value="">All users</option>
-        <option v-for="u in uniqueUsers" :key="u" :value="u">{{ u }}</option>
-      </select>
-    </div>
-
-    <div
-      v-if="sortedEntries.length"
-      class="mint-audit-trail__list"
-      :style="maxHeight ? { maxHeight, overflowY: 'auto' } : {}"
-    >
-      <div class="mint-audit-trail__line" />
-      <div
-        v-for="entry in sortedEntries"
-        :key="entry.id"
-        :class="['mint-audit-trail__entry', `mint-audit-trail__entry--${entry.type}`]"
-        @click="handleEntryClick(entry)"
-      >
-        <slot name="entry" :entry="entry">
-          <div class="mint-audit-trail__dot" />
-          <div class="mint-audit-trail__content">
-            <div class="mint-audit-trail__header">
-              <div v-if="entry.user" class="mint-audit-trail__avatar">{{ getInitials(entry.user) }}</div>
-              <span v-if="entry.user" class="mint-audit-trail__user">{{ entry.user }}</span>
-              <span class="mint-audit-trail__timestamp">{{ formatTimestamp(entry.timestamp) }}</span>
-            </div>
-            <div class="mint-audit-trail__action">{{ entry.action }}</div>
-            <div v-if="entry.detail" class="mint-audit-trail__detail">{{ entry.detail }}</div>
-            <div v-if="entry.metadata && Object.keys(entry.metadata).length" class="mint-audit-trail__metadata">
-              <span
-                v-for="(value, key) in entry.metadata"
-                :key="String(key)"
-                class="mint-audit-trail__metadata-item"
-              >
-                <span class="mint-audit-trail__metadata-key">{{ key }}:</span>
-                {{ value }}
-              </span>
-            </div>
-          </div>
-        </slot>
-      </div>
-    </div>
-
-    <div v-if="!sortedEntries.length" class="mint-audit-trail__empty">
-      <slot name="empty">{{ emptyMessage }}</slot>
-    </div>
-  </div>
-</template>
-
-<style>
-@import '../styles/components/audit-trail.css';
-</style>

package/src/components/AutoGroupModal.adapter.ts

@@ -1,203 +0,0 @@
-/**
- * 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, 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'
-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. `groupBy` is the schema's ORDERED layer
- * list — entry N is hierarchy layer N of the composed group names.
- */
-export function candidateColumns(columns: ColumnInfo[], groupBy: readonly number[]): ColumnInfo[] {
-  const enabled = new Set(groupBy)
-  return columns.filter(c => c.role === 'factor' || c.role === 'replicate' || enabled.has(c.index))
-}
-
-/**
- * Map engine columns to Field Recipe cards + their on/off state (same order).
- * `layers` aligns with the cards: the column's 1-based position in the
- * `groupBy` layer order, or `null` when the column is not grouped by.
- */
-export function engineFieldsToCards(
-  columns: ColumnInfo[],
-  groupBy: readonly number[],
-): { fields: SmartGroupField[]; enabled: boolean[]; layers: (number | null)[] } {
-  const candidates = candidateColumns(columns, groupBy)
-  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 => groupBy.includes(c.index)),
-    layers: candidates.map(c => {
-      const pos = groupBy.indexOf(c.index)
-      return pos === -1 ? null : pos + 1
-    }),
-  }
-}
-
-/**
- * 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 }))
-}
-
-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: [] }
-}