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

package/src/composables/useResourceCrud.ts

@@ -0,0 +1,249 @@
+import { computed, ref, shallowRef, type ComputedRef, type Ref, type ShallowRef } from 'vue'
+
+export type ResourceKey = string | number
+
+export interface ResourceCrudAdapter<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
+  list: () => Promise<TItem[]>
+  create?: (payload: TCreate) => Promise<TItem>
+  update?: (key: TKey, payload: TUpdate) => Promise<TItem>
+  remove?: (key: TKey) => Promise<void>
+}
+
+export interface UseResourceCrudOptions<
+  TItem,
+  TCreate = Partial<TItem>,
+  TUpdate = Partial<TItem>,
+  TKey extends ResourceKey = ResourceKey,
+> {
+  adapter: ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey>
+  initialItems?: readonly TItem[]
+  getKey?: (item: TItem) => TKey
+  readErrorMessage?: (error: unknown) => string
+}
+
+export interface UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey extends ResourceKey> {
+  items: Ref<TItem[]>
+  loading: ShallowRef<boolean>
+  saving: ShallowRef<boolean>
+  deleting: ShallowRef<boolean>
+  error: Ref<string | null>
+  isBusy: ComputedRef<boolean>
+  load: () => Promise<TItem[]>
+  createItem: (payload: TCreate) => Promise<TItem>
+  updateItem: (key: TKey, payload: TUpdate) => Promise<TItem>
+  deleteItem: (keyOrItem: TKey | TItem) => Promise<void>
+  setItems: (items: readonly TItem[]) => void
+  upsertLocal: (item: TItem) => void
+  removeLocal: (keyOrItem: TKey | TItem) => void
+  clearError: () => void
+}
+
+/**
+ * Common list/create/update/delete state wrapper for generated plugin clients.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useGeneratedPluginClient()` instead.
+ */
+export function useResourceCrud<
+  TItem,
+  TCreate = Partial<TItem>,
+  TUpdate = Partial<TItem>,
+  TKey extends ResourceKey = ResourceKey,
+>(
+  options: UseResourceCrudOptions<TItem, TCreate, TUpdate, TKey>,
+): UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey> {
+  const items = ref<TItem[]>([...(options.initialItems ?? [])]) as Ref<TItem[]>
+  const loading = shallowRef(false)
+  const saving = shallowRef(false)
+  const deleting = shallowRef(false)
+  const error = ref<string | null>(null)
+  const isBusy = computed(() => loading.value || saving.value || deleting.value)
+
+  const readMessage = options.readErrorMessage ?? readErrorMessage
+  const getKey = options.getKey ?? defaultGetKey<TKey, TItem>
+
+  function clearError(): void {
+    error.value = null
+  }
+
+  function setError(err: unknown): void {
+    error.value = readMessage(err)
+  }
+
+  function setItems(nextItems: readonly TItem[]): void {
+    items.value = [...nextItems]
+  }
+
+  function upsertLocal(item: TItem): void {
+    const key = getKey(item)
+    const index = items.value.findIndex(existing => getKey(existing) === key)
+    if (index === -1) {
+      items.value = [...items.value, item]
+      return
+    }
+    items.value = [
+      ...items.value.slice(0, index),
+      item,
+      ...items.value.slice(index + 1),
+    ]
+  }
+
+  function removeLocal(keyOrItem: TKey | TItem): void {
+    const key = resolveKey(keyOrItem, getKey)
+    items.value = items.value.filter(item => getKey(item) !== key)
+  }
+
+  async function load(): Promise<TItem[]> {
+    loading.value = true
+    clearError()
+    try {
+      const result = await options.adapter.list()
+      setItems(result)
+      return result
+    } catch (err) {
+      setError(err)
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function createItem(payload: TCreate): Promise<TItem> {
+    if (!options.adapter.create) {
+      throw new Error('[MINT SDK] Resource adapter does not implement create().')
+    }
+    saving.value = true
+    clearError()
+    try {
+      const result = await options.adapter.create(payload)
+      upsertLocal(result)
+      return result
+    } catch (err) {
+      setError(err)
+      throw err
+    } finally {
+      saving.value = false
+    }
+  }
+
+  async function updateItem(key: TKey, payload: TUpdate): Promise<TItem> {
+    if (!options.adapter.update) {
+      throw new Error('[MINT SDK] Resource adapter does not implement update().')
+    }
+    saving.value = true
+    clearError()
+    try {
+      const result = await options.adapter.update(key, payload)
+      upsertLocal(result)
+      return result
+    } catch (err) {
+      setError(err)
+      throw err
+    } finally {
+      saving.value = false
+    }
+  }
+
+  async function deleteItem(keyOrItem: TKey | TItem): Promise<void> {
+    if (!options.adapter.remove) {
+      throw new Error('[MINT SDK] Resource adapter does not implement remove().')
+    }
+    const key = resolveKey(keyOrItem, getKey)
+    deleting.value = true
+    clearError()
+    try {
+      await options.adapter.remove(key)
+      removeLocal(key)
+    } catch (err) {
+      setError(err)
+      throw err
+    } finally {
+      deleting.value = false
+    }
+  }
+
+  return {
+    items,
+    loading,
+    saving,
+    deleting,
+    error,
+    isBusy,
+    load,
+    createItem,
+    updateItem,
+    deleteItem,
+    setItems,
+    upsertLocal,
+    removeLocal,
+    clearError,
+  }
+}
+
+export interface PluginResourceClientOptions<
+  TClient,
+  TItem,
+  TCreate = Partial<TItem>,
+  TUpdate = Partial<TItem>,
+  TKey extends ResourceKey = ResourceKey,
+> {
+  client: TClient
+  list: (client: TClient) => Promise<TItem[]>
+  create?: (client: TClient, payload: TCreate) => Promise<TItem>
+  update?: (client: TClient, key: TKey, payload: TUpdate) => Promise<TItem>
+  remove?: (client: TClient, key: TKey) => Promise<void>
+}
+
+export function createPluginResourceClient<
+  TClient,
+  TItem,
+  TCreate = Partial<TItem>,
+  TUpdate = Partial<TItem>,
+  TKey extends ResourceKey = ResourceKey,
+>(
+  options: PluginResourceClientOptions<TClient, TItem, TCreate, TUpdate, TKey>,
+): ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey> {
+  return {
+    list: () => options.list(options.client),
+    create: options.create
+      ? payload => options.create!(options.client, payload)
+      : undefined,
+    update: options.update
+      ? (key, payload) => options.update!(options.client, key, payload)
+      : undefined,
+    remove: options.remove
+      ? key => options.remove!(options.client, key)
+      : undefined,
+  }
+}
+
+function defaultGetKey<TKey extends ResourceKey, TItem>(item: TItem): TKey {
+  if (item && typeof item === 'object' && 'id' in item) {
+    return (item as { id: ResourceKey }).id as TKey
+  }
+  throw new Error('[MINT SDK] Resource items need an id field or a getKey option.')
+}
+
+function resolveKey<TItem, TKey extends ResourceKey>(
+  keyOrItem: TKey | TItem,
+  getKey: (item: TItem) => TKey,
+): TKey {
+  if (typeof keyOrItem === 'string' || typeof keyOrItem === 'number') {
+    return keyOrItem as TKey
+  }
+  return getKey(keyOrItem as TItem)
+}
+
+function readErrorMessage(value: unknown): string {
+  if (value instanceof Error && value.message) return value.message
+  if (typeof value === 'string' && value.trim()) return value
+  if (
+    typeof value === 'object'
+    && value !== null
+    && 'message' in value
+    && typeof (value as { message?: unknown }).message === 'string'
+    && (value as { message: string }).message.trim()
+  ) {
+    return (value as { message: string }).message
+  }
+  return 'Request failed.'
+}

package/src/composables/useRovingFocus.ts

@@ -0,0 +1,66 @@
+import { nextTick } from 'vue'
+
+export interface UseRovingFocusOptions {
+  /** Selectable item ids, in DOM order. Already excludes items skipped entirely (e.g. disabled tabs). */
+  ids: () => string[]
+  /** The id that is currently active/selected. */
+  activeId: () => string | undefined
+  /** Activates an id (e.g. emit `update:modelValue`). The composable focuses the matching element afterward. */
+  activate: (id: string) => void
+  /** Returns the focusable element for an id, queried lazily so it reflects the post-activation DOM. */
+  getElement: (id: string) => HTMLElement | null | undefined
+  /** Arrow-key axis: `'horizontal'` (Left/Right, default) or `'vertical'` (Up/Down). */
+  orientation?: 'horizontal' | 'vertical'
+}
+
+export interface UseRovingFocusReturn {
+  /** Bind to each item's `@keydown`. */
+  handleKeydown: (event: KeyboardEvent) => void
+}
+
+/**
+ * WAI-ARIA roving-tabindex navigation with automatic activation (the tabs pattern):
+ * Left/Right (or Up/Down when `orientation` is `'vertical'`) move to the adjacent item
+ * and activate it immediately, wrapping past the ends; Home/End jump to the first/last
+ * item. Only the active item should carry `tabindex="0"`; give every other item
+ * `tabindex="-1"`. Used by BaseTabs.
+ */
+export function useRovingFocus(options: UseRovingFocusOptions): UseRovingFocusReturn {
+  const orientation = options.orientation ?? 'horizontal'
+  const prevKey = orientation === 'vertical' ? 'ArrowUp' : 'ArrowLeft'
+  const nextKey = orientation === 'vertical' ? 'ArrowDown' : 'ArrowRight'
+
+  function moveTo(id: string | undefined) {
+    if (id === undefined) return
+    options.activate(id)
+    void nextTick(() => options.getElement(id)?.focus())
+  }
+
+  function handleKeydown(event: KeyboardEvent) {
+    const ids = options.ids()
+    if (ids.length === 0) return
+    const currentIndex = ids.indexOf(options.activeId() ?? '')
+
+    if (event.key === 'Home') {
+      event.preventDefault()
+      moveTo(ids[0])
+      return
+    }
+    if (event.key === 'End') {
+      event.preventDefault()
+      moveTo(ids[ids.length - 1])
+      return
+    }
+    if (event.key === prevKey) {
+      event.preventDefault()
+      moveTo(ids[currentIndex <= 0 ? ids.length - 1 : currentIndex - 1])
+      return
+    }
+    if (event.key === nextKey) {
+      event.preventDefault()
+      moveTo(ids[currentIndex === -1 || currentIndex >= ids.length - 1 ? 0 : currentIndex + 1])
+    }
+  }
+
+  return { handleKeydown }
+}

package/src/composables/useRuntimeAlignment.ts

@@ -0,0 +1,184 @@
+import {
+  computed,
+  onMounted,
+  onScopeDispose,
+  readonly,
+  ref,
+  toValue,
+  type MaybeRefOrGetter,
+  type Ref,
+} from 'vue'
+
+const RUNTIME_RELOAD_KEY_PREFIX = 'mint:runtime-reload:'
+const REVISION_QUERY_KEY = '__mint_revision'
+const inMemoryReloadGuards = new Set<string>()
+
+interface RuntimeStorage {
+  getItem(key: string): string | null
+  setItem(key: string, value: string): void
+}
+
+interface RuntimeEventTarget {
+  addEventListener(type: 'vite:preloadError', listener: EventListener): void
+  removeEventListener(type: 'vite:preloadError', listener: EventListener): void
+}
+
+interface RuntimeVisibilityTarget {
+  addEventListener(type: 'visibilitychange', listener: EventListener): void
+  removeEventListener(type: 'visibilitychange', listener: EventListener): void
+}
+
+export interface RuntimeRevisionResponse {
+  frontend_revision?: string | null
+}
+
+export interface RuntimeAlignmentOptions {
+  /** Revision embedded in the HTML that booted this tab. */
+  currentRevision?: MaybeRefOrGetter<string | null | undefined>
+  /** Browser visibility seam. */
+  visibility?: () => DocumentVisibilityState
+  /** Current location seam. */
+  currentUrl?: () => string
+  /** Location replacement seam. */
+  replace?: (url: string) => void
+  /** Per-tab recovery guard storage. */
+  storage?: RuntimeStorage | null
+  /** Vite preload error source. */
+  eventTarget?: RuntimeEventTarget | null
+  /** Browser visibility event source. */
+  visibilityTarget?: RuntimeVisibilityTarget | null
+}
+
+export interface UseRuntimeAlignmentReturn {
+  updateAvailable: Readonly<Ref<boolean>>
+  nextRevision: Readonly<Ref<string | null>>
+  observe: (response: RuntimeRevisionResponse | unknown) => void
+  reload: () => void
+  recoverMissingChunk: () => void
+}
+
+function browserStorage(): RuntimeStorage | null {
+  try {
+    return globalThis.sessionStorage ?? null
+  } catch {
+    return null
+  }
+}
+
+function browserEventTarget(): RuntimeEventTarget | null {
+  return typeof globalThis.window === 'undefined' ? null : globalThis.window
+}
+
+function browserVisibilityTarget(): RuntimeVisibilityTarget | null {
+  return typeof globalThis.document === 'undefined' ? null : globalThis.document
+}
+
+function responseRevision(response: RuntimeRevisionResponse | unknown): string | null {
+  if (!response || typeof response !== 'object') return null
+  const value = (response as RuntimeRevisionResponse).frontend_revision
+  return typeof value === 'string' && value ? value : null
+}
+
+/** Keep a loaded MINT frontend aligned with the backend revision serving its scope. */
+export function useRuntimeAlignment(
+  options: RuntimeAlignmentOptions = {},
+): UseRuntimeAlignmentReturn {
+  const storage = options.storage === undefined ? browserStorage() : options.storage
+  const eventTarget = options.eventTarget === undefined ? browserEventTarget() : options.eventTarget
+  const visibilityTarget = options.visibilityTarget === undefined
+    ? browserVisibilityTarget()
+    : options.visibilityTarget
+  const visibility = options.visibility ?? (() => globalThis.document?.visibilityState ?? 'visible')
+  const currentUrl = options.currentUrl ?? (() => globalThis.location?.href ?? '/')
+  const replace = options.replace ?? ((url: string) => globalThis.location?.replace(url))
+  const initialRevision = computed(() => toValue(options.currentRevision) ?? null)
+  const baselineRevision = ref<string | null>(initialRevision.value)
+  const nextRevision = ref<string | null>(null)
+  const updateAvailable = computed(() => nextRevision.value !== null)
+  let wasHidden = false
+
+  function reloadTo(revision: string, guardKind: 'revision' | 'chunk'): void {
+    const guardKey = `${RUNTIME_RELOAD_KEY_PREFIX}${guardKind}:${revision}`
+    const url = new URL(currentUrl(), globalThis.location?.origin ?? 'http://localhost')
+    if (url.searchParams.get(REVISION_QUERY_KEY) === revision) return
+    if (inMemoryReloadGuards.has(guardKey)) return
+    try {
+      if (storage?.getItem(guardKey)) {
+        inMemoryReloadGuards.add(guardKey)
+        return
+      }
+      storage?.setItem(guardKey, '1')
+    } catch {
+      // A blocked sessionStorage must not block recovery.
+    }
+    inMemoryReloadGuards.add(guardKey)
+    url.searchParams.set(REVISION_QUERY_KEY, revision)
+    replace(url.toString())
+  }
+
+  function observe(response: RuntimeRevisionResponse | unknown): void {
+    const revision = responseRevision(response)
+    if (!revision) return
+    const current = initialRevision.value ?? baselineRevision.value
+    if (!current) {
+      baselineRevision.value = revision
+      return
+    }
+    if (revision === current) {
+      wasHidden = false
+      return
+    }
+    if (wasHidden || visibility() === 'hidden') {
+      wasHidden = false
+      reloadTo(revision, 'revision')
+      return
+    }
+    nextRevision.value = revision
+  }
+
+  function reload(): void {
+    if (nextRevision.value) reloadTo(nextRevision.value, 'revision')
+  }
+
+  function recoverMissingChunk(): void {
+    reloadTo(baselineRevision.value ?? initialRevision.value ?? 'unknown', 'chunk')
+  }
+
+  function handlePreloadError(event: Event): void {
+    event.preventDefault()
+    recoverMissingChunk()
+  }
+
+  function handleVisibilityChange(): void {
+    if (visibility() === 'hidden') wasHidden = true
+  }
+
+  onMounted(() => {
+    eventTarget?.addEventListener('vite:preloadError', handlePreloadError)
+    visibilityTarget?.addEventListener('visibilitychange', handleVisibilityChange)
+  })
+  onScopeDispose(() => {
+    eventTarget?.removeEventListener('vite:preloadError', handlePreloadError)
+    visibilityTarget?.removeEventListener('visibilitychange', handleVisibilityChange)
+  })
+
+  return {
+    updateAvailable: readonly(updateAvailable),
+    nextRevision: readonly(nextRevision),
+    observe,
+    reload,
+    recoverMissingChunk,
+  }
+}
+
+/** Read the revision injected into the HTML that started this browser tab. */
+export function getInjectedFrontendRevision(): string | null {
+  if (typeof globalThis.window === 'undefined') return null
+  const runtimeWindow = globalThis.window as typeof globalThis.window & {
+    __MINT_FRONTEND_REVISION__?: string
+    __MINT_PLATFORM__?: { plugin?: { frontend_revision?: string } }
+  }
+  return runtimeWindow.__MINT_PLATFORM__?.plugin?.frontend_revision
+    ?? runtimeWindow.__MINT_FRONTEND_REVISION__
+    ?? null
+}

package/src/composables/useSampleGroups.ts

@@ -0,0 +1,211 @@
+import { computed, toValue, type ComputedRef, type Ref } from 'vue'
+import type { SampleGroup } from '../types'
+import { deriveShade } from '../utils/color'
+import { splitSampleGroupPath } from '../utils/sampleGroupPath'
+
+export type SampleGroupSource<T> =
+  | T
+  | Ref<T>
+  | ComputedRef<T>
+  | (() => T)
+
+export interface DisplaySampleSubGroup extends SampleGroup {
+  displayColor: string
+  displayBg: string
+  displayBorder: string
+}
+
+export interface SampleMajorGroup {
+  name: string
+  color: string
+  subGroups: DisplaySampleSubGroup[]
+  allSamples: string[]
+}
+
+/**
+ * One node of the sample-group display hierarchy. Interior nodes are path
+ * prefixes of the group names (`Liver`, `Liver / High`); leaves carry the
+ * concrete group. A group's `name` stays the full path on its leaf because
+ * every mutation — drag, delete, colour, selection — resolves groups by name.
+ */
+export interface SampleGroupNode {
+  /** Unique across the tree; use for `:key` and expansion state. */
+  key: string
+  /** This node's own path segment, not the full path. */
+  label: string
+  color: string
+  displayBg: string
+  displayBorder: string
+  /** Every sample beneath this node, in group order. */
+  allSamples: string[]
+  /** Empty for leaves. */
+  children: SampleGroupNode[]
+  /** Present only on leaves. */
+  group?: DisplaySampleSubGroup
+}
+
+export interface UseSampleGroupsOptions {
+  groups: SampleGroupSource<readonly SampleGroup[]>
+  samples?: SampleGroupSource<readonly string[]>
+  separator?: SampleGroupSource<string | null | undefined>
+  fallbackColor?: SampleGroupSource<string | null | undefined>
+}
+
+export interface UseSampleGroupsReturn {
+  groups: ComputedRef<SampleGroup[]>
+  separator: ComputedRef<string>
+  /** Full N-layer display hierarchy; one level per group-name segment. */
+  groupTree: ComputedRef<SampleGroupNode[]>
+  /** Deepest layer count across the tree (1 when groups are flat). */
+  maxDepth: ComputedRef<number>
+  hierarchicalGroups: ComputedRef<SampleMajorGroup[]>
+  showHierarchy: ComputedRef<boolean>
+  groupedSamples: ComputedRef<Set<string>>
+  ungroupedSamples: ComputedRef<string[]>
+  findGroup: (groupName: string) => SampleGroup | undefined
+  getGroupColor: (groupName: string) => string
+}
+
+/** Shared sample-group hierarchy, color, and ungrouped-sample derivation for lab selectors. */
+export function useSampleGroups(options: UseSampleGroupsOptions): UseSampleGroupsReturn {
+  const groups = computed(() => [...toValue(options.groups)])
+  const samples = computed(() => [...(toValue(options.samples) ?? [])])
+  const fallbackColor = computed(() => toValue(options.fallbackColor) || '#3B82F6')
+  const separator = computed(() => {
+    const explicit = toValue(options.separator)
+    if (explicit) return explicit
+    return groups.value.some(group => group.name.includes('/')) ? '/' : '_'
+  })
+
+  // Groups are bucketed by their first segment (the major/family), then each
+  // family is expanded into a full prefix tree. Shades are assigned per family
+  // across its leaves so a family keeps one hue with a light→dark gradient,
+  // exactly as the two-level model did.
+  const families = computed(() => {
+    const byMajor = new Map<string, SampleGroup[]>()
+    for (const group of groups.value) {
+      const majorName = getMajorGroupName(group.name, separator.value)
+      const existing = byMajor.get(majorName)
+      if (existing) existing.push(group)
+      else byMajor.set(majorName, [group])
+    }
+    return [...byMajor.entries()].map(([name, members]) => {
+      const color = members[0]?.color || fallbackColor.value
+      return {
+        name,
+        color,
+        subGroups: members.map((group, index) => {
+          const displayColor = deriveShade(color, index, members.length)
+          return {
+            ...group,
+            displayColor,
+            displayBg: displayColor + '20',
+            displayBorder: displayColor + '40',
+          }
+        }),
+      }
+    })
+  })
+
+  const groupTree = computed<SampleGroupNode[]>(() => {
+    const roots: SampleGroupNode[] = []
+
+    for (const family of families.value) {
+      // Interior nodes are shared by path so siblings collapse into one parent;
+      // leaves are keyed separately so a group whose full path equals an
+      // interior path (e.g. "Liver" alongside "Liver / High") stays reachable
+      // instead of being swallowed by the prefix node.
+      const interior = new Map<string, SampleGroupNode>()
+
+      for (const subGroup of family.subGroups) {
+        const segments = splitSampleGroupPath(subGroup.name, separator.value)
+        const leafLabel = segments[segments.length - 1] ?? subGroup.name
+        let siblings = roots
+        let path = ''
+
+        for (const segment of segments.slice(0, -1)) {
+          path = path ? `${path}/${segment}` : segment
+          let node = interior.get(path)
+          if (!node) {
+            node = {
+              key: `node:${family.name}/${path}`,
+              label: segment,
+              color: family.color,
+              displayBg: family.color + '20',
+              displayBorder: family.color + '40',
+              allSamples: [],
+              children: [],
+            }
+            interior.set(path, node)
+            siblings.push(node)
+          }
+          node.allSamples.push(...subGroup.samples)
+          siblings = node.children
+        }
+
+        siblings.push({
+          key: `leaf:${subGroup.name}`,
+          label: leafLabel,
+          color: subGroup.displayColor,
+          displayBg: subGroup.displayBg,
+          displayBorder: subGroup.displayBorder,
+          allSamples: [...subGroup.samples],
+          children: [],
+          group: subGroup,
+        })
+      }
+    }
+
+    return roots
+  })
+
+  const maxDepth = computed(() => {
+    const depthOf = (nodes: SampleGroupNode[]): number =>
+      nodes.reduce((deepest, node) => Math.max(deepest, 1 + depthOf(node.children)), 0)
+    return depthOf(groupTree.value)
+  })
+
+  const hierarchicalGroups = computed<SampleMajorGroup[]>(() =>
+    families.value.map(family => ({
+      name: family.name,
+      color: family.color,
+      subGroups: family.subGroups,
+      allSamples: family.subGroups.flatMap(group => group.samples),
+    })),
+  )
+
+  const showHierarchy = computed(() => maxDepth.value > 1)
+
+  const groupedSamples = computed(() =>
+    new Set(groups.value.flatMap(group => group.samples))
+  )
+
+  const ungroupedSamples = computed(() =>
+    samples.value.filter(sample => !groupedSamples.value.has(sample))
+  )
+
+  function findGroup(groupName: string): SampleGroup | undefined {
+    return groups.value.find(group => group.name === groupName)
+  }
+
+  function getGroupColor(groupName: string): string {
+    return findGroup(groupName)?.color || fallbackColor.value
+  }
+
+  return {
+    groups,
+    separator,
+    groupTree,
+    maxDepth,
+    hierarchicalGroups,
+    showHierarchy,
+    groupedSamples,
+    ungroupedSamples,
+    findGroup,
+    getGroupColor,
+  }
+}
+
+function getMajorGroupName(groupName: string, separator: string): string {
+  return splitSampleGroupPath(groupName, separator)[0]
+}