@morscherlab/mint-sdk 1.1.25 → 1.2.0-beta.10

package/src/composables/usePluginWorkspace.ts

@@ -0,0 +1,208 @@
+import { computed } from 'vue'
+import type { ComputedRef } from 'vue'
+import type { PageSelectorItem, PillNavItem } from '../types'
+import type {
+  PluginWorkspaceViewEmit,
+  PluginWorkspaceViewProps,
+} from '../components/PluginWorkspaceView.props'
+import { usePluginWorkspaceControls } from '../components/PluginWorkspaceView.controls'
+import { usePluginWorkspaceNavigation } from '../components/PluginWorkspaceView.navigation'
+import {
+  getPluginWorkspaceSidebarSlotNames,
+  getPluginWorkspaceTopBarSlotNames,
+  hasPluginWorkspaceSidebarSurface,
+} from '../components/PluginWorkspaceView.shell'
+import type {
+  PluginWorkspaceControlsModel,
+  PluginWorkspaceShellModel,
+  PluginWorkspaceSidebarModel,
+} from './pluginWorkspaceModel'
+
+/**
+ * Loosely-typed view of a component's `useSlots()` result: only slot presence and names are
+ * read here, so this accepts any `defineSlots()` shape without fighting Vue's `Slot` render
+ * function type. Mirrors the `SlotKeyMap` helper type in PluginWorkspaceView.shell.ts.
+ */
+export type PluginWorkspaceSlotsLike = Readonly<Record<string, unknown>>
+
+export interface UsePluginWorkspaceOptions {
+  /** PluginWorkspaceView's own reactive props object (from `defineProps`). */
+  props: PluginWorkspaceViewProps
+  /** PluginWorkspaceView's own slots (from `useSlots()`), used to detect provided passthrough slots. */
+  slots: PluginWorkspaceSlotsLike
+  /** PluginWorkspaceView's own typed `emit` function (from `defineEmits<PluginWorkspaceViewEmits>()`). */
+  emit: PluginWorkspaceViewEmit
+}
+
+export interface UsePluginWorkspaceReturn {
+  /** Model consumed by WorkspaceShellInternal's `shell` prop. */
+  shell: ComputedRef<PluginWorkspaceShellModel>
+  /** Model consumed by WorkspaceSidebarInternal's `sidebar` prop. */
+  sidebar: ComputedRef<PluginWorkspaceSidebarModel>
+  /** Model consumed by WorkspaceControlsInternal's `controls` prop, and by the raw `default` slot. */
+  controls: ComputedRef<PluginWorkspaceControlsModel>
+  /** Whether AppLayout should render a sidebar surface at all. */
+  hasSidebarSurface: ComputedRef<boolean>
+  /** Applies an AppSidebar `update:model-value` payload to the shared control values and emits `update:modelValue`/`update:values`. */
+  handleControlValuesUpdate: (values: Record<string, unknown>) => void
+  /** Resolves an AppTopBar `page-selector-select` payload into the active view and emits `page-selector-select`. */
+  handlePageSelectorSelect: (page: PageSelectorItem) => void
+  /** Resolves an AppTopBar `pill-select` payload into the active view and emits `pill-select`. */
+  handlePillSelect: (item: PillNavItem) => void
+}
+
+/**
+ * Maps PluginWorkspaceView's flat 72-prop surface into the three typed model objects
+ * (`shell`, `sidebar`, `controls`) rendered by its internal pieces
+ * (WorkspaceShellInternal, WorkspaceSidebarInternal, WorkspaceControlsInternal). Reuses the
+ * existing `usePluginWorkspaceControls` / `usePluginWorkspaceNavigation` composables and the
+ * PluginWorkspaceView.shell slot-detection helpers, so it changes only how that state is
+ * assembled and exposed, not the underlying behavior.
+ *
+ * @example Recommended
+ * ```ts
+ * const props = withDefaults(defineProps<PluginWorkspaceViewProps>(), { ... })
+ * const emit = defineEmits<PluginWorkspaceViewEmits>()
+ * const slots = useSlots()
+ * const { shell, sidebar, controls } = usePluginWorkspace({ props, slots, emit })
+ * ```
+ */
+export function usePluginWorkspace(options: UsePluginWorkspaceOptions): UsePluginWorkspaceReturn {
+  const { props, slots, emit } = options
+
+  const controlsState = usePluginWorkspaceControls({
+    model: () => props.model,
+    controls: () => props.controls,
+    controlOptions: () => props.controlOptions ?? {},
+    modelValue: () => props.modelValue,
+    values: () => props.values,
+    componentBindings: () => props.componentBindings,
+    componentProps: () => props.componentProps,
+    componentPropsById: () => props.componentPropsById,
+    emitValues: (values) => {
+      emit('update:modelValue', values)
+      emit('update:values', values)
+    },
+  })
+
+  const navigationState = usePluginWorkspaceNavigation({
+    activeView: () => props.activeView,
+    defaultActiveView: () => props.defaultActiveView,
+    currentPillId: () => props.currentPillId,
+    currentPageSelectorId: () => props.currentPageSelectorId,
+    pillNav: () => props.pillNav,
+    pageSelector: () => props.pageSelector,
+    panelIds: () => Object.keys(props.panels ?? {}),
+    generatedPillNav: controlsState.generatedPillNav,
+    generatedDefaultView: controlsState.generatedDefaultView,
+    emitActiveView: viewId => emit('update:activeView', viewId),
+    emitPageSelectorSelect: page => emit('page-selector-select', page),
+    emitPillSelect: item => emit('pill-select', item),
+  })
+
+  const topBarSlotNames = computed<string[]>(() => getPluginWorkspaceTopBarSlotNames(slots))
+  const sidebarSlotNames = computed<string[]>(() => getPluginWorkspaceSidebarSlotNames(slots))
+
+  const hasSidebarSurface = computed(() => hasPluginWorkspaceSidebarSurface({
+    showSidebar: props.showSidebar ?? true,
+    panels: props.panels ?? {},
+    forms: props.forms ?? {},
+    model: props.model,
+    controls: props.controls,
+    showSidebarWhenEmpty: props.showSidebarWhenEmpty ?? false,
+    sidebarContentId: props.sidebarContentId,
+    sidebarTitle: props.sidebarTitle,
+    sidebarSubtitle: props.sidebarSubtitle,
+    sidebarBadge: props.sidebarBadge,
+    hasSidebarSlot: Boolean(slots.sidebar),
+    sidebarSlotCount: sidebarSlotNames.value.length,
+  }))
+
+  const controls = computed<PluginWorkspaceControlsModel>(() => ({
+    activeView: navigationState.resolvedActiveView.value,
+    setActiveView: navigationState.setActiveView,
+    values: controlsState.internalControlValues,
+    componentBindings: controlsState.resolvedComponentBindings.value,
+    componentBindingsById: controlsState.resolvedComponentBindingsById.value,
+    componentProps: controlsState.resolvedComponentProps.value,
+    componentPropsById: controlsState.resolvedComponentPropsById.value,
+  }))
+
+  const shell = computed<PluginWorkspaceShellModel>(() => ({
+    sidebarPosition: props.sidebarPosition ?? 'left',
+    sidebarWidth: props.sidebarWidth,
+    floating: props.floating ?? true,
+    responsiveSidebar: props.responsiveSidebar ?? true,
+    sidebarToggleLabel: props.sidebarToggleLabel ?? 'Open workspace sidebar',
+    sidebarCloseLabel: props.sidebarCloseLabel ?? 'Close workspace sidebar',
+    hasSidebarSurface: hasSidebarSurface.value,
+    title: props.title ?? 'Workspace',
+    subtitle: props.subtitle,
+    topBarVariant: props.topBarVariant ?? 'card',
+    homePath: props.homePath ?? '/',
+    showLogo: props.showLogo ?? true,
+    pageSelector: props.pageSelector,
+    currentPageSelectorId: navigationState.resolvedCurrentPageSelectorId.value,
+    pluginSwitcher: props.pluginSwitcher,
+    pillNav: navigationState.resolvedPillNav.value,
+    currentPillId: navigationState.resolvedCurrentPillId.value,
+    showThemeToggle: props.showThemeToggle ?? true,
+    showSettings: props.showSettings ?? true,
+    settingsConfig: props.settingsConfig,
+    showStandaloneLabel: props.showStandaloneLabel ?? false,
+    standaloneLabel: props.standaloneLabel ?? 'Standalone',
+    accountMenu: props.accountMenu,
+    showNotifications: props.showNotifications ?? false,
+    hasNotificationDot: props.hasNotificationDot ?? false,
+    showAdmin: props.showAdmin ?? false,
+    adminPath: props.adminPath ?? '/admin',
+    userName: props.userName,
+    userInitial: props.userInitial,
+    userEmail: props.userEmail,
+    topBarSlotNames: topBarSlotNames.value,
+    controls: controls.value,
+  }))
+
+  const sidebar = computed<PluginWorkspaceSidebarModel>(() => ({
+    title: props.sidebarTitle,
+    subtitle: props.sidebarSubtitle,
+    badge: props.sidebarBadge,
+    variant: props.sidebarVariant ?? 'analysis',
+    panels: props.panels ?? {},
+    activeView: navigationState.resolvedActiveView.value,
+    floating: false,
+    dense: props.dense ?? true,
+    width: props.sidebarWidth,
+    side: props.sidebarPosition ?? 'left',
+    forms: props.forms ?? {},
+    contentId: props.sidebarContentId,
+    showWhenEmpty: (props.showSidebarWhenEmpty ?? false) || props.sidebarContentId !== undefined,
+    model: props.model,
+    controlSchema: props.controls,
+    controlOptions: props.controlOptions ?? {},
+    values: controlsState.internalControlValues,
+    formEnhancements: props.formEnhancements,
+    showFormActions: props.showFormActions ?? false,
+    formLoading: props.formLoading ?? false,
+    formDisabled: props.formDisabled ?? false,
+    formReadonly: props.formReadonly ?? false,
+    formSize: props.formSize ?? 'sm',
+    collapsible: props.sidebarCollapsible,
+    collapsed: props.sidebarCollapsed,
+    defaultCollapsed: props.defaultSidebarCollapsed ?? false,
+    collapsedWidth: props.sidebarCollapsedWidth ?? '3rem',
+    collapseButtonLabel: props.sidebarCollapseButtonLabel ?? 'Collapse sidebar',
+    expandButtonLabel: props.sidebarExpandButtonLabel ?? 'Expand sidebar',
+    slotNames: sidebarSlotNames.value,
+  }))
+
+  return {
+    shell,
+    sidebar,
+    controls,
+    hasSidebarSurface,
+    handleControlValuesUpdate: controlsState.handleControlValuesUpdate,
+    handlePageSelectorSelect: navigationState.handlePageSelectorSelect,
+    handlePillSelect: navigationState.handlePillSelect,
+  }
+}

package/src/composables/useRackEditor.ts

@@ -1,5 +1,6 @@
 import { ref, computed, type Ref, type ComputedRef } from 'vue'
 import type { Rack, SlotPosition, WellPlateFormat, Well } from '../types'
+import { PLATE_CONFIGS, rowLabel as plateRowLabel } from '../components/WellPlate.geometry'
 
 export interface UseRackEditorOptions {
   defaultFormat?: WellPlateFormat
@@ -31,15 +32,6 @@ export interface UseRackEditorReturn {
 
 const SLOT_CYCLE: SlotPosition[] = ['R', 'G', 'B', 'Y']
 
-const PLATE_CONFIGS: 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 },
-}
 
 let globalIdCounter = 0
 
@@ -156,8 +148,7 @@ export function useRackEditor(
     let counter = 1
     for (let row = 0; row < config.rows; row++) {
       for (let col = 0; col < config.cols; col++) {
-        const rowLabel = String.fromCharCode(65 + row)
-        const wellId = `${rowLabel}${col + 1}`
+        const wellId = `${plateRowLabel(row)}${col + 1}`
         // Only fill empty wells
         if (!rack.wells[wellId]?.sampleType) {
           const paddedNum = String(counter).padStart(3, '0')

package/src/composables/useRequestSyncState.ts

@@ -1,10 +1,28 @@
 import { ref, type Ref } from 'vue'
+import { readErrorMessage as readSharedErrorMessage } from '../utils/errors'
 
 export type RequestSyncSuccessKind = 'load' | 'save' | 'run'
 
+/**
+ * The unit of work `run()` drives.
+ *
+ * It receives an `AbortSignal` that fires when the run is superseded by a
+ * newer `run()` or by `cancel()`. Zero-argument operations stay valid and
+ * simply ignore it.
+ */
+export type RequestSyncOperation<T> = (signal: AbortSignal) => Promise<T>
+
 export interface RequestSyncRunOptions {
   success?: RequestSyncSuccessKind
   errorMessage?: string
+  /**
+   * Abort the previously started run when this one starts. Default `true`;
+   * pass `false` to let overlapping runs finish their own work (the stale
+   * guard on shared state still applies either way).
+   */
+  abortPrevious?: boolean
+  /** Caller-owned signal; aborting it aborts this run's signal too. */
+  signal?: AbortSignal
 }
 
 export interface UseRequestSyncStateReturn {
@@ -30,8 +48,32 @@ export interface UseRequestSyncStateReturn {
   markSaved: (date?: Date) => void
   /** Mark the operation as successfully run. */
   markRun: (date?: Date) => void
-  /** Run a request with shared loading/error handling and optional sync marking. */
-  run: <T>(operation: () => Promise<T>, options?: RequestSyncRunOptions) => Promise<T>
+  /**
+   * Run a request with shared loading/error handling and optional sync marking.
+   *
+   * ## Stale-response semantics
+   *
+   * Every call takes a monotonically increasing token. Starting a run
+   * supersedes any run started before it, and a superseded run writes **no**
+   * shared state when it finally settles: it does not clear `loading`, does not
+   * set `error`, and does not move `lastLoadedAt` / `lastSavedAt` / `lastRunAt`.
+   * Only the newest run owns those.
+   *
+   * The caller's own promise is untouched by the guard — a superseded run still
+   * resolves with its value or rejects with its own error, exactly as the
+   * operation did. The guard never invents a rejection, so a caller awaiting
+   * `run()` never sees a "superseded" error it did not cause.
+   *
+   * The operation additionally receives an `AbortSignal` that fires when its
+   * run is superseded or `cancel()` is called, so an operation that forwards
+   * the signal (`fetch(url, { signal })`) stops work instead of racing.
+   */
+  run: <T>(operation: RequestSyncOperation<T>, options?: RequestSyncRunOptions) => Promise<T>
+  /**
+   * Abort the in-flight run and drop `loading`. The aborted run's completion
+   * is treated as stale and writes no state.
+   */
+  cancel: () => void
 }
 
 /** Shared loading/error/timestamp state for generated plugin request helpers. */
@@ -49,22 +91,7 @@ export function useRequestSyncState(
   }
 
   function readErrorMessage(value: unknown, fallback = defaultErrorMessage): 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
-    ) {
-      return (value as { message: string }).message
-    }
-    return fallback
+    return readSharedErrorMessage(value, fallback)
   }
 
   function setError(value: unknown, fallback?: string): string {
@@ -85,27 +112,69 @@ export function useRequestSyncState(
     lastRunAt.value = date
   }
 
+  // Monotonic token guarding every write to the shared loading/error/timestamp
+  // state. Overlapping runs settle in any order, and a superseded one must not
+  // clear a newer run's loading flag or overwrite its error.
+  let runToken = 0
+  let activeController: AbortController | null = null
+
+  function cancel(): void {
+    runToken += 1
+    activeController?.abort()
+    activeController = null
+    loading.value = false
+  }
+
   async function run<T>(
-    operation: () => Promise<T>,
+    operation: RequestSyncOperation<T>,
     options: RequestSyncRunOptions = {},
   ): Promise<T> {
+    if (options.abortPrevious !== false) {
+      activeController?.abort()
+    }
+
+    const token = (runToken += 1)
+    const controller = new AbortController()
+    activeController = controller
+
+    const callerSignal = options.signal
+    if (callerSignal) {
+      if (callerSignal.aborted) controller.abort(callerSignal.reason)
+      else callerSignal.addEventListener(
+        'abort',
+        () => controller.abort(callerSignal.reason),
+        { once: true },
+      )
+    }
+
+    const isCurrent = (): boolean => token === runToken
+
     loading.value = true
     clearError()
     try {
-      const response = await operation()
-      if (options.success === 'load') {
-        markLoaded()
-      } else if (options.success === 'save') {
-        markSaved()
-      } else if (options.success === 'run') {
-        markRun()
+      const response = await operation(controller.signal)
+      if (isCurrent()) {
+        if (options.success === 'load') {
+          markLoaded()
+        } else if (options.success === 'save') {
+          markSaved()
+        } else if (options.success === 'run') {
+          markRun()
+        }
       }
       return response
     } catch (err) {
-      setError(err, options.errorMessage)
+      if (isCurrent()) {
+        setError(err, options.errorMessage)
+      }
       throw err
     } finally {
-      loading.value = false
+      if (isCurrent()) {
+        loading.value = false
+      }
+      if (activeController === controller) {
+        activeController = null
+      }
     }
   }
 
@@ -122,5 +191,6 @@ export function useRequestSyncState(
     markSaved,
     markRun,
     run,
+    cancel,
   }
 }

package/src/composables/useResourceCrud.ts

@@ -1,4 +1,5 @@
 import { computed, ref, shallowRef, type ComputedRef, type Ref, type ShallowRef } from 'vue'
+import { readErrorMessage } from '../utils/errors'
 
 export type ResourceKey = string | number
 
@@ -38,7 +39,11 @@ export interface UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey extends Res
   clearError: () => void
 }
 
-/** Common list/create/update/delete state wrapper for generated plugin clients. */
+/**
+ * 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>,
@@ -228,18 +233,3 @@ function resolveKey<TItem, TKey extends ResourceKey>(
   }
   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/useScheduleDrag.ts

@@ -200,6 +200,42 @@ export function useScheduleDrag(options: UseScheduleDragOptions) {
     cleanup()
   }
 
+  /**
+   * Keyboard alternative to the pointer drag: shifts an event by one slot
+   * (`mode: 'move'`) or grows/shrinks its end by one slot (`mode: 'resize'`),
+   * staying inside the visible day. Returns whether the nudge was applied.
+   */
+  function nudgeEvent(
+    event: ScheduleEvent,
+    direction: -1 | 1,
+    mode: 'move' | 'resize' = 'move',
+  ): boolean {
+    if (options.readonly.value) return false
+    if (mode === 'move' && event.draggable === false) return false
+    if (mode === 'resize' && event.resizable === false) return false
+
+    const slotMin = options.slotDuration.value
+    const dayStart = options.dayStartHour.value * 60
+    const dayEnd = options.dayEndHour.value * 60
+    const start = dateToMinutes(new Date(event.start))
+    const end = dateToMinutes(new Date(event.end))
+
+    const nextStart = mode === 'move' ? start + direction * slotMin : start
+    const nextEnd = mode === 'move'
+      ? end + direction * slotMin
+      : Math.max(start + slotMin, end + direction * slotMin)
+
+    if (nextStart < dayStart || nextEnd > dayEnd || nextEnd <= nextStart) return false
+
+    const base = new Date(event.start)
+    const newStart = minutesToDate(base, nextStart)
+    const newEnd = minutesToDate(base, nextEnd)
+
+    if (mode === 'move') options.onMoveComplete?.(event, newStart, newEnd)
+    else options.onResizeComplete?.(event, newStart, newEnd)
+    return true
+  }
+
   function addListeners() {
     document.addEventListener('pointermove', onPointerMove)
     document.addEventListener('pointerup', onPointerUp)
@@ -221,6 +257,7 @@ export function useScheduleDrag(options: UseScheduleDragOptions) {
     startCreate,
     startMove,
     startResize,
+    nudgeEvent,
   }
 }
 

package/src/composables/useWellPainting.ts

@@ -1,5 +1,10 @@
 import { computed, ref, toValue, type ComputedRef, type Ref } from 'vue'
 import type { WellPlateFormat } from '../types'
+import {
+  PLATE_CONFIGS as PLATE_DIMENSIONS,
+  rowIndex as rowLabelToIndex,
+  rowLabel as indexToRowLabel,
+} from '../components/WellPlate.geometry'
 
 export type WellPlateSource<T> = T | Ref<T> | ComputedRef<T> | (() => T)
 
@@ -34,19 +39,12 @@ export interface UseWellPaintingReturn<TMode extends string = string, TPayload =
   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. */
+/**
+ * Pointer painting/rectangle selection state for WellPlate-based editors.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+ */
 export function useWellPainting<TMode extends string = string, TPayload = unknown>(
   options: UseWellPaintingOptions<TMode, TPayload>,
 ): UseWellPaintingReturn<TMode, TPayload> {
@@ -166,22 +164,4 @@ export function wellIdsInRectangle(
   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
-}

package/src/composables/useWellPlateAdapter.ts

@@ -28,7 +28,11 @@ export interface UseWellPlateAdapterReturn {
   wells: ComputedRef<Record<string, Partial<Well>>>
 }
 
-/** Convert domain rows into WellPlate's wells prop without hand-written adapters. */
+/**
+ * Convert domain rows into WellPlate's wells prop without hand-written adapters.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+ */
 export function useWellPlateAdapter<TEntry>(
   options: WellPlateAdapterOptions<TEntry>,
 ): UseWellPlateAdapterReturn {

package/src/composables/useWellPlateEditor.ts

@@ -5,18 +5,8 @@ import type {
   SampleType,
   WellPlateFormat,
 } from '../types'
+import { SAMPLE_COLOR_SCALE as DEFAULT_PALETTE } from '../utils/color'
 
-const DEFAULT_PALETTE = [
-  '#3B82F6', // blue
-  '#10B981', // green
-  '#EF4444', // red
-  '#F59E0B', // amber
-  '#8B5CF6', // purple
-  '#F97316', // orange
-  '#06B6D4', // cyan
-  '#14B8A6', // teal
-  '#6B7280', // gray
-]
 
 const MAX_HISTORY = 50
 

package/src/composables/useWellPlateValidation.ts

@@ -33,7 +33,11 @@ export interface UseWellPlateValidationReturn<TType extends string = string> {
   errorCount: ComputedRef<number>
 }
 
-/** Rule-driven validation state for WellPlate layout/design screens. */
+/**
+ * Rule-driven validation state for WellPlate layout/design screens.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+ */
 export function useWellPlateValidation<TContext, TType extends string = string>(
   options: UseWellPlateValidationOptions<TContext, TType>,
 ): UseWellPlateValidationReturn<TType> {