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

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

@@ -0,0 +1,32 @@
+import { computed, type Ref } from 'vue'
+import { useSettingsStore } from '../stores/settings'
+
+export interface UseThemeReturn {
+  isDark: Ref<boolean>
+  toggleTheme: () => void
+  setTheme: (theme: 'light' | 'dark') => void
+}
+
+/** Reads and toggles the active theme (light/dark/system) with reactivity to OS preference changes. */
+export function useTheme(): UseThemeReturn {
+  const settings = useSettingsStore()
+
+  // Load persisted theme from localStorage (idempotent — safe to call multiple times)
+  settings.initialize()
+
+  const isDark = computed(() => settings.isDark())
+
+  function toggleTheme() {
+    settings.theme = isDark.value ? 'light' : 'dark'
+  }
+
+  function setTheme(theme: 'light' | 'dark') {
+    settings.theme = theme
+  }
+
+  return {
+    isDark,
+    toggleTheme,
+    setTheme,
+  }
+}

package/src/composables/useTimeUtils.ts

@@ -0,0 +1,155 @@
+import type { TimeRange } from '../types/components'
+
+export function parseTime(time: string): { hour: number; minute: number } {
+  const [h, m] = time.split(':').map(Number)
+  return { hour: h, minute: m }
+}
+
+export function formatTime(hour: number, minute: number, format: '12h' | '24h' = '24h'): string {
+  if (format === '24h') {
+    return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`
+  }
+  const period = hour >= 12 ? 'PM' : 'AM'
+  const h12 = hour === 0 ? 12 : hour > 12 ? hour - 12 : hour
+  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)
+  const e = parseTime(end)
+  const startMin = s.hour * 60 + s.minute
+  const endMin = e.hour * 60 + e.minute
+
+  for (let m = startMin; m <= endMin; m += stepMinutes) {
+    const hour = Math.floor(m / 60)
+    const minute = m % 60
+    if (hour >= 24) break
+    slots.push(formatTime(hour, minute))
+  }
+  return slots
+}
+
+export function rangesOverlap(a: TimeRange, b: TimeRange): boolean {
+  const aStart = toMinutes(a.start)
+  const aEnd = toMinutes(a.end)
+  const bStart = toMinutes(b.start)
+  const bEnd = toMinutes(b.end)
+  return aStart < bEnd && bStart < aEnd
+}
+
+export function durationMinutes(start: string, end: string): number {
+  return toMinutes(end) - toMinutes(start)
+}
+
+export function formatDuration(minutes: number): string {
+  if (minutes < 0) return '-' + formatDuration(-minutes)
+  const h = Math.floor(minutes / 60)
+  const m = minutes % 60
+  if (h === 0) return `${m}m`
+  if (m === 0) return `${h}h`
+  return `${h}h ${m}m`
+}
+
+export function isTimeInRange(time: string, start: string, end: string): boolean {
+  const t = toMinutes(time)
+  return t >= toMinutes(start) && t <= toMinutes(end)
+}
+
+export function findAvailableSlots(
+  dayStart: string,
+  dayEnd: string,
+  occupied: TimeRange[],
+  minDuration: number,
+): TimeRange[] {
+  const sorted = [...occupied].sort((a, b) => toMinutes(a.start) - toMinutes(b.start))
+  const available: TimeRange[] = []
+  let cursor = toMinutes(dayStart)
+  const end = toMinutes(dayEnd)
+
+  for (const slot of sorted) {
+    const slotStart = toMinutes(slot.start)
+    const slotEnd = toMinutes(slot.end)
+    if (slotStart > cursor && slotStart - cursor >= minDuration) {
+      available.push({ start: fromMinutes(cursor), end: fromMinutes(slotStart) })
+    }
+    cursor = Math.max(cursor, slotEnd)
+  }
+
+  if (end > cursor && end - cursor >= minDuration) {
+    available.push({ start: fromMinutes(cursor), end: fromMinutes(end) })
+  }
+
+  return available
+}
+
+export function snapToSlot(time: string, stepMinutes: number): string {
+  const total = toMinutes(time)
+  const snapped = Math.round(total / stepMinutes) * stepMinutes
+  return fromMinutes(snapped)
+}
+
+export function addMinutes(time: string, minutes: number): string {
+  const total = toMinutes(time) + minutes
+  return fromMinutes(Math.max(0, Math.min(total, 24 * 60 - 1)))
+}
+
+export function compareTime(a: string, b: string): number {
+  const ma = toMinutes(a)
+  const mb = toMinutes(b)
+  if (ma < mb) return -1
+  if (ma > mb) return 1
+  return 0
+}
+
+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
+}
+
+export function fromMinutes(total: number): string {
+  const hour = Math.floor(total / 60) % 24
+  const minute = total % 60
+  return formatTime(hour, minute)
+}
+
+/** Time utility helpers for parsing, formatting, comparing, and snapping HH:MM strings. */
+export function useTimeUtils() {
+  return {
+    parseTime,
+    formatTime,
+    formatTimeSlot,
+    generateTimeSlots,
+    rangesOverlap,
+    durationMinutes,
+    formatDuration,
+    isTimeInRange,
+    findAvailableSlots,
+    snapToSlot,
+    addMinutes,
+    compareTime,
+    findNearestTimeSlotIndex,
+    toMinutes,
+    fromMinutes,
+  }
+}

package/src/composables/useToast.ts

@@ -0,0 +1,40 @@
+import { ref } from 'vue'
+import type { Toast } from '../types'
+
+const toasts = ref<Toast[]>([])
+let nextId = 0
+
+/** Reactive global toast queue with success/error/warning/info variants and auto-dismiss timers. */
+export function useToast() {
+  function show(message: string, type: Toast['type'] = 'success', duration = 3500) {
+    const id = nextId++
+    toasts.value.push({ id, message, type, duration })
+    setTimeout(() => dismiss(id), duration)
+  }
+
+  function success(message: string, duration = 3500) {
+    show(message, 'success', duration)
+  }
+
+  function error(message: string, duration = 5000) {
+    show(message, 'error', duration)
+  }
+
+  function warning(message: string, duration = 4000) {
+    show(message, 'warning', duration)
+  }
+
+  function info(message: string, duration = 3500) {
+    show(message, 'info', duration)
+  }
+
+  function dismiss(id: number) {
+    toasts.value = toasts.value.filter(t => t.id !== id)
+  }
+
+  function clear() {
+    toasts.value = []
+  }
+
+  return { toasts, show, success, error, warning, info, dismiss, clear }
+}

package/src/composables/useWellPainting.ts

@@ -0,0 +1,187 @@
+import { computed, ref, toValue, type ComputedRef, type Ref } from 'vue'
+import type { WellPlateFormat } from '../types'
+
+export type WellPlateSource<T> = T | Ref<T> | ComputedRef<T> | (() => T)
+
+export interface WellCoordinate {
+  row: number
+  col: number
+}
+
+export interface WellPaintResult<TMode extends string = string, TPayload = unknown> {
+  wellIds: string[]
+  mode: TMode
+  payload?: TPayload
+}
+
+export interface UseWellPaintingOptions<TMode extends string = string, TPayload = unknown> {
+  format: WellPlateSource<WellPlateFormat>
+  initialMode?: TMode
+  initialPayload?: TPayload
+  onComplete?: (result: WellPaintResult<TMode, TPayload>) => void
+}
+
+export interface UseWellPaintingReturn<TMode extends string = string, TPayload = unknown> {
+  activeMode: Ref<TMode>
+  activePayload: Ref<TPayload | undefined>
+  isDragging: Ref<boolean>
+  previewWellIds: ComputedRef<string[]>
+  setMode: (mode: TMode, payload?: TPayload) => void
+  setPayload: (payload: TPayload | undefined) => void
+  onWellMouseDown: (wellId: string) => void
+  onWellMouseMove: (wellId: string) => void
+  onWellMouseUp: () => void
+  cancel: () => void
+}
+
+const ROW_LABELS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+const PLATE_DIMENSIONS: Record<WellPlateFormat, { rows: number; cols: number }> = {
+  6: { rows: 2, cols: 3 },
+  12: { rows: 3, cols: 4 },
+  24: { rows: 4, cols: 6 },
+  48: { rows: 6, cols: 8 },
+  54: { rows: 6, cols: 9 },
+  96: { rows: 8, cols: 12 },
+  384: { rows: 16, cols: 24 },
+}
+
+/** Pointer painting/rectangle selection state for WellPlate-based editors. */
+export function useWellPainting<TMode extends string = string, TPayload = unknown>(
+  options: UseWellPaintingOptions<TMode, TPayload>,
+): UseWellPaintingReturn<TMode, TPayload> {
+  const activeMode = ref<TMode>(options.initialMode ?? 'select' as TMode) as Ref<TMode>
+  const activePayload = ref<TPayload | undefined>(options.initialPayload) as Ref<TPayload | undefined>
+  const isDragging = ref(false)
+  const dragStart = ref<WellCoordinate | null>(null)
+  const dragEnd = ref<WellCoordinate | null>(null)
+  const paintTrail = ref<Set<string>>(new Set())
+
+  const previewWellIds = computed(() => {
+    if (!isDragging.value) return []
+    if (activeMode.value === 'select') {
+      if (!dragStart.value || !dragEnd.value) return []
+      return wellIdsInRectangle(dragStart.value, dragEnd.value, toValue(options.format))
+    }
+    return [...paintTrail.value]
+  })
+
+  function setMode(mode: TMode, payload?: TPayload): void {
+    activeMode.value = mode
+    activePayload.value = payload
+  }
+
+  function setPayload(payload: TPayload | undefined): void {
+    activePayload.value = payload
+  }
+
+  function onWellMouseDown(wellId: string): void {
+    const coord = wellIdToCoordinate(wellId)
+    if (!coord) return
+    isDragging.value = true
+    dragStart.value = coord
+    dragEnd.value = coord
+    paintTrail.value = new Set([wellId])
+  }
+
+  function onWellMouseMove(wellId: string): void {
+    if (!isDragging.value) return
+    const coord = wellIdToCoordinate(wellId)
+    if (!coord) return
+    dragEnd.value = coord
+    if (activeMode.value !== 'select') {
+      paintTrail.value = new Set([...paintTrail.value, wellId])
+    }
+  }
+
+  function onWellMouseUp(): void {
+    if (!isDragging.value) return
+    const wellIds = previewWellIds.value
+    isDragging.value = false
+    if (wellIds.length > 0) {
+      options.onComplete?.({
+        wellIds,
+        mode: activeMode.value,
+        payload: activePayload.value,
+      })
+    }
+    clearDragState()
+  }
+
+  function cancel(): void {
+    isDragging.value = false
+    clearDragState()
+  }
+
+  function clearDragState(): void {
+    dragStart.value = null
+    dragEnd.value = null
+    paintTrail.value = new Set()
+  }
+
+  return {
+    activeMode,
+    activePayload,
+    isDragging,
+    previewWellIds,
+    setMode,
+    setPayload,
+    onWellMouseDown,
+    onWellMouseMove,
+    onWellMouseUp,
+    cancel,
+  }
+}
+
+export function wellIdToCoordinate(wellId: string): WellCoordinate | null {
+  const match = /^([A-Z]+)(\d+)$/i.exec(wellId.trim())
+  if (!match) return null
+  return {
+    row: rowLabelToIndex(match[1].toUpperCase()),
+    col: Number(match[2]) - 1,
+  }
+}
+
+export function coordinateToWellId(coord: WellCoordinate): string {
+  return `${indexToRowLabel(coord.row)}${coord.col + 1}`
+}
+
+export function wellIdsInRectangle(
+  start: WellCoordinate,
+  end: WellCoordinate,
+  format: WellPlateFormat,
+): string[] {
+  const dimensions = PLATE_DIMENSIONS[format]
+  const minRow = Math.max(0, Math.min(start.row, end.row))
+  const maxRow = Math.min(dimensions.rows - 1, Math.max(start.row, end.row))
+  const minCol = Math.max(0, Math.min(start.col, end.col))
+  const maxCol = Math.min(dimensions.cols - 1, Math.max(start.col, end.col))
+  const ids: string[] = []
+
+  for (let row = minRow; row <= maxRow; row++) {
+    for (let col = minCol; col <= maxCol; col++) {
+      ids.push(coordinateToWellId({ row, col }))
+    }
+  }
+  return ids
+}
+
+function rowLabelToIndex(label: string): number {
+  let result = 0
+  for (const char of label) {
+    result = result * 26 + (char.charCodeAt(0) - 64)
+  }
+  return result - 1
+}
+
+function indexToRowLabel(index: number): string {
+  if (index < ROW_LABELS.length) return ROW_LABELS[index]
+  let value = index + 1
+  let label = ''
+  while (value > 0) {
+    value--
+    label = ROW_LABELS[value % 26] + label
+    value = Math.floor(value / 26)
+  }
+  return label
+}