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

package/src/components/internal/PlateMapEditorToolbarInternal.vue

@@ -1,128 +0,0 @@
-<script setup lang="ts">
-/** Toolbar for PlateMapEditor plate tabs and import/export history actions. */
-import type { PlateMap } from '../../types'
-
-interface Props {
-  plates: PlateMap[]
-  activePlateId?: string
-  plateWellCounts: Record<string, number>
-  canAddPlate: boolean
-  canUndo: boolean
-  canRedo: boolean
-  slotColorForPlate: (plateId: string, plateIndex: number) => string
-}
-
-const props = defineProps<Props>()
-
-const emit = defineEmits<{
-  'select-plate': [plateId: string]
-  'remove-plate': [plateId: string]
-  'add-plate': []
-  undo: []
-  redo: []
-  import: []
-  'export-json': []
-}>()
-</script>
-
-<template>
-  <div class="mint-plate-editor__toolbar">
-    <div class="mint-plate-editor__tabs">
-      <button
-        v-for="(plate, index) in plates"
-        :key="plate.id"
-        type="button"
-        :class="['mint-plate-editor__tab', { 'mint-plate-editor__tab--active': plate.id === activePlateId }]"
-        @click="emit('select-plate', plate.id)"
-      >
-        <span
-          class="mint-plate-editor__tab-slot"
-          :style="{ backgroundColor: slotColorForPlate(plate.id, index) }"
-        />
-        <span class="mint-plate-editor__tab-name">{{ plate.name }}</span>
-        <span
-          v-if="plateWellCounts[plate.id] > 0"
-          class="mint-plate-editor__tab-count"
-        >
-          {{ plateWellCounts[plate.id] }}
-        </span>
-        <button
-          v-if="props.plates.length > 1"
-          type="button"
-          class="mint-plate-editor__tab-remove"
-          :aria-label="`Remove ${plate.name}`"
-          @click.stop="emit('remove-plate', plate.id)"
-        >
-          <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-            <path d="M18 6 6 18" /><path d="m6 6 12 12" />
-          </svg>
-        </button>
-      </button>
-
-      <button
-        v-if="canAddPlate"
-        type="button"
-        class="mint-plate-editor__add-plate"
-        aria-label="Add plate"
-        @click="emit('add-plate')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="M5 12h14" /><path d="M12 5v14" />
-        </svg>
-        <span>Add</span>
-      </button>
-    </div>
-
-    <div class="mint-plate-editor__spacer" />
-
-    <div class="mint-plate-editor__actions">
-      <button
-        type="button"
-        :disabled="!canUndo"
-        class="mint-plate-editor__action-btn"
-        title="Undo (Ctrl+Z)"
-        @click="emit('undo')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="M9 14 4 9l5-5" /><path d="M4 9h10.5a5.5 5.5 0 0 1 5.5 5.5a5.5 5.5 0 0 1-5.5 5.5H11" />
-        </svg>
-      </button>
-
-      <button
-        type="button"
-        :disabled="!canRedo"
-        class="mint-plate-editor__action-btn"
-        title="Redo (Ctrl+Shift+Z)"
-        @click="emit('redo')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="m15 14 5-5-5-5" /><path d="M20 9H9.5A5.5 5.5 0 0 0 4 14.5A5.5 5.5 0 0 0 9.5 20H13" />
-        </svg>
-      </button>
-
-      <div class="mint-plate-editor__divider" />
-
-      <button
-        type="button"
-        class="mint-plate-editor__action-btn"
-        title="Import"
-        @click="emit('import')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="M12 3v12" /><path d="m17 8-5-5-5 5" /><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
-        </svg>
-      </button>
-
-      <button
-        type="button"
-        class="mint-plate-editor__action-btn"
-        title="Export JSON"
-        @click="emit('export-json')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="M12 15V3" /><path d="m7 10 5 5 5-5" /><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
-        </svg>
-      </button>
-    </div>
-  </div>
-</template>

package/src/components/internal/WellEditPopupInternal.vue

@@ -1,230 +0,0 @@
-<script setup lang="ts">
-import { ref, watch, computed } from 'vue'
-import type { Well, WellEditData, WellEditField } from '../../types'
-import { useEventListener } from '../../composables/useEventListener'
-
-interface Props {
-  wellId: string
-  wellData?: Partial<Well>
-  editFields?: WellEditField[]
-  defaultInjectionVolume?: number
-  position: { x: number; y: number }
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  wellData: () => ({}),
-  editFields: () => ['label', 'sampleType', 'injectionVolume', 'injectionCount', 'customMethod'],
-  defaultInjectionVolume: 5,
-})
-
-const emit = defineEmits<{
-  save: [data: WellEditData]
-  clear: []
-  close: []
-}>()
-
-const showAdvanced = ref(false)
-
-const formData = ref({
-  label: '',
-  sampleType: 'sample',
-  injectionVolume: props.defaultInjectionVolume,
-  injectionCount: 1,
-  customMethod: '',
-})
-
-watch(
-  () => [props.wellId, props.wellData] as const,
-  () => {
-    const meta = props.wellData?.metadata as Record<string, unknown> | undefined
-    formData.value = {
-      label: (meta?.label as string) || '',
-      sampleType: props.wellData?.sampleType || 'sample',
-      injectionVolume: (meta?.injectionVolume as number) || props.defaultInjectionVolume,
-      injectionCount: (meta?.injectionCount as number) || 1,
-      customMethod: (meta?.customMethod as string) || '',
-    }
-    showAdvanced.value = (formData.value.injectionCount > 1) || !!formData.value.customMethod
-  },
-  { immediate: true },
-)
-
-const hasField = (field: WellEditField) => props.editFields.includes(field)
-
-const popupStyle = computed(() => {
-  const x = props.position.x
-  const y = props.position.y
-  const style: Record<string, string> = {
-    left: `${x}px`,
-    top: `${y}px`,
-  }
-  return style
-})
-
-function save() {
-  emit('save', {
-    wellId: props.wellId,
-    label: formData.value.label.trim(),
-    sampleType: formData.value.sampleType,
-    injectionVolume: formData.value.injectionVolume,
-    injectionCount: formData.value.injectionCount || 1,
-    customMethod: formData.value.customMethod?.trim() || '',
-  })
-}
-
-function clear() {
-  emit('clear')
-}
-
-function close() {
-  emit('close')
-}
-
-function handleKeydown(e: KeyboardEvent) {
-  if (e.key === 'Escape') close()
-}
-
-useEventListener(() => document, 'keydown', handleKeydown)
-
-const sampleTypeButtons = [
-  { type: 'sample', label: 'S', tooltip: 'Sample' },
-  { type: 'blank', label: 'B', tooltip: 'Blank' },
-  { type: 'qc', label: 'Q', tooltip: 'QC' },
-  { type: 'iqc', label: 'I', tooltip: 'IQC' },
-]
-</script>
-
-<template>
-  <Teleport to="body">
-    <!-- Backdrop -->
-    <div class="mint-well-edit-popup__backdrop" @click="close" />
-
-    <!-- Popup -->
-    <div
-      class="mint-well-edit-popup"
-      :style="popupStyle"
-      @click.stop
-    >
-      <!-- Header -->
-      <div class="mint-well-edit-popup__header">
-        <div class="mint-well-edit-popup__header-left">
-          <span class="mint-well-edit-popup__well-id">{{ wellId }}</span>
-          <span class="mint-well-edit-popup__title">Edit Well</span>
-        </div>
-        <button class="mint-well-edit-popup__close" @click="close">
-          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-            <path d="M18 6 6 18" /><path d="m6 6 12 12" />
-          </svg>
-        </button>
-      </div>
-
-      <!-- Body -->
-      <div class="mint-well-edit-popup__body">
-        <!-- Sample Name -->
-        <div v-if="hasField('label')">
-          <label class="mint-well-edit-popup__label">Sample Name</label>
-          <input
-            v-model="formData.label"
-            type="text"
-            placeholder="e.g., Sample_001"
-            class="mint-well-edit-popup__input"
-            @keydown.enter="save"
-            autofocus
-          />
-        </div>
-
-        <!-- Type + Volume row -->
-        <div class="mint-well-edit-popup__row">
-          <div v-if="hasField('sampleType')">
-            <label class="mint-well-edit-popup__label">Type</label>
-            <div class="mint-well-edit-popup__type-grid">
-              <button
-                v-for="btn in sampleTypeButtons"
-                :key="btn.type"
-                :title="btn.tooltip"
-                class="mint-well-edit-popup__type-btn"
-                :class="{
-                  [`mint-well-edit-popup__type-btn--${btn.type}`]: formData.sampleType === btn.type,
-                }"
-                @click="formData.sampleType = btn.type"
-              >
-                {{ btn.label }}
-              </button>
-            </div>
-          </div>
-          <div v-if="hasField('injectionVolume')">
-            <label class="mint-well-edit-popup__label">Volume (uL)</label>
-            <input
-              v-model.number="formData.injectionVolume"
-              type="number"
-              min="0.1"
-              max="100"
-              step="0.5"
-              class="mint-well-edit-popup__input"
-            />
-          </div>
-        </div>
-
-        <!-- Advanced toggle -->
-        <label
-          v-if="hasField('injectionCount') || hasField('customMethod')"
-          class="mint-well-edit-popup__advanced-toggle"
-        >
-          <input type="checkbox" v-model="showAdvanced" />
-          <span>Advanced options</span>
-        </label>
-
-        <!-- Advanced fields -->
-        <template v-if="showAdvanced">
-          <!-- Injection count -->
-          <div v-if="hasField('injectionCount')">
-            <label class="mint-well-edit-popup__label">Repeat Injections</label>
-            <div class="mint-well-edit-popup__count-grid">
-              <button
-                v-for="n in [1, 2, 3, 4, 5]"
-                :key="n"
-                class="mint-well-edit-popup__count-btn"
-                :class="{ 'mint-well-edit-popup__count-btn--active': formData.injectionCount === n }"
-                @click="formData.injectionCount = n"
-              >
-                {{ n }}&times;
-              </button>
-              <input
-                v-model.number="formData.injectionCount"
-                type="number"
-                min="1"
-                max="10"
-                class="mint-well-edit-popup__count-input"
-              />
-            </div>
-          </div>
-
-          <!-- Custom method -->
-          <div v-if="hasField('customMethod')">
-            <label class="mint-well-edit-popup__label">Custom Method Path</label>
-            <input
-              v-model="formData.customMethod"
-              type="text"
-              placeholder="Leave empty for default"
-              class="mint-well-edit-popup__input mint-well-edit-popup__input--mono"
-            />
-          </div>
-        </template>
-      </div>
-
-      <!-- Footer -->
-      <div class="mint-well-edit-popup__footer">
-        <button class="mint-well-edit-popup__btn mint-well-edit-popup__btn--clear" @click="clear">
-          Clear Well
-        </button>
-        <button class="mint-well-edit-popup__btn mint-well-edit-popup__btn--save" @click="save">
-          Save
-        </button>
-      </div>
-    </div>
-  </Teleport>
-</template>
-
-<style>
-@import '../../styles/components/well-edit-popup.css';
-</style>

package/src/composables/analysisArtifactTarget.ts

@@ -1,53 +0,0 @@
-import type { AnalysisArtifactTarget } from '../types/analysisArtifactTypes'
-
-const EXPERIMENT_ID = 'experiment_id'
-const ARTIFACT_PLUGIN_ID = 'artifact_plugin_id'
-const ARTIFACT_KEY = 'artifact_key'
-const ARTIFACT_ID = 'artifact_id'
-
-function parsePositiveInteger(value: string | null): number | undefined {
-  if (value === null || !/^\d+$/.test(value)) return undefined
-  const parsed = Number(value)
-  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined
-}
-
-/** Build the canonical query used to open one analysis artifact in a plugin. */
-export function buildAnalysisArtifactTargetQuery(
-  target: AnalysisArtifactTarget,
-): URLSearchParams {
-  const query = new URLSearchParams()
-  query.set(EXPERIMENT_ID, String(target.experimentId))
-  query.set(ARTIFACT_PLUGIN_ID, target.artifactPluginId)
-  query.set(ARTIFACT_KEY, target.artifactKey)
-  if (target.artifactId !== undefined) {
-    query.set(ARTIFACT_ID, String(target.artifactId))
-  }
-  return query
-}
-
-/** Parse a complete canonical target. Incomplete or invalid input is not guessed. */
-export function parseAnalysisArtifactTarget(
-  query: URLSearchParams,
-): AnalysisArtifactTarget | null {
-  const experimentId = parsePositiveInteger(query.get(EXPERIMENT_ID))
-  const artifactPluginId = query.get(ARTIFACT_PLUGIN_ID)?.trim()
-  const artifactKey = query.get(ARTIFACT_KEY)?.trim()
-  const rawArtifactId = query.get(ARTIFACT_ID)
-  const artifactId = parsePositiveInteger(rawArtifactId)
-
-  if (
-    experimentId === undefined
-    || !artifactPluginId
-    || !artifactKey
-    || (rawArtifactId !== null && artifactId === undefined)
-  ) {
-    return null
-  }
-
-  return {
-    experimentId,
-    artifactPluginId,
-    artifactKey,
-    ...(artifactId === undefined ? {} : { artifactId }),
-  }
-}

package/src/composables/autoGroup/classKey.ts

@@ -1,8 +0,0 @@
-import type { SampleClass } from '../../types/auto-group'
-
-export function classKey(
-  c: Pick<SampleClass, 'kind'> & { subKind?: string; tokenLength?: number },
-): string {
-  const base = c.subKind ? `${c.kind}:${c.subKind}` : c.kind
-  return c.tokenLength != null ? `${base}#${c.tokenLength}` : base
-}

package/src/composables/autoGroup/classify.ts

@@ -1,205 +0,0 @@
-import type { SampleClass, SampleClassKind, ClassDisposition } from '../../types/auto-group'
-import { classKey } from './classKey'
-import vocabData from './vocab.json'
-
-export interface ClassVocab {
-  blankPattern: RegExp
-  iqcPattern: RegExp
-  eqcPattern: RegExp
-  standardPattern: RegExp
-  standardAllow: Set<string>
-  spikeInPattern: RegExp
-  stockPattern: RegExp
-  /**
-   * Matrix lookup: lowercase token → canonical display name. Matching is
-   * case-insensitive, and several aliases can collapse to one display name
-   * (cell → Cells, medium → Medium).
-   */
-  matrixVocab: Map<string, string>
-  /** Lowercase polarity tokens → POS / NEG. */
-  ionizationModes: Map<string, 'POS' | 'NEG'>
-  /** Lowercase tokens that flag the next token as the organ subKind. */
-  tissueParentTokens: Set<string>
-}
-
-type VocabFile = typeof vocabData
-type IonMode = 'POS' | 'NEG'
-
-function compileVocab(data: VocabFile): ClassVocab {
-  return {
-    blankPattern: new RegExp(data.patterns.blank, 'i'),
-    iqcPattern: new RegExp(data.patterns.iqc, 'i'),
-    eqcPattern: new RegExp(data.patterns.eqc, 'i'),
-    standardPattern: new RegExp(data.patterns.standard, 'i'),
-    spikeInPattern: new RegExp(data.patterns.spikeIn, 'i'),
-    stockPattern: new RegExp(data.patterns.stock, 'i'),
-    standardAllow: new Set(data.standardAllow),
-    matrixVocab: new Map(Object.entries(data.matrixVocab)),
-    ionizationModes: new Map(
-      Object.entries(data.ionizationModes).map(([k, v]) => [k, v as IonMode]),
-    ),
-    tissueParentTokens: new Set(data.tissueParentTokens),
-  }
-}
-
-export const classVocab: ClassVocab = compileVocab(vocabData)
-
-function matrixCanonical(token: string, vocab: ClassVocab): string | undefined {
-  return vocab.matrixVocab.get(token.toLowerCase())
-}
-
-function isTissueParentToken(token: string, vocab: ClassVocab): boolean {
-  return vocab.tissueParentTokens.has(token.toLowerCase())
-}
-
-export interface DetectClassOptions {
-  vocab?: Partial<ClassVocab>
-  /** Per-sample explicit `sample_type` hint (e.g. from experiment design data). */
-  sampleTypeHints?: (string | undefined)[]
-}
-
-const DEFAULT_DISPOSITION: Record<SampleClassKind, ClassDisposition> = {
-  biological: 'group',
-  iqc: 'overlay',
-  eqc: 'overlay',
-  standard: 'overlay',
-  'spike-in': 'overlay',
-  stock: 'overlay',
-  blank: 'overlay',
-  unknown: 'group',
-}
-
-function classifyTokens(
-  tokens: string[],
-  vocab: ClassVocab,
-): { kind: SampleClassKind; subKind?: string; tagPositions: number[] } {
-  // First-match-wins ordering: Blank → IQC → EQC → Standard → SpikeIn → Stock → Biological → Unknown.
-  for (let i = 0; i < tokens.length; i++) {
-    if (vocab.blankPattern.test(tokens[i])) return { kind: 'blank', tagPositions: [i] }
-  }
-  for (let i = 0; i < tokens.length; i++) {
-    if (vocab.iqcPattern.test(tokens[i])) return { kind: 'iqc', tagPositions: [i] }
-  }
-  for (let i = 0; i < tokens.length; i++) {
-    if (vocab.eqcPattern.test(tokens[i])) return { kind: 'eqc', tagPositions: [i] }
-  }
-  for (let i = 0; i < tokens.length; i++) {
-    if (vocab.standardPattern.test(tokens[i]) || vocab.standardAllow.has(tokens[i])) {
-      return { kind: 'standard', tagPositions: [i] }
-    }
-  }
-  for (let i = 0; i < tokens.length; i++) {
-    if (vocab.spikeInPattern.test(tokens[i])) return { kind: 'spike-in', tagPositions: [i] }
-  }
-  for (let i = 0; i < tokens.length; i++) {
-    if (vocab.stockPattern.test(tokens[i])) return { kind: 'stock', tagPositions: [i] }
-  }
-  for (let i = 0; i < tokens.length; i++) {
-    const canonical = matrixCanonical(tokens[i], vocab)
-    if (canonical) {
-      const isTissueParent = isTissueParentToken(tokens[i], vocab)
-      const tagPositions = [i]
-      if (isTissueParent) {
-        // "Tissues"/"Tissue" is the parent group; tag the next token (organ name) as well.
-        if (i + 1 < tokens.length) tagPositions.push(i + 1)
-        return { kind: 'biological', subKind: 'Tissues', tagPositions }
-      }
-      // Non-parent matrix token: tag any immediately preceding "Tissues"/"Tissue" parent.
-      if (i > 0 && isTissueParentToken(tokens[i - 1], vocab)) {
-        tagPositions.unshift(i - 1)
-        return { kind: 'biological', subKind: 'Tissues', tagPositions }
-      }
-      return { kind: 'biological', subKind: canonical, tagPositions }
-    }
-  }
-  return { kind: 'unknown', tagPositions: [] }
-}
-
-/**
- * LC-MS batches run positive- and negative-ion-mode acquisitions separately,
- * and the two produce different feature tables that should never be grouped
- * together. When a POS / NEG / positive / negative token is present we suffix
- * it to the class label so the schema builder treats each mode as its own class.
- */
-function ionizationModeFor(
-  tokens: string[],
-  vocab: ClassVocab,
-): { mode: IonMode; position: number } | undefined {
-  for (let i = 0; i < tokens.length; i++) {
-    const mode = vocab.ionizationModes.get(tokens[i].toLowerCase())
-    if (mode) return { mode, position: i }
-  }
-  return undefined
-}
-
-function labelFor(kind: SampleClassKind, subKind?: string): string {
-  const base: Record<SampleClassKind, string> = {
-    biological: 'Biological',
-    iqc: 'IQC',
-    eqc: 'EQC',
-    standard: 'Standard',
-    'spike-in': 'SpikeIn',
-    stock: 'Stock',
-    blank: 'Blank',
-    unknown: 'Unknown',
-  }
-  return subKind ? `${base[kind]} / ${subKind}` : base[kind]
-}
-
-/** Classify each tokenized sample into a SampleClass. */
-export function detectClass(
-  tokenizedSamples: string[][],
-  options: DetectClassOptions,
-): SampleClass[] {
-  const vocab = { ...classVocab, ...(options.vocab ?? {}) }
-  const hints = options.sampleTypeHints ?? []
-  const buckets = new Map<string, SampleClass>()
-
-  for (let i = 0; i < tokenizedSamples.length; i++) {
-    const hint = hints[i]?.toLowerCase()
-    let kind: SampleClassKind
-    let subKind: string | undefined
-    let tagPositions: number[]
-
-    if (hint === 'qc') {
-      kind = 'iqc'
-      tagPositions = []
-    } else if (hint === 'blank') {
-      kind = 'blank'
-      tagPositions = []
-    } else {
-      const r = classifyTokens(tokenizedSamples[i], vocab)
-      kind = r.kind
-      subKind = r.subKind
-      tagPositions = r.tagPositions
-    }
-
-    // Split classes by ionization mode (POS / NEG) so the two acquisitions get
-    // independent schemas even when they share a matrix and sample-type vocab.
-    const mode = ionizationModeFor(tokenizedSamples[i], vocab)
-    if (mode) {
-      subKind = subKind ? `${subKind} / ${mode.mode}` : mode.mode
-      if (!tagPositions.includes(mode.position)) tagPositions.push(mode.position)
-    }
-
-    const key = classKey({ kind, subKind })
-    const bucket = buckets.get(key)
-    if (bucket) {
-      bucket.members.push(i)
-      for (const p of tagPositions) {
-        if (!bucket.classTagPositions.includes(p)) bucket.classTagPositions.push(p)
-      }
-    } else {
-      buckets.set(key, {
-        kind,
-        subKind,
-        label: labelFor(kind, subKind),
-        members: [i],
-        classTagPositions: [...tagPositions],
-        disposition: DEFAULT_DISPOSITION[kind],
-      })
-    }
-  }
-
-  return [...buckets.values()]
-}

package/src/composables/autoGroup/colors.ts

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