@morscherlab/mint-sdk 1.2.10 → 1.3.0-beta.10

package/src/components/internal/PlateMapEditorToolbarInternal.vue

@@ -1,128 +0,0 @@
-<script setup lang="ts">
-/** Toolbar for PlateMapEditor plate tabs and import/export history actions. */
-import type { PlateMap } from '../../types'
-
-interface Props {
-  plates: PlateMap[]
-  activePlateId?: string
-  plateWellCounts: Record<string, number>
-  canAddPlate: boolean
-  canUndo: boolean
-  canRedo: boolean
-  slotColorForPlate: (plateId: string, plateIndex: number) => string
-}
-
-const props = defineProps<Props>()
-
-const emit = defineEmits<{
-  'select-plate': [plateId: string]
-  'remove-plate': [plateId: string]
-  'add-plate': []
-  undo: []
-  redo: []
-  import: []
-  'export-json': []
-}>()
-</script>
-
-<template>
-  <div class="mint-plate-editor__toolbar">
-    <div class="mint-plate-editor__tabs">
-      <button
-        v-for="(plate, index) in plates"
-        :key="plate.id"
-        type="button"
-        :class="['mint-plate-editor__tab', { 'mint-plate-editor__tab--active': plate.id === activePlateId }]"
-        @click="emit('select-plate', plate.id)"
-      >
-        <span
-          class="mint-plate-editor__tab-slot"
-          :style="{ backgroundColor: slotColorForPlate(plate.id, index) }"
-        />
-        <span class="mint-plate-editor__tab-name">{{ plate.name }}</span>
-        <span
-          v-if="plateWellCounts[plate.id] > 0"
-          class="mint-plate-editor__tab-count"
-        >
-          {{ plateWellCounts[plate.id] }}
-        </span>
-        <button
-          v-if="props.plates.length > 1"
-          type="button"
-          class="mint-plate-editor__tab-remove"
-          :aria-label="`Remove ${plate.name}`"
-          @click.stop="emit('remove-plate', plate.id)"
-        >
-          <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-            <path d="M18 6 6 18" /><path d="m6 6 12 12" />
-          </svg>
-        </button>
-      </button>
-
-      <button
-        v-if="canAddPlate"
-        type="button"
-        class="mint-plate-editor__add-plate"
-        aria-label="Add plate"
-        @click="emit('add-plate')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="M5 12h14" /><path d="M12 5v14" />
-        </svg>
-        <span>Add</span>
-      </button>
-    </div>
-
-    <div class="mint-plate-editor__spacer" />
-
-    <div class="mint-plate-editor__actions">
-      <button
-        type="button"
-        :disabled="!canUndo"
-        class="mint-plate-editor__action-btn"
-        title="Undo (Ctrl+Z)"
-        @click="emit('undo')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="M9 14 4 9l5-5" /><path d="M4 9h10.5a5.5 5.5 0 0 1 5.5 5.5a5.5 5.5 0 0 1-5.5 5.5H11" />
-        </svg>
-      </button>
-
-      <button
-        type="button"
-        :disabled="!canRedo"
-        class="mint-plate-editor__action-btn"
-        title="Redo (Ctrl+Shift+Z)"
-        @click="emit('redo')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="m15 14 5-5-5-5" /><path d="M20 9H9.5A5.5 5.5 0 0 0 4 14.5A5.5 5.5 0 0 0 9.5 20H13" />
-        </svg>
-      </button>
-
-      <div class="mint-plate-editor__divider" />
-
-      <button
-        type="button"
-        class="mint-plate-editor__action-btn"
-        title="Import"
-        @click="emit('import')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="M12 3v12" /><path d="m17 8-5-5-5 5" /><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
-        </svg>
-      </button>
-
-      <button
-        type="button"
-        class="mint-plate-editor__action-btn"
-        title="Export JSON"
-        @click="emit('export-json')"
-      >
-        <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <path d="M12 15V3" /><path d="m7 10 5 5 5-5" /><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
-        </svg>
-      </button>
-    </div>
-  </div>
-</template>

package/src/composables/useAsync.ts

@@ -1,327 +0,0 @@
-import { ref, computed, type Ref, type ComputedRef } from 'vue'
-
-/**
- * Error type for async operations.
- */
-export interface AsyncError {
-  message: string
-  code?: string
-  details?: Record<string, unknown>
-  originalError?: unknown
-}
-
-/**
- * State of an async operation.
- */
-export type AsyncState = 'idle' | 'loading' | 'success' | 'error'
-
-/**
- * Return type for useAsync composable.
- */
-export interface UseAsyncReturn<T> {
-  // Data
-  data: Ref<T | null>
-  error: Ref<AsyncError | null>
-
-  // State
-  state: Ref<AsyncState>
-  isIdle: ComputedRef<boolean>
-  isLoading: ComputedRef<boolean>
-  isSuccess: ComputedRef<boolean>
-  isError: ComputedRef<boolean>
-
-  // Methods
-  execute: (...args: unknown[]) => Promise<T | null>
-  reset: () => void
-  setData: (data: T | null) => void
-  setError: (error: AsyncError | null) => void
-}
-
-/**
- * Options for useAsync.
- */
-export interface UseAsyncOptions<T> {
-  // Initial data value
-  initialData?: T | null
-
-  // Whether to run immediately on creation
-  immediate?: boolean
-
-  // Arguments for immediate execution
-  immediateArgs?: unknown[]
-
-  // Transform error into AsyncError
-  transformError?: (error: unknown) => AsyncError
-
-  // Called on success
-  onSuccess?: (data: T) => void
-
-  // Called on error
-  onError?: (error: AsyncError) => void
-
-  // Reset data on new execution
-  resetOnExecute?: boolean
-}
-
-/**
- * Default error transformer.
- */
-function defaultTransformError(error: unknown): AsyncError {
-  if (error instanceof Error) {
-    return {
-      message: error.message,
-      originalError: error,
-    }
-  }
-
-  if (typeof error === 'object' && error !== null) {
-    const errorObj = error as Record<string, unknown>
-
-    // Handle Axios-like errors
-    if ('response' in errorObj && errorObj.response) {
-      const response = errorObj.response as Record<string, unknown>
-      const data = response.data as Record<string, unknown> | undefined
-
-      return {
-        message: (data?.detail as string) || (data?.message as string) || 'Request failed',
-        code: String(response.status),
-        details: data,
-        originalError: error,
-      }
-    }
-
-    // Handle generic error objects
-    return {
-      message: (errorObj.message as string) || 'Unknown error',
-      code: errorObj.code as string | undefined,
-      details: errorObj,
-      originalError: error,
-    }
-  }
-
-  return {
-    message: String(error),
-    originalError: error,
-  }
-}
-
-/**
- * Composable for managing async operation state.
- *
- * Provides standardized loading, error, and success state management
- * for any async function.
- *
- * @param asyncFn - The async function to wrap
- * @param options - Configuration options
- *
- * @example
- * ```typescript
- * // Basic usage
- * const { data, isLoading, error, execute } = useAsync(
- *   async (id: string) => {
- *     const response = await api.get(`/users/${id}`)
- *     return response.data
- *   }
- * )
- *
- * // Execute the function
- * await execute('user-123')
- *
- * // In template
- * <div v-if="isLoading">Loading...</div>
- * <div v-else-if="error">{{ error.message }}</div>
- * <div v-else-if="data">{{ data.name }}</div>
- * ```
- *
- * @example
- * ```typescript
- * // With options
- * const { data, execute } = useAsync(
- *   fetchUser,
- *   {
- *     immediate: true,
- *     immediateArgs: ['default-user'],
- *     onSuccess: (user) => console.log('Fetched:', user.name),
- *     onError: (error) => toast.error(error.message),
- *   }
- * )
- * ```
- *
- * @example
- * ```typescript
- * // Form submission
- * const { isLoading, error, execute: submit } = useAsync(
- *   async (formData: FormData) => {
- *     await api.post('/submit', formData)
- *   },
- *   {
- *     onSuccess: () => {
- *       toast.success('Submitted!')
- *       router.push('/success')
- *     },
- *   }
- * )
- *
- * const handleSubmit = () => submit(new FormData(formRef.value))
- * ```
- */
-/**
- * Wraps an async function with reactive loading, error, and success state plus optional auto-execute.
- *
- * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useRequestSyncState()` instead.
- */
-export function useAsync<T>(
-  asyncFn: (...args: unknown[]) => Promise<T>,
-  options: UseAsyncOptions<T> = {}
-): UseAsyncReturn<T> {
-  const {
-    initialData = null,
-    immediate = false,
-    immediateArgs = [],
-    transformError = defaultTransformError,
-    onSuccess,
-    onError,
-    resetOnExecute = false,
-  } = options
-
-  // State
-  const data = ref<T | null>(initialData) as Ref<T | null>
-  const error = ref<AsyncError | null>(null)
-  const state = ref<AsyncState>('idle')
-
-  // Computed state helpers
-  const isIdle = computed(() => state.value === 'idle')
-  const isLoading = computed(() => state.value === 'loading')
-  const isSuccess = computed(() => state.value === 'success')
-  const isError = computed(() => state.value === 'error')
-
-  // Execute the async function
-  async function execute(...args: unknown[]): Promise<T | null> {
-    state.value = 'loading'
-    error.value = null
-
-    if (resetOnExecute) {
-      data.value = null
-    }
-
-    try {
-      const result = await asyncFn(...args)
-      data.value = result
-      state.value = 'success'
-      onSuccess?.(result)
-      return result
-    } catch (e) {
-      const asyncError = transformError(e)
-      error.value = asyncError
-      state.value = 'error'
-      onError?.(asyncError)
-      return null
-    }
-  }
-
-  // Reset to initial state
-  function reset(): void {
-    data.value = initialData
-    error.value = null
-    state.value = 'idle'
-  }
-
-  // Manual data setter
-  function setData(newData: T | null): void {
-    data.value = newData
-    if (newData !== null) {
-      state.value = 'success'
-      error.value = null
-    }
-  }
-
-  // Manual error setter
-  function setError(newError: AsyncError | null): void {
-    error.value = newError
-    if (newError !== null) {
-      state.value = 'error'
-    }
-  }
-
-  // Execute immediately if requested
-  if (immediate) {
-    execute(...immediateArgs)
-  }
-
-  return {
-    data,
-    error,
-    state,
-    isIdle,
-    isLoading,
-    isSuccess,
-    isError,
-    execute,
-    reset,
-    setData,
-    setError,
-  }
-}
-
-/**
- * Create a batch of async operations that can be executed in parallel.
- *
- * @example
- * ```typescript
- * const { results, isLoading, execute } = useAsyncBatch([
- *   () => fetchUser(userId),
- *   () => fetchPosts(userId),
- *   () => fetchComments(userId),
- * ])
- *
- * await execute()
- * // results.value = [user, posts, comments]
- * ```
- */
-export function useAsyncBatch<T extends readonly (() => Promise<unknown>)[]>(
-  asyncFns: T
-): {
-  results: Ref<{ [K in keyof T]: Awaited<ReturnType<T[K]>> | null }>
-  errors: Ref<(AsyncError | null)[]>
-  isLoading: Ref<boolean>
-  execute: () => Promise<void>
-  reset: () => void
-} {
-  type Results = { [K in keyof T]: Awaited<ReturnType<T[K]>> | null }
-
-  const results = ref<Results>(asyncFns.map(() => null) as unknown as Results) as Ref<Results>
-  const errors = ref<(AsyncError | null)[]>(asyncFns.map(() => null))
-  const isLoading = ref(false)
-
-  async function execute(): Promise<void> {
-    isLoading.value = true
-    errors.value = asyncFns.map(() => null)
-
-    const promises = asyncFns.map(async (fn, index) => {
-      try {
-        const result = await fn()
-        ;(results.value as unknown[])[index] = result
-      } catch (e) {
-        errors.value[index] = defaultTransformError(e)
-        ;(results.value as unknown[])[index] = null
-      }
-    })
-
-    await Promise.all(promises)
-    isLoading.value = false
-  }
-
-  function reset(): void {
-    results.value = asyncFns.map(() => null) as unknown as Results
-    errors.value = asyncFns.map(() => null)
-    isLoading.value = false
-  }
-
-  return {
-    results,
-    errors,
-    isLoading,
-    execute,
-    reset,
-  }
-}