@morscherlab/mint-sdk 1.0.0-alpha.2

package/dist/composables/useForm.d.ts

@@ -0,0 +1,92 @@
+import { Ref } from 'vue';
+/**
+ * Validation rule function type.
+ * Returns error message string if invalid, undefined/null if valid.
+ */
+export type ValidationRule<T = unknown> = (value: T, formData: Record<string, unknown>) => string | undefined | null;
+/**
+ * Field validation rules configuration.
+ */
+export interface FieldRules<T = unknown> {
+    required?: boolean | string;
+    minLength?: number | {
+        value: number;
+        message: string;
+    };
+    maxLength?: number | {
+        value: number;
+        message: string;
+    };
+    min?: number | {
+        value: number;
+        message: string;
+    };
+    max?: number | {
+        value: number;
+        message: string;
+    };
+    pattern?: RegExp | {
+        value: RegExp;
+        message: string;
+    };
+    email?: boolean | string;
+    custom?: ValidationRule<T> | ValidationRule<T>[];
+}
+/**
+ * Field validation rules configuration.
+ */
+export interface FieldState {
+    value: unknown;
+    error: string | null;
+    touched: boolean;
+    dirty: boolean;
+}
+/**
+ * Form state and methods.
+ */
+export interface UseFormReturn<T extends Record<string, unknown>> {
+    data: T;
+    errors: Record<string, string | null>;
+    touched: Record<string, boolean>;
+    dirty: Record<string, boolean>;
+    isValid: Ref<boolean>;
+    isDirty: Ref<boolean>;
+    isSubmitting: Ref<boolean>;
+    setFieldValue: <K extends keyof T>(field: K, value: T[K]) => void;
+    setFieldError: (field: string, error: string | null) => void;
+    setFieldTouched: (field: string, touched?: boolean) => void;
+    validateField: (field: string) => boolean;
+    validate: () => boolean;
+    reset: (values?: Partial<T>) => void;
+    handleSubmit: (onSubmit: (data: T) => Promise<void> | void) => (e?: Event) => Promise<void>;
+    getFieldProps: <K extends keyof T>(field: K) => {
+        modelValue: T[K];
+        'onUpdate:modelValue': (value: T[K]) => void;
+        onBlur: () => void;
+        error: string | null;
+    };
+}
+/**
+ * Form state management composable with validation.
+ *
+ * @param initialValues - Initial form values
+ * @param rules - Validation rules for each field
+ *
+ * @example
+ * ```typescript
+ * const { data, errors, isValid, handleSubmit, getFieldProps } = useForm(
+ *   { email: '', password: '' },
+ *   {
+ *     email: { required: true, email: true },
+ *     password: { required: true, minLength: 8 },
+ *   }
+ * )
+ *
+ * // In template
+ * <BaseInput v-bind="getFieldProps('email')" label="Email" />
+ * <BaseInput v-bind="getFieldProps('password')" type="password" label="Password" />
+ * <BaseButton @click="handleSubmit(onSubmit)" :disabled="!isValid">Submit</BaseButton>
+ * ```
+ */
+/** Reactive form state with field-level validation, dirty tracking, and submit handling. */
+export declare function useForm<T extends Record<string, unknown>>(initialValues: T, rules?: Partial<Record<keyof T, FieldRules>>): UseFormReturn<T>;

package/dist/composables/useFormBuilder.d.ts

@@ -0,0 +1,24 @@
+import { FormSchema, FieldCondition, FormEnhancements, UseFormBuilderReturn } from '../types/form-builder';
+/**
+ * Evaluate a JSON-serializable field condition against the current form data.
+ *
+ * Supports logical operators (`and`, `or`, `not`) and comparison operators
+ * (`eq`, `neq`, `gt`, `lt`, `gte`, `lte`, `in`, `notIn`, `truthy`, `falsy`,
+ * `contains`). Returns `true` if the condition passes.
+ */
+export declare function evaluateCondition(condition: FieldCondition, data: Record<string, unknown>): boolean;
+/**
+ * Drive a `FormSchema` as reactive form state.
+ *
+ * Builds initial values from schema defaults and `initialData`, derives
+ * validation rules from `FieldValidation` descriptors and enhancement
+ * validators, evaluates `FieldCondition` expressions for field/section
+ * visibility, and wires wizard step navigation when `schema.steps` is set.
+ *
+ * @param schema - Declarative form or wizard schema.
+ * @param initialData - Values that override schema defaults.
+ * @param enhancements - TypeScript-only callbacks (dynamic options, validators,
+ *   submit handler, transform, field-change watcher).
+ */
+/** Drives a declarative FormSchema as reactive state with conditional fields, wizard steps, and validation. */
+export declare function useFormBuilder<T extends Record<string, unknown> = Record<string, unknown>>(schema: FormSchema, initialData?: Partial<T>, enhancements?: FormEnhancements<T>): UseFormBuilderReturn<T>;

package/dist/composables/usePasskey.d.ts

@@ -0,0 +1,10 @@
+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/usePlatformContext.d.ts

@@ -0,0 +1,131 @@
+import { PlatformContext, PlatformContextOptions, PlatformEvent } from '../types';
+/**
+ * Platform context composable for plugin integration with MLD Platform.
+ *
+ * Provides secure communication with the parent platform via postMessage.
+ *
+ * @param options - Configuration options
+ * @param options.allowedOrigins - List of allowed origins for postMessage
+ * @param options.allowAnyOrigin - Allow any origin (UNSAFE, development only)
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - derives origin from platform injection
+ * const { isIntegrated, user, theme } = usePlatformContext()
+ *
+ * // With explicit allowed origins
+ * const { isIntegrated } = usePlatformContext({
+ *   allowedOrigins: ['https://mld.example.com']
+ * })
+ *
+ * // Development mode (UNSAFE)
+ * const { isIntegrated } = usePlatformContext({
+ *   allowAnyOrigin: import.meta.env.DEV
+ * })
+ * ```
+ */
+/** Connects a plugin to the MLD platform via postMessage, exposing user, theme, and experiment context. */
+export declare function usePlatformContext(options?: PlatformContextOptions): {
+    context: import('vue').Ref<{
+        isIntegrated: boolean;
+        plugin?: {
+            id: string;
+            name: string;
+            version: string;
+            description?: string | undefined;
+            icon?: string | undefined;
+            route_prefix: string;
+            api_prefix: string;
+            nav_items?: {
+                id: string;
+                label: string;
+                path: string;
+                icon?: string | undefined;
+                children?: /*elided*/ any[] | undefined;
+            }[] | undefined;
+            settings?: import('..').PluginSettings | undefined;
+        } | undefined;
+        platformApiUrl?: string | undefined;
+        platformOrigin?: string | undefined;
+        user?: {
+            id: string;
+            username: string;
+            role: string;
+            shortname?: string | undefined;
+        } | undefined;
+        theme: "light" | "dark" | "system";
+        allowedExperimentTypes?: string[] | null | undefined;
+        features?: {
+            experiments?: boolean | undefined;
+            passkey?: boolean | undefined;
+            multiUser?: boolean | undefined;
+        } | undefined;
+    }, PlatformContext | {
+        isIntegrated: boolean;
+        plugin?: {
+            id: string;
+            name: string;
+            version: string;
+            description?: string | undefined;
+            icon?: string | undefined;
+            route_prefix: string;
+            api_prefix: string;
+            nav_items?: {
+                id: string;
+                label: string;
+                path: string;
+                icon?: string | undefined;
+                children?: /*elided*/ any[] | undefined;
+            }[] | undefined;
+            settings?: import('..').PluginSettings | undefined;
+        } | undefined;
+        platformApiUrl?: string | undefined;
+        platformOrigin?: string | undefined;
+        user?: {
+            id: string;
+            username: string;
+            role: string;
+            shortname?: string | undefined;
+        } | undefined;
+        theme: "light" | "dark" | "system";
+        allowedExperimentTypes?: string[] | null | undefined;
+        features?: {
+            experiments?: boolean | undefined;
+            passkey?: boolean | undefined;
+            multiUser?: boolean | undefined;
+        } | undefined;
+    }>;
+    isIntegrated: import('vue').ComputedRef<boolean>;
+    plugin: import('vue').ComputedRef<{
+        id: string;
+        name: string;
+        version: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        route_prefix: string;
+        api_prefix: string;
+        nav_items?: {
+            id: string;
+            label: string;
+            path: string;
+            icon?: string | undefined;
+            children?: /*elided*/ any[] | undefined;
+        }[] | undefined;
+        settings?: import('..').PluginSettings | undefined;
+    } | undefined>;
+    user: import('vue').ComputedRef<{
+        id: string;
+        username: string;
+        role: string;
+        shortname?: string | undefined;
+    } | undefined>;
+    theme: import('vue').ComputedRef<"light" | "dark" | "system">;
+    features: import('vue').ComputedRef<{
+        experiments?: boolean | undefined;
+        passkey?: boolean | undefined;
+        multiUser?: boolean | undefined;
+    } | undefined>;
+    navigate: (path: string) => void;
+    notify: (message: string, type?: "success" | "error" | "warning" | "info") => void;
+    sendToPlatform: (event: PlatformEvent) => void;
+};

package/dist/composables/usePluginApi.d.ts

@@ -0,0 +1,29 @@
+export interface UsePluginApiOptions {
+    /**
+     * Fallback API prefix when `VITE_API_PREFIX` is not set.
+     * Typically your plugin's route prefix, e.g. `'/api/drp'`.
+     */
+    fallbackPrefix?: string;
+}
+/**
+ * Pre-configured API client for plugins.
+ *
+ * Resolves the base URL in priority order:
+ * 1. `import.meta.env.VITE_API_PREFIX` (build-time env override)
+ * 2. `fallbackPrefix` option (plugin's route prefix)
+ * 3. `'/api'` (default)
+ *
+ * Eliminates the repeated pattern across plugins:
+ * ```ts
+ * const API_BASE = import.meta.env.VITE_API_PREFIX || '/api/my-plugin'
+ * const api = useApi({ baseUrl: API_BASE })
+ * ```
+ *
+ * @example
+ * ```ts
+ * const api = usePluginApi({ fallbackPrefix: '/api/drp' })
+ * const data = await api.get('/sessions')
+ * ```
+ */
+/** Pre-configured API client resolving the plugin base URL from VITE_API_PREFIX or a fallback prefix. */
+export declare function usePluginApi(options?: UsePluginApiOptions): import('./useApi').UseApiReturn;

package/dist/composables/usePluginConfig.d.ts

@@ -0,0 +1,13 @@
+import { Ref, ComputedRef } from 'vue';
+export interface UsePluginConfigReturn {
+    config: Ref<Record<string, unknown>>;
+    isLoading: Ref<boolean>;
+    isSaving: Ref<boolean>;
+    error: Ref<string | null>;
+    isDirty: ComputedRef<boolean>;
+    load: () => Promise<void>;
+    save: () => Promise<boolean>;
+    reset: () => void;
+}
+/** Loads, saves, and tracks dirty state for a plugin's persistent configuration via the platform API. */
+export declare function usePluginConfig(pluginName?: string): UsePluginConfigReturn;

package/dist/composables/useProtocolTemplates.d.ts

@@ -0,0 +1,44 @@
+import { Ref, ComputedRef } from 'vue';
+import { ProtocolStep, ProtocolStepType } from '../types';
+export interface ParameterDefinition {
+    key: string;
+    label: string;
+    type: 'number' | 'text' | 'select' | 'concentration' | 'temperature' | 'duration' | 'reagent';
+    unit?: string;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    required?: boolean;
+    default?: unknown;
+    min?: number;
+    max?: number;
+    placeholder?: string;
+}
+export interface StepTemplate {
+    id: string;
+    type: ProtocolStepType;
+    name: string;
+    description?: string;
+    defaultDuration?: number;
+    parameters: ParameterDefinition[];
+    isBuiltIn?: boolean;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: Record<string, string>;
+}
+export interface UseProtocolTemplatesReturn {
+    builtInTemplates: StepTemplate[];
+    customTemplates: Ref<StepTemplate[]>;
+    allTemplates: ComputedRef<StepTemplate[]>;
+    getTemplateByType: (type: ProtocolStepType) => StepTemplate | undefined;
+    getTemplateById: (id: string) => StepTemplate | undefined;
+    saveCustomTemplate: (template: StepTemplate) => void;
+    deleteCustomTemplate: (templateId: string) => void;
+    validateStep: (step: ProtocolStep, template: StepTemplate) => ValidationResult;
+    createStepFromTemplate: (template: StepTemplate, overrides?: Partial<ProtocolStep>) => ProtocolStep;
+    formatParameterValue: (value: unknown, param: ParameterDefinition) => string;
+}
+/** Provides built-in and custom protocol step templates with validation and step creation helpers. */
+export declare function useProtocolTemplates(): UseProtocolTemplatesReturn;

package/dist/composables/useRackEditor.d.ts

@@ -0,0 +1,31 @@
+import { Ref, ComputedRef } from 'vue';
+import { Rack, WellPlateFormat, Well } from '../types';
+export interface UseRackEditorOptions {
+    defaultFormat?: WellPlateFormat;
+    defaultInjectionVolume?: number;
+    maxRacks?: number;
+    minRacks?: number;
+}
+export interface UseRackEditorReturn {
+    racks: Ref<Rack[]>;
+    activeRack: ComputedRef<Rack | undefined>;
+    activeRackId: Ref<string>;
+    addRack(name?: string): Rack;
+    removeRack(rackId: string): void;
+    reorderRacks(fromIndex: number, toIndex: number): void;
+    updateRack(rackId: string, data: Partial<Rack>): void;
+    setActiveRack(rackId: string): void;
+    setWellData(rackId: string, wellId: string, data: Partial<Well>): void;
+    clearWell(rackId: string, wellId: string): void;
+    clearAllWells(rackId: string): void;
+    fillSeries(rackId: string, prefix?: string): void;
+    getAllWells(): Array<{
+        rackId: string;
+        wellId: string;
+        well: Partial<Well>;
+    }>;
+    totalSampleCount: ComputedRef<number>;
+    reset(): void;
+}
+/** Manages a set of sample racks with well-level assignment, series fill, and multi-rack reordering. */
+export declare function useRackEditor(initialRacks?: Rack[], options?: UseRackEditorOptions): UseRackEditorReturn;

package/dist/composables/useReagentSeries.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Composable for generating dilution series used in plate-based experiments.
+ * Provides geometric series generation from presets (2x, 3x, ½ log, 10x)
+ * and utility functions for series manipulation.
+ */
+export interface LevelEntry {
+    value: number;
+    replicates: number;
+}
+export interface DilutionPreset {
+    label: string;
+    factor: number | 'half-log';
+}
+export declare const DEFAULT_PRESETS: DilutionPreset[];
+export declare const DEFAULT_UNITS: string[];
+export declare function generateDilutionSeries(startConcentration: number, count: number, factor: number | 'half-log', defaultReplicates?: number): LevelEntry[];
+export interface UseReagentSeriesReturn {
+    generateSeries: (start: number, count: number, factor: number | 'half-log', defaultReplicates?: number) => LevelEntry[];
+    sortLevels: (levels: LevelEntry[], order?: 'asc' | 'desc') => LevelEntry[];
+    totalPositions: (levels: LevelEntry[]) => number;
+}
+/** Generates and sorts geometric dilution series (2x, 3x, ½ log, 10x) for plate-based experiments. */
+export declare function useReagentSeries(): UseReagentSeriesReturn;

package/dist/composables/useScheduleDrag.d.ts

@@ -0,0 +1,78 @@
+import { Ref } from 'vue';
+import { ScheduleEvent } from '../types/components';
+export type DragType = 'create' | 'resize-top' | 'resize-bottom' | 'move';
+export interface DragState {
+    type: DragType;
+    event?: ScheduleEvent;
+    startDate: Date;
+    startY: number;
+    currentY: number;
+    dayIndex: number;
+    currentDayIndex: number;
+}
+export interface GhostEvent {
+    start: Date;
+    end: Date;
+    dayIndex: number;
+    style: Record<string, string>;
+}
+export interface UseScheduleDragOptions {
+    slotDuration: Ref<number>;
+    dayStartHour: Ref<number>;
+    dayEndHour: Ref<number>;
+    readonly: Ref<boolean>;
+    slotHeight: Ref<number>;
+    blockedSlots?: Ref<{
+        start: string;
+        end: string;
+        label?: string;
+    }[]>;
+    onCreateComplete?: (start: Date, end: Date) => void;
+    onMoveComplete?: (event: ScheduleEvent, newStart: Date, newEnd: Date) => void;
+    onResizeComplete?: (event: ScheduleEvent, newStart: Date, newEnd: Date) => void;
+}
+/** Handles pointer-driven create, move, and resize drag interactions for the ScheduleCalendar grid. */
+export declare function useScheduleDrag(options: UseScheduleDragOptions): {
+    isDragging: Ref<boolean, boolean>;
+    dragState: Ref<{
+        type: DragType;
+        event?: {
+            id: string;
+            start: string;
+            end: string;
+            title: string;
+            color?: string | undefined;
+            status?: import('..').ScheduleEventStatus | undefined;
+            draggable?: boolean | undefined;
+            resizable?: boolean | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        } | undefined;
+        startDate: Date;
+        startY: number;
+        currentY: number;
+        dayIndex: number;
+        currentDayIndex: number;
+    } | null, DragState | {
+        type: DragType;
+        event?: {
+            id: string;
+            start: string;
+            end: string;
+            title: string;
+            color?: string | undefined;
+            status?: import('..').ScheduleEventStatus | undefined;
+            draggable?: boolean | undefined;
+            resizable?: boolean | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        } | undefined;
+        startDate: Date;
+        startY: number;
+        currentY: number;
+        dayIndex: number;
+        currentDayIndex: number;
+    } | null>;
+    ghost: import('vue').ComputedRef<GhostEvent | null>;
+    startCreate: (date: Date, y: number, dayIndex: number) => void;
+    startMove: (event: ScheduleEvent, y: number, dayIndex: number) => void;
+    startResize: (event: ScheduleEvent, edge: "top" | "bottom", y: number, dayIndex: number) => void;
+};

package/dist/composables/useSequenceUtils.d.ts

@@ -0,0 +1,14 @@
+export type SequenceType = 'dna' | 'rna' | 'protein' | 'auto';
+export interface SequenceStats {
+    length: number;
+    gcPercent?: number;
+    molecularWeight?: number;
+}
+/** Detects, validates, cleans, and computes stats (GC%, MW) for DNA, RNA, and protein sequences. */
+export declare function useSequenceUtils(): {
+    detectSequenceType: (seq: string) => "dna" | "rna" | "protein";
+    validateSequence: (seq: string, type: SequenceType) => string;
+    reverseComplement: (seq: string, type: "dna" | "rna") => string;
+    calculateStats: (seq: string, type: "dna" | "rna" | "protein") => SequenceStats;
+    formatFasta: (seq: string, lineWidth?: number) => string;
+};

package/dist/composables/useTheme.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+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 declare function useTheme(): UseThemeReturn;

package/dist/composables/useTimeUtils.d.ts

@@ -0,0 +1,29 @@
+import { TimeRange } from '../types/components';
+export declare function parseTime(time: string): {
+    hour: number;
+    minute: number;
+};
+export declare function formatTime(hour: number, minute: number, format?: '12h' | '24h'): string;
+export declare function generateTimeSlots(start: string, end: string, stepMinutes: number): string[];
+export declare function rangesOverlap(a: TimeRange, b: TimeRange): boolean;
+export declare function durationMinutes(start: string, end: string): number;
+export declare function formatDuration(minutes: number): string;
+export declare function isTimeInRange(time: string, start: string, end: string): boolean;
+export declare function findAvailableSlots(dayStart: string, dayEnd: string, occupied: TimeRange[], minDuration: number): TimeRange[];
+export declare function snapToSlot(time: string, stepMinutes: number): string;
+export declare function addMinutes(time: string, minutes: number): string;
+export declare function compareTime(a: string, b: string): number;
+/** Time utility helpers for parsing, formatting, comparing, and snapping HH:MM strings. */
+export declare function useTimeUtils(): {
+    parseTime: typeof parseTime;
+    formatTime: typeof formatTime;
+    generateTimeSlots: typeof generateTimeSlots;
+    rangesOverlap: typeof rangesOverlap;
+    durationMinutes: typeof durationMinutes;
+    formatDuration: typeof formatDuration;
+    isTimeInRange: typeof isTimeInRange;
+    findAvailableSlots: typeof findAvailableSlots;
+    snapToSlot: typeof snapToSlot;
+    addMinutes: typeof addMinutes;
+    compareTime: typeof compareTime;
+};

package/dist/composables/useToast.d.ts

@@ -0,0 +1,22 @@
+import { Toast } from '../types';
+/** Reactive global toast queue with success/error/warning/info variants and auto-dismiss timers. */
+export declare function useToast(): {
+    toasts: import('vue').Ref<{
+        id: number;
+        message: string;
+        type: "success" | "error" | "warning" | "info";
+        duration?: number | undefined;
+    }[], Toast[] | {
+        id: number;
+        message: string;
+        type: "success" | "error" | "warning" | "info";
+        duration?: number | undefined;
+    }[]>;
+    show: (message: string, type?: Toast["type"], duration?: number) => void;
+    success: (message: string, duration?: number) => void;
+    error: (message: string, duration?: number) => void;
+    warning: (message: string, duration?: number) => void;
+    info: (message: string, duration?: number) => void;
+    dismiss: (id: number) => void;
+    clear: () => void;
+};

package/dist/composables/useWellPlateEditor.d.ts

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