@morscherlab/mint-sdk 1.0.0-beta.2 → 1.0.0-beta.4

package/src/composables/useSampleGroups.ts

@@ -0,0 +1,126 @@
+import { computed, toValue, type ComputedRef, type Ref } from 'vue'
+import type { SampleGroup } from '../types'
+import { deriveShade } from '../utils/color'
+
+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[]
+}
+
+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>
+  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('/')) ? '/' : '_'
+  })
+
+  const hierarchicalGroups = computed<SampleMajorGroup[]>(() => {
+    if (groups.value.length === 0) return []
+    const groupedByMajor = new Map<string, SampleGroup[]>()
+
+    for (const group of groups.value) {
+      const majorName = getMajorGroupName(group.name, separator.value)
+      const existing = groupedByMajor.get(majorName)
+      if (existing) {
+        existing.push(group)
+      } else {
+        groupedByMajor.set(majorName, [group])
+      }
+    }
+
+    return [...groupedByMajor.entries()].map(([majorName, subGroups]) => {
+      const color = subGroups[0]?.color || fallbackColor.value
+      const displaySubs = subGroups.map((subGroup, index) => {
+        const displayColor = deriveShade(color, index, subGroups.length)
+        return {
+          ...subGroup,
+          displayColor,
+          displayBg: displayColor + '20',
+          displayBorder: displayColor + '40',
+        }
+      })
+
+      return {
+        name: majorName,
+        color,
+        subGroups: displaySubs,
+        allSamples: subGroups.flatMap(group => group.samples),
+      }
+    })
+  })
+
+  const showHierarchy = computed(() =>
+    hierarchicalGroups.value.some(major =>
+      major.subGroups.length > 1 ||
+      (major.subGroups.length === 1 && major.name !== major.subGroups[0].name)
+    )
+  )
+
+  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,
+    hierarchicalGroups,
+    showHierarchy,
+    groupedSamples,
+    ungroupedSamples,
+    findGroup,
+    getGroupColor,
+  }
+}
+
+function getMajorGroupName(groupName: string, separator: string): string {
+  const parts = groupName.split(separator)
+  return parts.length > 1 ? parts[0] : groupName
+}

package/src/composables/useSelectionLimit.ts

@@ -0,0 +1,57 @@
+import { computed, toValue, type ComputedRef, type Ref } from 'vue'
+
+export type SelectionLimitSource<T> =
+  | T
+  | Ref<T>
+  | ComputedRef<T>
+  | (() => T)
+
+export interface UseSelectionLimitOptions {
+  count: SelectionLimitSource<number>
+  max?: SelectionLimitSource<number | null | undefined>
+}
+
+export interface UseSelectionLimitReturn {
+  count: ComputedRef<number>
+  max: ComputedRef<number | undefined>
+  isLimited: ComputedRef<boolean>
+  isAtLimit: ComputedRef<boolean>
+  canAddMore: ComputedRef<boolean>
+  remaining: ComputedRef<number | undefined>
+  canAdd: (amount?: number, fromCount?: number) => boolean
+}
+
+/** Shared cap logic for chip, tag, and multi-select controls. */
+export function useSelectionLimit(options: UseSelectionLimitOptions): UseSelectionLimitReturn {
+  const count = computed(() => Math.max(0, Math.floor(toValue(options.count) || 0)))
+  const max = computed(() => normalizeMax(toValue(options.max)))
+  const isLimited = computed(() => max.value !== undefined)
+  const remaining = computed(() => {
+    if (max.value === undefined) return undefined
+    return Math.max(0, max.value - count.value)
+  })
+  const isAtLimit = computed(() => remaining.value === 0)
+  const canAddMore = computed(() => canAdd(1))
+
+  function canAdd(amount = 1, fromCount = count.value): boolean {
+    const normalizedAmount = Math.max(0, Math.floor(amount))
+    const normalizedCount = Math.max(0, Math.floor(fromCount))
+    if (max.value === undefined) return true
+    return normalizedCount + normalizedAmount <= max.value
+  }
+
+  return {
+    count,
+    max,
+    isLimited,
+    isAtLimit,
+    canAddMore,
+    remaining,
+    canAdd,
+  }
+}
+
+function normalizeMax(value: number | null | undefined): number | undefined {
+  if (value === null || value === undefined || !Number.isFinite(value)) return undefined
+  return Math.max(0, Math.floor(value))
+}

package/src/composables/useSortedItems.ts

@@ -0,0 +1,118 @@
+import { computed, toValue, type ComputedRef, type Ref } from 'vue'
+
+export type SortedItemsSource<T> =
+  | T
+  | Ref<T>
+  | ComputedRef<T>
+  | (() => T)
+
+export type SortOrder = 'asc' | 'desc'
+
+export interface SortDescriptor<TKey extends string = string> {
+  key: TKey
+  direction?: SortOrder | null
+}
+
+export interface CompareSortValuesOptions {
+  caseSensitive?: boolean
+}
+
+export interface SortComparatorContext<TItem, TKey extends string = string> {
+  key: TKey
+  direction: SortOrder
+  a: TItem
+  b: TItem
+}
+
+export type SortComparator<TItem, TKey extends string = string> = (
+  aValue: unknown,
+  bValue: unknown,
+  context: SortComparatorContext<TItem, TKey>,
+) => number
+
+export interface UseSortedItemsOptions<TItem, TKey extends string = string> {
+  items: SortedItemsSource<readonly TItem[]>
+  sort: SortedItemsSource<SortDescriptor<TKey> | null | undefined>
+  enabled?: SortedItemsSource<boolean | null | undefined>
+  caseSensitive?: SortedItemsSource<boolean | null | undefined>
+  getValue: (item: TItem, key: TKey) => unknown
+  compare?: SortComparator<TItem, TKey>
+}
+
+export interface UseSortedItemsReturn<TItem, TKey extends string = string> {
+  sort: ComputedRef<SortDescriptor<TKey> | null | undefined>
+  sortedItems: ComputedRef<TItem[]>
+}
+
+/** Shared sorting for SDK tables and lists with stable empty-value handling. */
+export function useSortedItems<TItem, TKey extends string = string>(
+  options: UseSortedItemsOptions<TItem, TKey>,
+): UseSortedItemsReturn<TItem, TKey> {
+  const sort = computed(() => toValue(options.sort))
+  const enabled = computed(() => toValue(options.enabled) ?? true)
+
+  const sortedItems = computed(() => {
+    const items = [...toValue(options.items)]
+    const activeSort = sort.value
+
+    if (!enabled.value || !activeSort?.key || !activeSort.direction) return items
+
+    const direction = activeSort.direction
+    const caseSensitive = toValue(options.caseSensitive) ?? true
+
+    return items.sort((a, b) => {
+      const aValue = options.getValue(a, activeSort.key)
+      const bValue = options.getValue(b, activeSort.key)
+
+      if (options.compare) {
+        return options.compare(aValue, bValue, {
+          key: activeSort.key,
+          direction,
+          a,
+          b,
+        })
+      }
+
+      return compareSortValues(aValue, bValue, direction, { caseSensitive })
+    })
+  })
+
+  return {
+    sort,
+    sortedItems,
+  }
+}
+
+export function compareSortValues(
+  aValue: unknown,
+  bValue: unknown,
+  direction: SortOrder = 'asc',
+  options: CompareSortValuesOptions = {},
+): number {
+  const aEmpty = aValue === null || aValue === undefined
+  const bEmpty = bValue === null || bValue === undefined
+
+  if (aEmpty && bEmpty) return 0
+  if (aEmpty) return 1
+  if (bEmpty) return -1
+
+  const aComparable = toComparableSortValue(aValue, options)
+  const bComparable = toComparableSortValue(bValue, options)
+
+  let comparison = 0
+  if (typeof aComparable === 'number' && typeof bComparable === 'number') {
+    comparison = aComparable - bComparable
+  } else {
+    comparison = String(aComparable).localeCompare(String(bComparable))
+  }
+
+  return direction === 'asc' ? comparison : -comparison
+}
+
+function toComparableSortValue(value: unknown, options: CompareSortValuesOptions): unknown {
+  if (value instanceof Date) return value.getTime()
+  if (typeof value === 'string' && options.caseSensitive === false) {
+    return value.toLowerCase()
+  }
+  return value
+}

package/src/composables/useTemplateCollection.ts

@@ -0,0 +1,229 @@
+import { computed, ref, type ComputedRef, type Ref } from 'vue'
+import { useExperimentSave, type UseExperimentSaveOptions } from './useExperimentSave'
+import {
+  createTemplateCollection,
+  ensureTemplateFromCollection,
+  extractTemplateCollection,
+  type BioTemplateEnvelope,
+  type TemplateCollection,
+  type TemplateCollectionEnvelope,
+} from '../templates'
+
+export type TemplateCollectionInput =
+  | TemplateCollectionEnvelope
+  | BioTemplateEnvelope<unknown>
+  | Array<BioTemplateEnvelope<unknown>>
+
+export interface UseTemplateCollectionOptions extends UseExperimentSaveOptions {
+  /** Initial template collection or factory; defaults to an empty collection. */
+  initial?: TemplateCollectionInput | (() => TemplateCollectionInput)
+}
+
+export interface UseTemplateCollectionReturn {
+  /** Current experiment id from platform injection, URL query, or URL path. */
+  currentExperimentId: ComputedRef<number | undefined>
+  /** Whether a current experiment id is available. */
+  hasCurrentExperiment: ComputedRef<boolean>
+  /** Full template collection envelope ready to save into design_data. */
+  templateCollection: Ref<TemplateCollectionEnvelope>
+  /** Template map keyed by template_id. */
+  templates: ComputedRef<TemplateCollection>
+  /** Collection-level metadata, or an empty object. */
+  metadata: ComputedRef<Record<string, unknown>>
+  /** Template ids currently present in the collection. */
+  templateIds: ComputedRef<string[]>
+  /** Whether the collection contains at least one template. */
+  hasTemplates: ComputedRef<boolean>
+  /** Whether a load or delete operation is in progress. */
+  isLoading: Ref<boolean>
+  /** Whether a save operation is in progress. */
+  isSaving: Ref<boolean>
+  /** Error message from the last failed operation, or null. */
+  error: Ref<string | null>
+  /** Timestamp of the last successful load, or null. */
+  lastLoadedAt: Ref<Date | null>
+  /** Timestamp of the last successful save, or null. */
+  lastSavedAt: Ref<Date | null>
+  /** Replace local state from a template envelope, collection envelope, or raw design_data. */
+  apply: (value: unknown, metadata?: Record<string, unknown>) => TemplateCollectionEnvelope
+  /** Reset local state to the configured initial collection. */
+  reset: () => TemplateCollectionEnvelope
+  /** Add or replace one template in the local collection. */
+  setTemplate: (template: BioTemplateEnvelope<unknown>) => TemplateCollectionEnvelope
+  /** Remove one template from the local collection. */
+  removeTemplate: (templateId: string) => boolean
+  /** Read one template from the local collection, returning null when missing. */
+  getTemplate: <TTemplate extends BioTemplateEnvelope<unknown> = BioTemplateEnvelope<unknown>>(
+    templateId: string,
+  ) => TTemplate | null
+  /** Read one template from the local collection, throwing when missing or mismatched. */
+  requireTemplate: <TTemplate extends BioTemplateEnvelope<unknown> = BioTemplateEnvelope<unknown>>(
+    templateId: string,
+  ) => TTemplate
+  /** Load template design_data for an experiment and apply it locally. */
+  load: (experimentId: number) => Promise<TemplateCollectionEnvelope | null>
+  /** Load template design_data for the current experiment and apply it locally. */
+  loadCurrent: () => Promise<TemplateCollectionEnvelope | null>
+  /** Save the local template collection as experiment design_data. */
+  save: (experimentId: number) => Promise<boolean>
+  /** Save the local template collection as current experiment design_data. */
+  saveCurrent: () => Promise<boolean>
+  /** Require and return the current experiment id, or throw when missing. */
+  requireCurrentExperimentId: () => number
+}
+
+/** Manages a biology template collection in the current experiment's design_data. */
+export function useTemplateCollection(
+  options: UseTemplateCollectionOptions = {},
+): UseTemplateCollectionReturn {
+  const experimentSave = useExperimentSave(options)
+  const templateCollection = ref<TemplateCollectionEnvelope>(createInitialCollection(options))
+  const templates = computed(() => extractTemplateCollection(templateCollection.value))
+  const metadata = computed(() => templateCollection.value.metadata ?? {})
+  const templateIds = computed(() => Object.keys(templates.value))
+  const hasTemplates = computed(() => templateIds.value.length > 0)
+
+  function apply(value: unknown, metadata?: Record<string, unknown>): TemplateCollectionEnvelope {
+    templateCollection.value = normalizeTemplateCollection(value, metadata)
+    return templateCollection.value
+  }
+
+  function reset(): TemplateCollectionEnvelope {
+    templateCollection.value = createInitialCollection(options)
+    return templateCollection.value
+  }
+
+  function setTemplate(template: BioTemplateEnvelope<unknown>): TemplateCollectionEnvelope {
+    const nextTemplates = {
+      ...templates.value,
+      [template.template_id]: template,
+    }
+    templateCollection.value = createTemplateCollectionEnvelope(
+      Object.values(nextTemplates),
+      templateCollection.value.metadata,
+    )
+    return templateCollection.value
+  }
+
+  function removeTemplate(templateId: string): boolean {
+    if (!templates.value[templateId]) return false
+    const nextTemplates = { ...templates.value }
+    delete nextTemplates[templateId]
+    templateCollection.value = createTemplateCollectionEnvelope(
+      Object.values(nextTemplates),
+      templateCollection.value.metadata,
+    )
+    return true
+  }
+
+  function getTemplate<
+    TTemplate extends BioTemplateEnvelope<unknown> = BioTemplateEnvelope<unknown>,
+  >(templateId: string): TTemplate | null {
+    return (templates.value[templateId] as TTemplate | undefined) ?? null
+  }
+
+  function requireTemplate<
+    TTemplate extends BioTemplateEnvelope<unknown> = BioTemplateEnvelope<unknown>,
+  >(templateId: string): TTemplate {
+    return ensureTemplateFromCollection<TTemplate>(templateCollection.value, templateId)
+  }
+
+  async function load(experimentId: number): Promise<TemplateCollectionEnvelope | null> {
+    const data = await experimentSave.loadDesign(experimentId)
+    return data === null ? null : apply(data)
+  }
+
+  async function loadCurrent(): Promise<TemplateCollectionEnvelope | null> {
+    const data = await experimentSave.loadCurrentDesign()
+    return data === null ? null : apply(data)
+  }
+
+  async function save(experimentId: number): Promise<boolean> {
+    return experimentSave.saveDesign(
+      experimentId,
+      templateCollection.value as unknown as Record<string, unknown>,
+    )
+  }
+
+  async function saveCurrent(): Promise<boolean> {
+    return experimentSave.saveCurrentDesign(
+      templateCollection.value as unknown as Record<string, unknown>,
+    )
+  }
+
+  return {
+    currentExperimentId: experimentSave.currentExperimentId,
+    hasCurrentExperiment: experimentSave.hasCurrentExperiment,
+    templateCollection,
+    templates,
+    metadata,
+    templateIds,
+    hasTemplates,
+    isLoading: experimentSave.isLoading,
+    isSaving: experimentSave.isSaving,
+    error: experimentSave.error,
+    lastLoadedAt: experimentSave.lastLoadedAt,
+    lastSavedAt: experimentSave.lastSavedAt,
+    apply,
+    reset,
+    setTemplate,
+    removeTemplate,
+    getTemplate,
+    requireTemplate,
+    load,
+    loadCurrent,
+    save,
+    saveCurrent,
+    requireCurrentExperimentId: experimentSave.requireCurrentExperimentId,
+  }
+}
+
+function createInitialCollection(options: UseTemplateCollectionOptions): TemplateCollectionEnvelope {
+  const initial = typeof options.initial === 'function' ? options.initial() : options.initial
+  if (initial === undefined) return { templates: {} }
+  return normalizeTemplateCollection(initial)
+}
+
+function normalizeTemplateCollection(
+  value: unknown,
+  metadata?: Record<string, unknown>,
+): TemplateCollectionEnvelope {
+  if (Array.isArray(value)) {
+    return createTemplateCollectionEnvelope(value, metadata)
+  }
+
+  return createTemplateCollectionEnvelope(
+    Object.values(extractTemplateCollection(value)),
+    readCollectionMetadata(value) ?? metadata,
+  )
+}
+
+function createTemplateCollectionEnvelope(
+  templates: Array<BioTemplateEnvelope<unknown>>,
+  metadata?: Record<string, unknown>,
+): TemplateCollectionEnvelope {
+  return metadata === undefined
+    ? createTemplateCollection(templates)
+    : createTemplateCollection(templates, metadata)
+}
+
+function readCollectionMetadata(value: unknown): Record<string, unknown> | undefined {
+  if (
+    typeof value !== 'object'
+    || value === null
+    || Array.isArray(value)
+    || !('metadata' in value)
+  ) {
+    return undefined
+  }
+
+  const metadata = (value as { metadata?: unknown }).metadata
+  if (
+    typeof metadata === 'object'
+    && metadata !== null
+    && !Array.isArray(metadata)
+  ) {
+    return metadata as Record<string, unknown>
+  }
+  return undefined
+}

package/src/composables/useTextSearch.ts

@@ -0,0 +1,60 @@
+import { computed, toValue, type ComputedRef, type Ref } from 'vue'
+
+export type TextSearchSource<T> =
+  | T
+  | Ref<T>
+  | ComputedRef<T>
+  | (() => T)
+
+export type TextSearchCandidate = unknown | readonly unknown[]
+
+export interface UseTextSearchOptions<TItem> {
+  items: TextSearchSource<readonly TItem[]>
+  query: TextSearchSource<string | null | undefined>
+  enabled?: TextSearchSource<boolean | null | undefined>
+  getText: (item: TItem) => TextSearchCandidate
+}
+
+export interface UseTextSearchReturn<TItem> {
+  query: ComputedRef<string>
+  filteredItems: ComputedRef<TItem[]>
+  matches: (item: TItem, query?: string | null | undefined) => boolean
+}
+
+/** Shared text-search filtering for tables, lists, selectors, and chip inputs. */
+export function useTextSearch<TItem>(options: UseTextSearchOptions<TItem>): UseTextSearchReturn<TItem> {
+  const query = computed(() => normalizeSearchQuery(toValue(options.query)))
+  const enabled = computed(() => toValue(options.enabled) ?? true)
+
+  function matches(item: TItem, overrideQuery?: string | null | undefined): boolean {
+    const activeQuery = overrideQuery === undefined ? query.value : normalizeSearchQuery(overrideQuery)
+    if (!activeQuery) return true
+    return candidateMatchesSearch(options.getText(item), activeQuery)
+  }
+
+  const filteredItems = computed(() => {
+    const items = [...toValue(options.items)]
+    if (!enabled.value || !query.value) return items
+    return items.filter(item => matches(item))
+  })
+
+  return {
+    query,
+    filteredItems,
+    matches,
+  }
+}
+
+export function normalizeSearchQuery(value: string | null | undefined): string {
+  return (value ?? '').trim().toLowerCase()
+}
+
+export function candidateMatchesSearch(candidate: TextSearchCandidate, query: string): boolean {
+  const normalizedQuery = normalizeSearchQuery(query)
+  if (!normalizedQuery) return true
+  const values = Array.isArray(candidate) ? candidate : [candidate]
+  return values.some((value) => {
+    if (value === null || value === undefined) return false
+    return String(value).toLowerCase().includes(normalizedQuery)
+  })
+}

package/src/composables/useTheme.ts

@@ -1,4 +1,4 @@
-import { computed, onUnmounted, getCurrentInstance, type Ref } from 'vue'
+import { computed, type Ref } from 'vue'
 import { useSettingsStore } from '../stores/settings'
 
 export interface UseThemeReturn {
@@ -14,33 +14,7 @@ export function useTheme(): UseThemeReturn {
   // Load persisted theme from localStorage (idempotent — safe to call multiple times)
   settings.initialize()
 
-  const mql = typeof window !== 'undefined'
-    ? window.matchMedia('(prefers-color-scheme: dark)')
-    : null
-
-  const isDark = computed(() => {
-    if (settings.theme === 'system') {
-      return mql?.matches ?? false
-    }
-    return settings.theme === 'dark'
-  })
-
-  // React to system preference changes when in 'system' mode
-  function onSystemChange() {
-    if (settings.theme === 'system') {
-      // Force reactivity by toggling theme to itself — the computed re-evaluates
-      // because mql.matches changed, but Vue needs a trigger. We nudge the store.
-      settings.theme = 'system'
-    }
-  }
-
-  mql?.addEventListener('change', onSystemChange)
-
-  if (getCurrentInstance()) {
-    onUnmounted(() => {
-      mql?.removeEventListener('change', onSystemChange)
-    })
-  }
+  const isDark = computed(() => settings.isDark())
 
   function toggleTheme() {
     settings.theme = isDark.value ? 'light' : 'dark'

package/src/composables/useTimeUtils.ts

@@ -14,6 +14,11 @@ export function formatTime(hour: number, minute: number, format: '12h' | '24h' =
   return `${h12}:${String(minute).padStart(2, '0')} ${period}`
 }
 
+export function formatTimeSlot(time: string, format: '12h' | '24h' = '24h'): string {
+  const { hour, minute } = parseTime(time)
+  return formatTime(hour, minute, format)
+}
+
 export function generateTimeSlots(start: string, end: string, stepMinutes: number): string[] {
   const slots: string[] = []
   const s = parseTime(start)
@@ -102,12 +107,27 @@ export function compareTime(a: string, b: string): number {
   return 0
 }
 
-function toMinutes(time: string): number {
+export function findNearestTimeSlotIndex(time: string, slots: readonly string[]): number {
+  if (slots.length === 0) return -1
+  const target = toMinutes(time)
+  let bestIndex = 0
+  let bestDiff = Infinity
+  for (let index = 0; index < slots.length; index++) {
+    const diff = Math.abs(toMinutes(slots[index]) - target)
+    if (diff < bestDiff) {
+      bestDiff = diff
+      bestIndex = index
+    }
+  }
+  return bestIndex
+}
+
+export function toMinutes(time: string): number {
   const { hour, minute } = parseTime(time)
   return hour * 60 + minute
 }
 
-function fromMinutes(total: number): string {
+export function fromMinutes(total: number): string {
   const hour = Math.floor(total / 60) % 24
   const minute = total % 60
   return formatTime(hour, minute)
@@ -118,6 +138,7 @@ export function useTimeUtils() {
   return {
     parseTime,
     formatTime,
+    formatTimeSlot,
     generateTimeSlots,
     rangesOverlap,
     durationMinutes,
@@ -127,5 +148,8 @@ export function useTimeUtils() {
     snapToSlot,
     addMinutes,
     compareTime,
+    findNearestTimeSlotIndex,
+    toMinutes,
+    fromMinutes,
   }
 }