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

package/dist/composables/useAsync.d.ts

@@ -1,132 +0,0 @@
-import { Ref, 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: Ref<T | null>;
-    error: Ref<AsyncError | null>;
-    state: Ref<AsyncState>;
-    isIdle: ComputedRef<boolean>;
-    isLoading: ComputedRef<boolean>;
-    isSuccess: ComputedRef<boolean>;
-    isError: ComputedRef<boolean>;
-    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> {
-    initialData?: T | null;
-    immediate?: boolean;
-    immediateArgs?: unknown[];
-    transformError?: (error: unknown) => AsyncError;
-    onSuccess?: (data: T) => void;
-    onError?: (error: AsyncError) => void;
-    resetOnExecute?: boolean;
-}
-/**
- * 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 declare function useAsync<T>(asyncFn: (...args: unknown[]) => Promise<T>, options?: UseAsyncOptions<T>): UseAsyncReturn<T>;
-/**
- * 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 declare 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;
-};

package/dist/composables/useAuth.d.ts

@@ -1,47 +0,0 @@
-import { Ref } from 'vue';
-import { AuthConfig, UserInfo } from '../types';
-/**
- * Authentication composable with automatic token refresh.
- *
- * Features:
- * - Automatic token refresh before expiration
- * - Login/logout/register functionality
- * - Token verification on startup
- * - User profile management
- *
- * @example
- * ```typescript
- * const { login, logout, isAuthenticated, user } = useAuth()
- *
- * // Login
- * const success = await login('username', 'password')
- *
- * // Automatic refresh is enabled by default
- * // Tokens are refreshed 5 minutes before expiration
- * ```
- */
-export interface UseAuthReturn {
-    login: (username: string, password: string) => Promise<boolean>;
-    logout: () => void;
-    register: (username: string, password: string, email?: string) => Promise<boolean>;
-    verifyToken: () => Promise<boolean>;
-    fetchAuthConfig: () => Promise<AuthConfig>;
-    initializeAuth: () => Promise<void>;
-    getCurrentUser: () => Promise<UserInfo | null>;
-    getAuthHeader: () => Record<string, string>;
-    updateProfile: (data: {
-        email?: string;
-        shortname?: string;
-        currentPassword?: string;
-        newPassword?: string;
-    }) => Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    refreshToken: () => Promise<boolean>;
-    isRefreshing: Ref<boolean>;
-}
-/** @internal Reset module-level state — only for use in tests. */
-export declare function _resetAuthStateForTesting(): void;
-/** Manages authentication state with login/logout/register and automatic JWT token refresh. */
-export declare function useAuth(): UseAuthReturn;

package/dist/composables/useCommandHistory.d.ts

@@ -1,33 +0,0 @@
-import { ComputedRef, Ref } from 'vue';
-export type CommandHistoryResult = void | Promise<void>;
-export interface CommandHistoryCommand {
-    execute: () => CommandHistoryResult;
-    undo: () => CommandHistoryResult;
-    redo?: () => CommandHistoryResult;
-    description?: string;
-}
-export interface CommandHistoryExecuteOptions {
-    skipExecute?: boolean;
-}
-export interface UseCommandHistoryOptions {
-    maxDepth?: number;
-}
-export interface UseCommandHistoryReturn<TCommand extends CommandHistoryCommand = CommandHistoryCommand> {
-    undoStack: Ref<TCommand[]>;
-    redoStack: Ref<TCommand[]>;
-    canUndo: ComputedRef<boolean>;
-    canRedo: ComputedRef<boolean>;
-    undoDescription: ComputedRef<string>;
-    redoDescription: ComputedRef<string>;
-    execute: (command: TCommand, options?: CommandHistoryExecuteOptions) => CommandHistoryResult;
-    push: (command: TCommand) => void;
-    undo: () => CommandHistoryResult;
-    redo: () => CommandHistoryResult;
-    clear: () => void;
-}
-/**
- * Generic command-stack state for plugin editors with undo/redo controls.
- *
- * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; keep command stacks plugin-local.
- */
-export declare function useCommandHistory<TCommand extends CommandHistoryCommand = CommandHistoryCommand>(options?: UseCommandHistoryOptions): UseCommandHistoryReturn<TCommand>;

package/dist/composables/useOptimisticMutation.d.ts

@@ -1,32 +0,0 @@
-import { ComputedRef, Ref, ShallowRef } from 'vue';
-export interface OptimisticMutationContext<TVariables, TSnapshot> {
-    variables: TVariables;
-    snapshot: TSnapshot | undefined;
-}
-export interface UseOptimisticMutationOptions<TVariables, TData, TSnapshot = unknown> {
-    mutation: (variables: TVariables) => Promise<TData>;
-    snapshot?: (variables: TVariables) => TSnapshot;
-    apply?: (variables: TVariables, snapshot: TSnapshot | undefined) => void;
-    commit?: (data: TData, context: OptimisticMutationContext<TVariables, TSnapshot>) => void;
-    rollback?: (snapshot: TSnapshot | undefined, variables: TVariables, error: unknown) => void;
-    onSuccess?: (data: TData, context: OptimisticMutationContext<TVariables, TSnapshot>) => void;
-    onError?: (error: unknown, context: OptimisticMutationContext<TVariables, TSnapshot>) => void;
-    onSettled?: (context: OptimisticMutationContext<TVariables, TSnapshot>) => void;
-    readErrorMessage?: (error: unknown) => string;
-}
-export interface UseOptimisticMutationReturn<TVariables, TData, TSnapshot = unknown> {
-    loading: ShallowRef<boolean>;
-    error: Ref<string | null>;
-    data: Ref<TData | null>;
-    lastSnapshot: Ref<TSnapshot | undefined>;
-    isIdle: ComputedRef<boolean>;
-    run: (variables: TVariables) => Promise<TData>;
-    clearError: () => void;
-    reset: () => void;
-}
-/**
- * Run async mutations with optional optimistic local updates and rollback.
- *
- * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useRequestSyncState()` instead.
- */
-export declare function useOptimisticMutation<TVariables, TData, TSnapshot = unknown>(options: UseOptimisticMutationOptions<TVariables, TData, TSnapshot>): UseOptimisticMutationReturn<TVariables, TData, TSnapshot>;

package/dist/composables/usePasskey.d.ts

@@ -1,10 +0,0 @@
-import { CredentialInfo } from '../types';
-/** Registers and authenticates passkeys using WebAuthn, lazily loading the browser dependency. */
-export declare function usePasskey(): {
-    isSupported: () => Promise<boolean>;
-    registerPasskey: (deviceName?: string) => Promise<boolean>;
-    loginWithPasskey: () => Promise<boolean>;
-    listCredentials: () => Promise<CredentialInfo[]>;
-    deleteCredential: (credentialId: string) => Promise<boolean>;
-    deleteAllCredentials: () => Promise<boolean>;
-};

package/dist/composables/usePluginConfig.d.ts

@@ -1,27 +0,0 @@
-import { Ref, ComputedRef } from 'vue';
-export interface UsePluginConfigReturn {
-    /** Editable plugin configuration values. */
-    config: Ref<Record<string, unknown>>;
-    /** Whether the config is currently loading. */
-    isLoading: Ref<boolean>;
-    /** Whether the config is currently saving. */
-    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>;
-    /** Whether local config differs from the last loaded or saved snapshot. */
-    isDirty: ComputedRef<boolean>;
-    /** Load plugin configuration from the platform. */
-    load: () => Promise<void>;
-    /** Save plugin configuration to the platform. */
-    save: () => Promise<boolean>;
-    /** Restore the last loaded or saved configuration snapshot. */
-    reset: () => void;
-}
-/**
- * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `usePluginSettings()` for typed plugin settings.
- */
-export declare function usePluginConfig(pluginName?: string): UsePluginConfigReturn;

package/dist/composables/useResourceCrud.d.ts

@@ -1,44 +0,0 @@
-import { ComputedRef, Ref, ShallowRef } from 'vue';
-export type ResourceKey = string | number;
-export interface ResourceCrudAdapter<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
-    list: () => Promise<TItem[]>;
-    create?: (payload: TCreate) => Promise<TItem>;
-    update?: (key: TKey, payload: TUpdate) => Promise<TItem>;
-    remove?: (key: TKey) => Promise<void>;
-}
-export interface UseResourceCrudOptions<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
-    adapter: ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey>;
-    initialItems?: readonly TItem[];
-    getKey?: (item: TItem) => TKey;
-    readErrorMessage?: (error: unknown) => string;
-}
-export interface UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey extends ResourceKey> {
-    items: Ref<TItem[]>;
-    loading: ShallowRef<boolean>;
-    saving: ShallowRef<boolean>;
-    deleting: ShallowRef<boolean>;
-    error: Ref<string | null>;
-    isBusy: ComputedRef<boolean>;
-    load: () => Promise<TItem[]>;
-    createItem: (payload: TCreate) => Promise<TItem>;
-    updateItem: (key: TKey, payload: TUpdate) => Promise<TItem>;
-    deleteItem: (keyOrItem: TKey | TItem) => Promise<void>;
-    setItems: (items: readonly TItem[]) => void;
-    upsertLocal: (item: TItem) => void;
-    removeLocal: (keyOrItem: TKey | TItem) => void;
-    clearError: () => void;
-}
-/**
- * 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 declare function useResourceCrud<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey>(options: UseResourceCrudOptions<TItem, TCreate, TUpdate, TKey>): UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey>;
-export interface PluginResourceClientOptions<TClient, TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
-    client: TClient;
-    list: (client: TClient) => Promise<TItem[]>;
-    create?: (client: TClient, payload: TCreate) => Promise<TItem>;
-    update?: (client: TClient, key: TKey, payload: TUpdate) => Promise<TItem>;
-    remove?: (client: TClient, key: TKey) => Promise<void>;
-}
-export declare function createPluginResourceClient<TClient, TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey>(options: PluginResourceClientOptions<TClient, TItem, TCreate, TUpdate, TKey>): ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey>;

package/dist/composables/useWellPainting.d.ts

@@ -1,39 +0,0 @@
-import { ComputedRef, Ref } from 'vue';
-import { 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;
-}
-/**
- * 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 declare function useWellPainting<TMode extends string = string, TPayload = unknown>(options: UseWellPaintingOptions<TMode, TPayload>): UseWellPaintingReturn<TMode, TPayload>;
-export declare function wellIdToCoordinate(wellId: string): WellCoordinate | null;
-export declare function coordinateToWellId(coord: WellCoordinate): string;
-export declare function wellIdsInRectangle(start: WellCoordinate, end: WellCoordinate, format: WellPlateFormat): string[];

package/dist/composables/useWellPlateAdapter.d.ts

@@ -1,40 +0,0 @@
-import { ComputedRef, Ref } from 'vue';
-import { ColumnCondition, RowCondition, Well } from '../types';
-export type WellPlateAdapterSource<T> = T | Ref<T> | ComputedRef<T> | (() => T);
-export interface WellPlateEntry {
-    wellId: string;
-    state?: Well['state'];
-    sampleType?: string;
-    value?: number;
-    metadata?: Record<string, unknown>;
-}
-export interface WellPlateAdapterOptions<TEntry> {
-    entries: WellPlateAdapterSource<readonly TEntry[]>;
-    getWellId: (entry: TEntry) => string;
-    getState?: (entry: TEntry) => Well['state'] | undefined;
-    getSampleType?: (entry: TEntry) => string | undefined;
-    getValue?: (entry: TEntry) => number | undefined;
-    getMetadata?: (entry: TEntry) => Record<string, unknown> | undefined;
-}
-export interface UseWellPlateAdapterReturn {
-    wells: ComputedRef<Record<string, Partial<Well>>>;
-}
-/**
- * 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 declare function useWellPlateAdapter<TEntry>(options: WellPlateAdapterOptions<TEntry>): UseWellPlateAdapterReturn;
-export declare function createWellPlateWells<TEntry>(entries: readonly TEntry[], options: Omit<WellPlateAdapterOptions<TEntry>, 'entries'>): Record<string, Partial<Well>>;
-export interface AxisConditionEntry {
-    label: string;
-    color: string;
-    start: string | number;
-    concentrations: readonly {
-        value: number;
-        replicates?: number;
-    }[];
-    unit?: string;
-}
-export declare function createColumnConditions(entries: readonly AxisConditionEntry[]): ColumnCondition[];
-export declare function createRowConditions(entries: readonly AxisConditionEntry[]): RowCondition[];

package/dist/composables/useWellPlateEditor.d.ts

@@ -1,33 +0,0 @@
-import { ComputedRef } from 'vue';
-import { PlateMapEditorState, PlateMap, SampleType, WellPlateFormat } from '../types';
-export interface UseWellPlateEditorOptions {
-    maxHistory?: number;
-    defaultFormat?: WellPlateFormat;
-}
-export interface UseWellPlateEditorReturn {
-    state: ComputedRef<PlateMapEditorState>;
-    plates: ComputedRef<PlateMap[]>;
-    activePlate: ComputedRef<PlateMap | undefined>;
-    samples: ComputedRef<SampleType[]>;
-    selectedWells: ComputedRef<string[]>;
-    activeSampleId: ComputedRef<string | undefined>;
-    canUndo: ComputedRef<boolean>;
-    canRedo: ComputedRef<boolean>;
-    setActivePlate: (plateId: string) => void;
-    setActiveSample: (sampleId: string | undefined) => void;
-    setSelectedWells: (wellIds: string[]) => void;
-    addPlate: (name?: string, format?: WellPlateFormat) => PlateMap;
-    removePlate: (plateId: string) => void;
-    addSample: (name: string, color?: string) => SampleType;
-    removeSample: (sampleId: string) => void;
-    assignSample: (wellIds: string[], sampleId: string | undefined) => void;
-    clearWells: (wellIds: string[]) => void;
-    undo: () => void;
-    redo: () => void;
-    exportData: (format: 'json' | 'csv') => string;
-    importData: (data: string, format: 'json' | 'csv') => boolean;
-    loadState: (state: Partial<PlateMapEditorState>) => void;
-    reset: () => void;
-}
-/** Manages multi-plate well-plate state with sample assignment, selection, and undo/redo history. */
-export declare function useWellPlateEditor(initialState?: Partial<PlateMapEditorState>, options?: UseWellPlateEditorOptions): UseWellPlateEditorReturn;

package/dist/composables/useWellPlateValidation.d.ts

@@ -1,31 +0,0 @@
-import { ComputedRef, Ref } from 'vue';
-export type WellPlateValidationSeverity = 'error' | 'warning' | 'info';
-export interface WellPlateValidationWarning<TType extends string = string> {
-    type: TType;
-    severity: WellPlateValidationSeverity;
-    message: string;
-    affectedWells?: string[];
-}
-export interface WellPlateValidationRule<TContext, TType extends string = string> {
-    type: TType;
-    severity: WellPlateValidationSeverity;
-    validate: (context: TContext) => false | string | Omit<WellPlateValidationWarning<TType>, 'type' | 'severity'>;
-}
-export type WellPlateValidationSource<T> = T | Ref<T> | ComputedRef<T> | (() => T);
-export interface UseWellPlateValidationOptions<TContext, TType extends string = string> {
-    context: WellPlateValidationSource<TContext>;
-    rules: WellPlateValidationSource<readonly WellPlateValidationRule<TContext, TType>[]>;
-}
-export interface UseWellPlateValidationReturn<TType extends string = string> {
-    warnings: ComputedRef<WellPlateValidationWarning<TType>[]>;
-    hasBlockingIssues: ComputedRef<boolean>;
-    warningCount: ComputedRef<number>;
-    errorCount: ComputedRef<number>;
-}
-/**
- * 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 declare function useWellPlateValidation<TContext, TType extends string = string>(options: UseWellPlateValidationOptions<TContext, TType>): UseWellPlateValidationReturn<TType>;
-export declare function runWellPlateValidation<TContext, TType extends string = string>(context: TContext, rules: readonly WellPlateValidationRule<TContext, TType>[]): WellPlateValidationWarning<TType>[];