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

package/src/composables/useTemplateCollection.ts

@@ -1,229 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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,32 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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
-}