@morscherlab/mint-sdk 1.2.0-beta.8 → 1.2.0-beta.9

package/src/composables/useDropdownState.ts

@@ -1,10 +1,18 @@
-import { ref, type Ref } from 'vue'
+import { nextTick, ref, type Ref } from 'vue'
 import { useEventListener } from './useEventListener'
 
 export interface UseDropdownStateOptions {
   closeOnOutsideClick?: boolean
   closeOnEscape?: boolean
+  /** Close the panel when the page scrolls or the viewport resizes. Default `false`. */
+  closeOnScroll?: boolean
   insideRefs?: Array<Ref<HTMLElement | null>>
+  /**
+   * Element focus returns to when the panel closes with `close(true)` (Escape).
+   * Pass one when the trigger lives outside `rootRef`; otherwise bind the
+   * returned `triggerRef` to the trigger element.
+   */
+  triggerRef?: Ref<HTMLElement | null>
   onOpen?: () => void
   onClose?: () => void
 }
@@ -12,19 +20,29 @@ export interface UseDropdownStateOptions {
 export interface UseDropdownStateReturn {
   isOpen: Ref<boolean>
   rootRef: Ref<HTMLElement | null>
+  /** Bind to the trigger element so Escape can return focus to it. */
+  triggerRef: Ref<HTMLElement | null>
   open: () => void
-  close: () => void
+  /** Closes the panel; `returnFocus` moves focus back to `triggerRef`. */
+  close: (returnFocus?: boolean) => void
   toggle: () => void
   handleClickOutside: (event: MouseEvent) => void
   handleKeydown: (event: KeyboardEvent) => void
 }
 
-/** Shared disclosure state for dropdown-style SDK components. */
+/**
+ * Shared disclosure state for dropdown-style SDK components: open/close state,
+ * outside-click and Escape closing, optional scroll/resize closing, and focus
+ * return to the trigger. `close(returnFocus)` mirrors `useMenuKeyboard`'s
+ * contract, so the two compose directly.
+ */
 export function useDropdownState(options: UseDropdownStateOptions = {}): UseDropdownStateReturn {
   const isOpen = ref(false)
   const rootRef = ref<HTMLElement | null>(null)
+  const triggerRef = options.triggerRef ?? ref<HTMLElement | null>(null)
   const closeOnOutsideClick = options.closeOnOutsideClick ?? true
   const closeOnEscape = options.closeOnEscape ?? true
+  const closeOnScroll = options.closeOnScroll ?? false
 
   function open(): void {
     if (isOpen.value) return
@@ -32,10 +50,13 @@ export function useDropdownState(options: UseDropdownStateOptions = {}): UseDrop
     options.onOpen?.()
   }
 
-  function close(): void {
+  function close(returnFocus = false): void {
     if (!isOpen.value) return
     isOpen.value = false
     options.onClose?.()
+    if (returnFocus) {
+      void nextTick(() => triggerRef.value?.focus())
+    }
   }
 
   function toggle(): void {
@@ -60,20 +81,29 @@ export function useDropdownState(options: UseDropdownStateOptions = {}): UseDrop
 
   function handleKeydown(event: KeyboardEvent): void {
     if (closeOnEscape && event.key === 'Escape') {
-      close()
+      close(true)
     }
   }
 
+  function handleViewportChange(): void {
+    if (isOpen.value) close()
+  }
+
   if (closeOnOutsideClick) {
     useEventListener(() => document, 'click', handleClickOutside)
   }
   if (closeOnEscape) {
     useEventListener(() => document, 'keydown', handleKeydown)
   }
+  if (closeOnScroll) {
+    useEventListener(() => window, 'scroll', handleViewportChange, true)
+    useEventListener(() => window, 'resize', handleViewportChange)
+  }
 
   return {
     isOpen,
     rootRef,
+    triggerRef,
     open,
     close,
     toggle,

package/src/composables/useEventStream.ts

@@ -7,6 +7,7 @@ import {
   shallowRef,
   type Ref,
 } from 'vue'
+import { tryUseSettingsStore } from '../stores/settings'
 
 export type EventStreamTransport = (
   input: RequestInfo | URL,
@@ -26,7 +27,16 @@ export interface EventStreamOptions<TData = string> {
   headers?: HeadersInit
   credentials?: RequestCredentials
   immediate?: boolean
+  /**
+   * Reconnect after a dropped stream. Left unset, it follows the platform's
+   * `wsAutoReconnect` setting, defaulting to `true` without a settings store.
+   */
   reconnect?: boolean
+  /**
+   * Delay before the first reconnect attempt. Left unset, it follows the
+   * platform's `wsReconnectInterval` setting, defaulting to 2000 ms without a
+   * settings store. A server-sent `retry:` field still overrides it.
+   */
   reconnectDelayMs?: number
   parseJson?: boolean
   shouldReconnect?: (cause?: unknown) => boolean
@@ -114,7 +124,9 @@ export function useEventStream<TData = string>(
   let controller: AbortController | null = null
   let reader: ReadableStreamDefaultReader<Uint8Array> | null = null
   let reconnectTimer: ReturnType<typeof setTimeout> | null = null
-  let reconnectDelayMs = options.reconnectDelayMs ?? 2_000
+  const settings = tryUseSettingsStore()
+  const reconnectEnabled = options.reconnect ?? settings?.wsAutoReconnect ?? true
+  let reconnectDelayMs = options.reconnectDelayMs ?? settings?.wsReconnectInterval ?? 2_000
   let stopped = true
   let generation = 0
 
@@ -135,7 +147,7 @@ export function useEventStream<TData = string>(
 
   function scheduleReconnect(connectionGeneration: number, cause?: unknown): void {
     if (stopped || generation !== connectionGeneration) return
-    if (options.reconnect === false || options.shouldReconnect?.(cause) === false) {
+    if (!reconnectEnabled || options.shouldReconnect?.(cause) === false) {
       stopped = true
       return
     }

package/src/composables/useFileImport.ts

@@ -1,4 +1,5 @@
 import { ref, shallowRef, type Ref, type ShallowRef } from 'vue'
+import { readErrorMessage } from '../utils/errors'
 
 export interface DelimitedTable {
   columns: string[]
@@ -63,7 +64,7 @@ export function useFileImport<TResult = string>(
       result.value = parsed
       return parsed
     } catch (err) {
-      const message = readErrorMessage(err)
+      const message = readErrorMessage(err, 'Failed to import file.')
       error.value = message
       throw err
     } finally {
@@ -223,9 +224,3 @@ function formatBytes(bytes: number): string {
   if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`
   return `${Math.round(bytes / (1024 * 1024))} MB`
 }
-
-function readErrorMessage(value: unknown): string {
-  if (value instanceof Error && value.message) return value.message
-  if (typeof value === 'string' && value.trim()) return value
-  return 'Failed to import file.'
-}

package/src/composables/useGeneratedAnalysis.ts

@@ -13,7 +13,7 @@ import type {
   PluginJobCenterSource,
 } from './useJobsStatusTray'
 import { useEventStream, type EventStreamMessage } from './useEventStream'
-import { normalizeJobState } from '../jobs'
+import { isActiveJobStatus, normalizeJobState } from '../jobs'
 import type {
   GeneratedAnalysisJob,
   GeneratedAnalysisJobInput,
@@ -111,7 +111,6 @@ export interface UsePluginJobsReturn extends PluginJobCenterSource {
 
 export type UseGeneratedAnalysisReturn = UsePluginJobsReturn
 
-const ACTIVE_STATUSES = new Set(['awaiting_input', 'queued', 'running'])
 const AUTH_TOKEN_KEY = 'mint-auth-token'
 const SESSION_NOT_FOUND_DETAIL = 'Session not found'
 const MAX_RESULT_CACHE_ENTRIES = 32
@@ -473,12 +472,12 @@ function createPluginJobs(
       .then((payload) => {
         if (disposed) return jobs.value
         if (revision !== jobsRevision) {
-          if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
+          if (jobs.value.some(job => isActiveJobStatus(job.status))) schedulePoll()
           return jobs.value
         }
         replaceJobs(payload.jobs)
         error.value = null
-        if (!paused && !jobStream.isConnected.value && jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) {
+        if (!paused && !jobStream.isConnected.value && jobs.value.some(job => isActiveJobStatus(job.status))) {
           schedulePoll()
         }
         return jobs.value
@@ -530,7 +529,7 @@ function createPluginJobs(
     const current = typeof job === 'string'
       ? jobs.value.find(candidate => candidate.job_id === jobId)
       : jobs.value.find(candidate => candidate.job_id === jobId) ?? job
-    if (current && !ACTIVE_STATUSES.has(current.status)) {
+    if (current && !isActiveJobStatus(current.status)) {
       return terminalWaitResult(current, options.rejectOnFailure === true)
     }
     if (paused) return Promise.reject(new Error('Plugin jobs runtime is paused'))
@@ -567,7 +566,7 @@ function createPluginJobs(
   }
 
   function settleJobWaiters(job: GeneratedAnalysisJob): void {
-    if (ACTIVE_STATUSES.has(job.status)) return
+    if (isActiveJobStatus(job.status)) return
     const waiting = jobWaiters.get(job.job_id)
     if (!waiting) return
     jobWaiters.delete(job.job_id)
@@ -915,7 +914,7 @@ function createPluginJobs(
         await refreshJobs()
       } catch (cause) {
         error.value = errorMessage(cause, 'Failed to refresh analysis jobs')
-        if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
+        if (jobs.value.some(job => isActiveJobStatus(job.status))) schedulePoll()
       }
     }, pollInterval)
   }
@@ -927,7 +926,7 @@ function createPluginJobs(
   }
 
   function schedulePollForActiveJobs(): void {
-    if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
+    if (jobs.value.some(job => isActiveJobStatus(job.status))) schedulePoll()
   }
 
   function applyJobStreamMessage(message: EventStreamMessage<PluginJobStreamData>): void {
@@ -1005,7 +1004,7 @@ function createPluginJobs(
       scheduleManagedDownloadRefresh(jobId, managedDownloadRefreshDelay(result))
     }
     if (streamEnabled) jobStream.start()
-    else if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
+    else if (jobs.value.some(job => isActiveJobStatus(job.status))) schedulePoll()
   }
 
   function dispose(): void {

package/src/composables/useListReorder.story.vue

@@ -0,0 +1,143 @@
+<script setup lang="ts">
+/** Demonstrates `useListReorder`: drag a row, or focus a handle and press Alt with the arrow keys. */
+import { ref } from 'vue'
+import { useListReorder } from './useListReorder'
+
+interface Step { id: string; name: string }
+
+const steps = ref<Step[]>([
+  { id: 's1', name: 'Thaw samples' },
+  { id: 's2', name: 'Quench metabolism' },
+  { id: 's3', name: 'Extract metabolites' },
+  { id: 's4', name: 'Dry down' },
+])
+
+const handles = new Map<string, HTMLElement>()
+
+function setHandle(id: string, el: Element | null) {
+  if (el instanceof HTMLElement) handles.set(id, el)
+  else handles.delete(id)
+}
+
+const {
+  draggingId,
+  dragOverId,
+  announcement,
+  announcerStyle,
+  onDragStart,
+  onDragOver,
+  onDragLeave,
+  onDrop,
+  onDragEnd,
+  onKeydown,
+} = useListReorder<Step>({
+  items: () => steps.value,
+  getId: (step) => step.id,
+  getLabel: (step) => step.name,
+  getElement: (id) => handles.get(id),
+  itemNoun: 'Step',
+  onReorder: ({ items }) => {
+    steps.value = items
+  },
+})
+
+function initState() {
+  return { showAnnouncement: true }
+}
+</script>
+
+<template>
+  <Story title="Composables/useListReorder">
+    <Variant title="Playground" :init-state="initState">
+      <template #default="{ state }">
+        <div style="padding: 2rem; max-width: 600px;">
+          <p class="mint-story-hint">
+            Drag a row, or focus its handle and press Alt with the up/down arrow keys.
+          </p>
+          <ul class="mint-story-list">
+            <li
+              v-for="(step, index) in steps"
+              :key="step.id"
+              class="mint-story-row"
+              :class="{
+                'mint-story-row--dragging': draggingId === step.id,
+                'mint-story-row--over': dragOverId === step.id,
+              }"
+              draggable="true"
+              @dragstart="onDragStart($event, step, index)"
+              @dragover="onDragOver($event, step, index)"
+              @dragleave="onDragLeave"
+              @drop="onDrop($event, step, index)"
+              @dragend="onDragEnd"
+            >
+              <button
+                :ref="(el) => setHandle(step.id, el as Element | null)"
+                type="button"
+                class="mint-story-handle"
+                :aria-label="`Reorder ${step.name}. Press Alt with the arrow keys to move it.`"
+                @keydown="onKeydown($event, step, index)"
+              >
+                ⠿
+              </button>
+              <span>{{ index + 1 }}. {{ step.name }}</span>
+            </li>
+          </ul>
+
+          <p v-if="state.showAnnouncement" class="mint-story-hint">
+            Live region: <em>{{ announcement || '—' }}</em>
+          </p>
+          <div role="status" aria-live="polite" :style="announcerStyle">{{ announcement }}</div>
+        </div>
+      </template>
+
+      <template #controls="{ state }">
+        <HstCheckbox v-model="state.showAnnouncement" title="Show live-region text" />
+      </template>
+    </Variant>
+  </Story>
+</template>
+
+<style scoped>
+.mint-story-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+}
+
+.mint-story-row {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.5rem 0.75rem;
+  border: 1px solid var(--border-color);
+  border-radius: 0.5rem;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+}
+
+.mint-story-row--dragging {
+  opacity: 0.5;
+}
+
+.mint-story-row--over {
+  border-color: var(--color-primary);
+}
+
+.mint-story-handle {
+  padding: 0;
+  border: 0;
+  background: none;
+  color: var(--text-muted);
+  cursor: grab;
+  font-size: 1rem;
+}
+
+.mint-story-hint {
+  margin: 0 0 0.75rem;
+  color: var(--text-secondary);
+  font-size: 0.8125rem;
+}
+</style>

package/src/composables/useListReorder.ts

@@ -0,0 +1,242 @@
+import { nextTick, ref, type Ref } from 'vue'
+
+/** Inline style for a visually hidden `aria-live` region (no global utility class in the SDK). */
+export const REORDER_ANNOUNCER_STYLE = Object.freeze({
+  position: 'absolute',
+  width: '1px',
+  height: '1px',
+  padding: '0',
+  margin: '-1px',
+  overflow: 'hidden',
+  clip: 'rect(0, 0, 0, 0)',
+  whiteSpace: 'nowrap',
+  border: '0',
+})
+
+export interface UseReorderAnnouncerReturn {
+  /** Bind to a polite live region's text content. */
+  announcement: Ref<string>
+  /** Publishes a message to the live region. */
+  announce: (message: string) => void
+  /** Bind to the live region's `style` so it stays visually hidden. */
+  announcerStyle: typeof REORDER_ANNOUNCER_STYLE
+}
+
+/**
+ * Screen-reader announcements for drag/keyboard move interactions. Bind
+ * `announcement` to a `role="status" aria-live="polite"` element styled with
+ * `announcerStyle`.
+ */
+export function useReorderAnnouncer(): UseReorderAnnouncerReturn {
+  const announcement = ref('')
+
+  function announce(message: string) {
+    // Re-announce identical consecutive messages by clearing first.
+    if (announcement.value === message) announcement.value = ''
+    void nextTick(() => {
+      announcement.value = message
+    })
+  }
+
+  return { announcement, announce, announcerStyle: REORDER_ANNOUNCER_STYLE }
+}
+
+export interface ListReorderMove<T> {
+  /** Index the item moved from, within `items()`. */
+  fromIndex: number
+  /** Index the item moved to, within `items()`. */
+  toIndex: number
+  /** The reordered array (a copy — `items()` is never mutated). */
+  items: T[]
+  /** Whether the move came from the keyboard or a pointer drag. */
+  source: 'keyboard' | 'drag'
+}
+
+export interface UseListReorderOptions<T> {
+  /** The list being reordered, in its canonical (not merely rendered) order. */
+  items: () => T[]
+  /** Stable id for an item; falls back to the render index when ids repeat. */
+  getId: (item: T, index: number) => string
+  /** Applies the move. The composable never mutates the source array. */
+  onReorder: (move: ListReorderMove<T>) => void
+  /** Human-readable name used in announcements. Defaults to the item's id. */
+  getLabel?: (item: T, index: number) => string
+  /** Blocks every reorder while it returns `true` (readonly / non-sortable lists). */
+  disabled?: () => boolean
+  /** Resolves the focusable element for an id so keyboard moves keep focus on the item. */
+  getElement?: (id: string) => HTMLElement | null | undefined
+  /** Noun used in announcements, e.g. `'Reagent'`. Default `'Item'`. */
+  itemNoun?: string
+}
+
+export interface UseListReorderReturn<T> {
+  /** Id of the item currently being dragged, or `null`. */
+  draggingId: Ref<string | null>
+  /** Id of the item the pointer is hovering as a drop target, or `null`. */
+  dragOverId: Ref<string | null>
+  isDragging: (id: string) => boolean
+  isDragOver: (id: string) => boolean
+  announcement: Ref<string>
+  announcerStyle: typeof REORDER_ANNOUNCER_STYLE
+  announce: (message: string) => void
+  /** Bind to the draggable element's `@dragstart`. */
+  onDragStart: (event: DragEvent, item: T, index: number) => void
+  /** Bind to `@dragover` — calls `preventDefault()` so the drop is accepted. */
+  onDragOver: (event: DragEvent, item: T, index: number) => void
+  /** Bind to `@dragleave`. */
+  onDragLeave: () => void
+  /** Bind to `@drop`. */
+  onDrop: (event: DragEvent, item: T, index: number) => void
+  /** Bind to `@dragend`. */
+  onDragEnd: () => void
+  /**
+   * Bind to the item's (or its drag handle's) `@keydown`: Alt+ArrowUp / Alt+ArrowLeft
+   * moves the item one position earlier, Alt+ArrowDown / Alt+ArrowRight one later.
+   */
+  onKeydown: (event: KeyboardEvent, item: T, index: number) => void
+  /** Moves an item between two indices of `items()` programmatically. */
+  move: (fromIndex: number, toIndex: number, source?: 'keyboard' | 'drag') => void
+}
+
+/** Pure helper: a copy of `items` with the entry at `from` moved to `to`. */
+export function reorderList<T>(items: T[], from: number, to: number): T[] {
+  const next = [...items]
+  const [moved] = next.splice(from, 1)
+  next.splice(to, 0, moved)
+  return next
+}
+
+/**
+ * Keyboard-accessible list reordering shared by the SDK's drag-to-reorder lists.
+ * It owns the HTML5 drag state, the drop-index maths, and an Alt+Arrow keyboard
+ * alternative that announces every move through a polite live region — so a
+ * reorder never depends on a pointer.
+ */
+export function useListReorder<T>(options: UseListReorderOptions<T>): UseListReorderReturn<T> {
+  const draggingId = ref<string | null>(null)
+  const dragOverId = ref<string | null>(null)
+  const { announcement, announce, announcerStyle } = useReorderAnnouncer()
+  const noun = options.itemNoun ?? 'Item'
+
+  function isDisabled(): boolean {
+    return options.disabled?.() === true
+  }
+
+  function idFor(item: T, index: number): string {
+    return options.getId(item, index)
+  }
+
+  /** Index within `items()`, resolved by id so filtered/sorted renders still map back. */
+  function indexOf(item: T, renderIndex: number): number {
+    const id = idFor(item, renderIndex)
+    const found = options.items().findIndex((candidate, index) => idFor(candidate, index) === id)
+    return found === -1 ? renderIndex : found
+  }
+
+  function labelFor(index: number): string {
+    const item = options.items()[index]
+    if (item === undefined) return noun
+    return options.getLabel?.(item, index) ?? idFor(item, index)
+  }
+
+  function clearDragState() {
+    draggingId.value = null
+    dragOverId.value = null
+  }
+
+  function move(fromIndex: number, toIndex: number, source: 'keyboard' | 'drag' = 'keyboard') {
+    if (isDisabled()) return
+    const items = options.items()
+    if (
+      fromIndex === toIndex ||
+      fromIndex < 0 ||
+      toIndex < 0 ||
+      fromIndex >= items.length ||
+      toIndex >= items.length
+    ) return
+
+    const movedId = idFor(items[fromIndex], fromIndex)
+    const label = labelFor(fromIndex)
+    options.onReorder({
+      fromIndex,
+      toIndex,
+      items: reorderList(items, fromIndex, toIndex),
+      source,
+    })
+    announce(`${label} moved to position ${toIndex + 1} of ${items.length}.`)
+    void nextTick(() => options.getElement?.(movedId)?.focus())
+  }
+
+  function onDragStart(event: DragEvent, item: T, index: number) {
+    if (isDisabled()) return
+    const id = idFor(item, index)
+    draggingId.value = id
+    if (event.dataTransfer) {
+      event.dataTransfer.effectAllowed = 'move'
+      event.dataTransfer.setData('text/plain', id)
+    }
+  }
+
+  function onDragOver(event: DragEvent, item: T, index: number) {
+    if (isDisabled() || draggingId.value === null) return
+    event.preventDefault()
+    if (event.dataTransfer) event.dataTransfer.dropEffect = 'move'
+    const id = idFor(item, index)
+    dragOverId.value = id === draggingId.value ? null : id
+  }
+
+  function onDragLeave() {
+    dragOverId.value = null
+  }
+
+  function onDrop(event: DragEvent, item: T, index: number) {
+    if (isDisabled() || draggingId.value === null) {
+      clearDragState()
+      return
+    }
+    event.preventDefault()
+
+    const items = options.items()
+    const fromIndex = items.findIndex((candidate, i) => idFor(candidate, i) === draggingId.value)
+    const toIndex = indexOf(item, index)
+    clearDragState()
+    if (fromIndex === -1) return
+    move(fromIndex, toIndex, 'drag')
+  }
+
+  function onDragEnd() {
+    clearDragState()
+  }
+
+  function onKeydown(event: KeyboardEvent, item: T, index: number) {
+    if (isDisabled() || !event.altKey) return
+    const direction =
+      event.key === 'ArrowUp' || event.key === 'ArrowLeft'
+        ? -1
+        : event.key === 'ArrowDown' || event.key === 'ArrowRight'
+          ? 1
+          : 0
+    if (direction === 0) return
+
+    event.preventDefault()
+    const fromIndex = indexOf(item, index)
+    move(fromIndex, fromIndex + direction, 'keyboard')
+  }
+
+  return {
+    draggingId,
+    dragOverId,
+    isDragging: (id: string) => draggingId.value === id,
+    isDragOver: (id: string) => dragOverId.value === id,
+    announcement,
+    announcerStyle,
+    announce,
+    onDragStart,
+    onDragOver,
+    onDragLeave,
+    onDrop,
+    onDragEnd,
+    onKeydown,
+    move,
+  }
+}

package/src/composables/useMenuKeyboard.ts

@@ -27,8 +27,8 @@ export interface UseMenuKeyboardReturn {
 
 /**
  * Shared keyboard contract for menu- and listbox-style disclosure panels (the
- * WAI-ARIA menu button pattern). Used by AppAvatarMenu and DropdownButton; ActionMenu
- * implements the same contract inline.
+ * WAI-ARIA menu button pattern). Used by ActionMenu, AppAvatarMenu and DropdownButton,
+ * each pairing it with `useDropdownState` for the disclosure state itself.
  */
 export function useMenuKeyboard(options: UseMenuKeyboardOptions): UseMenuKeyboardReturn {
   function focusItem(position: 'first' | 'last') {

package/src/composables/useOptimisticMutation.ts

@@ -1,4 +1,5 @@
 import { computed, ref, shallowRef, type ComputedRef, type Ref, type ShallowRef } from 'vue'
+import { readErrorMessage } from '../utils/errors'
 
 export interface OptimisticMutationContext<TVariables, TSnapshot> {
   variables: TVariables
@@ -94,18 +95,3 @@ export function useOptimisticMutation<TVariables, TData, TSnapshot = unknown>(
     reset,
   }
 }
-
-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/usePluginConfig.ts

@@ -75,7 +75,9 @@ export interface UsePluginConfigReturn {
   reset: () => void
 }
 
-/** @deprecated Use `usePluginSettings()` for typed plugin settings. */
+/**
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `usePluginSettings()` for typed plugin settings.
+ */
 export function usePluginConfig(pluginName?: string): UsePluginConfigReturn {
   const injectedContext = getInjectedPlatformContext()
   const { plugin } = usePlatformContext()