@morscherlab/mint-sdk 1.2.0-beta.2 → 1.2.0-beta.20

package/dist/composables/useRequestSyncState.d.ts

@@ -1,8 +1,24 @@
 import { Ref } from 'vue';
 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 {
     /** Whether a request is in progress. */
@@ -27,8 +43,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. */
 export declare function useRequestSyncState(defaultErrorMessage?: string): UseRequestSyncStateReturn;

package/dist/composables/useResourceCrud.d.ts

@@ -28,7 +28,11 @@ export interface UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey extends Res
     removeLocal: (keyOrItem: TKey | TItem) => void;
     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 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;

package/dist/composables/useRovingFocus.d.ts

@@ -0,0 +1,24 @@
+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 declare function useRovingFocus(options: UseRovingFocusOptions): UseRovingFocusReturn;

package/dist/composables/useScheduleDrag.d.ts

@@ -75,4 +75,5 @@ export declare function useScheduleDrag(options: UseScheduleDragOptions): {
     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;
+    nudgeEvent: (event: ScheduleEvent, direction: -1 | 1, mode?: "move" | "resize") => boolean;
 };

package/dist/composables/useWellPainting.d.ts

@@ -28,7 +28,11 @@ export interface UseWellPaintingReturn<TMode extends string = string, TPayload =
     onWellMouseUp: () => void;
     cancel: () => void;
 }
-/** 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 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;

package/dist/composables/useWellPlateAdapter.d.ts

@@ -19,7 +19,11 @@ export interface WellPlateAdapterOptions<TEntry> {
 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 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 {

package/dist/composables/useWellPlateValidation.d.ts

@@ -22,6 +22,10 @@ export interface UseWellPlateValidationReturn<TType extends string = string> {
     warningCount: ComputedRef<number>;
     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 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>[];

package/dist/composables/workspaceRecipes.d.ts

@@ -0,0 +1,188 @@
+import { TopBarVariant } from '../types';
+import { FormEnhancements } from '../types/form-builder';
+import { ControlModel, ControlModelBinding, ControlSchema, ControlWorkspaceOptions, UseControlWorkspaceReturn } from './useControlSchema';
+/**
+ * Merges `initialValues`/external `modelValue`/`values` on top of a base
+ * `ControlWorkspaceOptions.initialValues`, matching the layering FormBuilder expects: base
+ * defaults, then caller-supplied initial values, then live external values win last. Shared by
+ * {@link controlWorkspaceProps} and {@link bioTemplatePresetWorkspaceProps} so both "generate a
+ * workspace from options, initialValues, and v-model" views merge options identically.
+ */
+export declare function resolveControlOptionsWithExternalValues<TOptions extends ControlWorkspaceOptions>(base: TOptions, initialValues: Record<string, unknown> | undefined, externalValues: Record<string, unknown> | undefined): TOptions;
+export interface ControlWorkspaceModelProps {
+    model?: ControlModel | ControlModelBinding;
+    controls?: ControlSchema;
+    controlOptions?: ControlWorkspaceOptions;
+    initialValues?: Record<string, unknown>;
+    modelValue?: Record<string, unknown>;
+    values?: Record<string, unknown>;
+}
+export interface ResolvedControlWorkspaceModel {
+    /** `modelValue` if provided, else `values` — the single external v-model source of truth. */
+    externalValues: Record<string, unknown> | undefined;
+    /** `model` resolved through `resolveControlModel()`, or undefined for a raw `controls` schema. */
+    resolvedModel: ControlModelBinding | undefined;
+    /** `controls` if provided, else the resolved model's controls, else `{}`. */
+    resolvedControls: ControlSchema;
+    /** `controlOptions` merged over the resolved model's own options, with initialValues/external values layered on top. */
+    resolvedControlOptions: ControlWorkspaceOptions;
+}
+/**
+ * Resolves ControlWorkspaceView's `model`/`controls`/`controlOptions`/`initialValues`/
+ * `modelValue`/`values` props into the schema + options pair `useControlWorkspace()` needs.
+ * Pure and framework-free so callers wrap each field in their own `computed()`.
+ *
+ * @example Recommended
+ * ```ts
+ * const resolved = computed(() => controlWorkspaceProps(props))
+ * const resolvedControls = computed(() => resolved.value.resolvedControls)
+ * ```
+ */
+export declare function controlWorkspaceProps(props: ControlWorkspaceModelProps): ResolvedControlWorkspaceModel;
+export interface DoseDesignWorkspacePassthroughProps {
+    workspace?: UseControlWorkspaceReturn<ControlSchema>;
+    controlOptions?: ControlWorkspaceOptions;
+    initialValues?: Record<string, unknown>;
+    modelValue?: Record<string, unknown>;
+    values?: Record<string, unknown>;
+    title?: string;
+    subtitle?: string;
+    topBarVariant?: TopBarVariant;
+    sidebarWidth?: string;
+    sidebarVariant?: 'default' | 'analysis';
+    responsiveSidebar?: boolean;
+    sidebarPosition?: 'left' | 'right';
+    sidebarTitle?: string;
+    sidebarSubtitle?: string;
+    sidebarBadge?: string | number;
+    floating?: boolean;
+    dense?: boolean;
+    showSettings?: boolean;
+    showFormActions?: boolean;
+    formEnhancements?: FormEnhancements<Record<string, unknown>>;
+    formLoading?: boolean;
+    formDisabled?: boolean;
+    formReadonly?: boolean;
+    formSize?: 'sm' | 'md' | 'lg';
+}
+/**
+ * Maps DoseDesignWorkspaceView's props straight through to the identically-named
+ * ControlWorkspaceView props it wraps — the ~25-key pass-through list that used to be spelled
+ * out attribute-by-attribute in the template. `model` is the caller's already-resolved dose
+ * design model, not the raw (possibly absent) `props.model`.
+ *
+ * @example Recommended
+ * ```vue
+ * <ControlWorkspaceView v-bind="doseDesignWorkspaceProps(props, resolvedModel)" />
+ * ```
+ */
+export declare function doseDesignWorkspaceProps(props: DoseDesignWorkspacePassthroughProps, model: ControlModel | ControlModelBinding): {
+    model: ControlModel | ControlModelBinding;
+    workspace: UseControlWorkspaceReturn<ControlSchema> | undefined;
+    controlOptions: ControlWorkspaceOptions | undefined;
+    initialValues: Record<string, unknown> | undefined;
+    modelValue: Record<string, unknown> | undefined;
+    values: Record<string, unknown> | undefined;
+    title: string | undefined;
+    subtitle: string | undefined;
+    topBarVariant: TopBarVariant | undefined;
+    sidebarWidth: string | undefined;
+    sidebarVariant: "default" | "analysis" | undefined;
+    responsiveSidebar: boolean | undefined;
+    sidebarPosition: "left" | "right" | undefined;
+    sidebarTitle: string | undefined;
+    sidebarSubtitle: string | undefined;
+    sidebarBadge: string | number | undefined;
+    floating: boolean | undefined;
+    dense: boolean | undefined;
+    showSettings: boolean | undefined;
+    showFormActions: boolean | undefined;
+    formEnhancements: FormEnhancements<Record<string, unknown>> | undefined;
+    formLoading: boolean | undefined;
+    formDisabled: boolean | undefined;
+    formReadonly: boolean | undefined;
+    formSize: "sm" | "md" | "lg" | undefined;
+};
+export interface BioTemplateExperimentWorkspaceStatusProps {
+    status?: {
+        loading?: boolean;
+        saving?: boolean;
+        error?: string | null;
+        hasExperiment?: boolean;
+        currentExperimentId?: number;
+        lastLoadedAt?: Date | null;
+        lastSavedAt?: Date | null;
+    };
+    loading?: boolean;
+    error?: string | null;
+    hasExperiment?: boolean;
+    currentExperimentId?: number;
+    lastLoadedAt?: Date | null;
+    lastSavedAt?: Date | null;
+}
+export interface ResolvedBioTemplateExperimentStatus {
+    loading: boolean;
+    error: string | null | undefined;
+    hasExperiment: boolean;
+    currentExperimentId: number | undefined;
+    lastLoadedAt: Date | null | undefined;
+    lastSavedAt: Date | null | undefined;
+}
+/**
+ * Merges BioTemplateExperimentWorkspaceView's grouped `status` prop over its individual
+ * `loading`/`error`/`hasExperiment`/... props: `status` wins whenever the corresponding field
+ * on it is set, otherwise the flat prop (or its default) is used. Centralizes the six
+ * independent fallback rules generated plugin pages rely on when they pass a request/experiment
+ * `status` object instead of wiring each field by hand.
+ */
+export declare function bioTemplateExperimentWorkspaceProps(props: BioTemplateExperimentWorkspaceStatusProps): ResolvedBioTemplateExperimentStatus;
+export interface BioTemplatePackWorkspacePassthroughProps {
+    message?: string;
+    dense?: boolean;
+    readonly?: boolean;
+    showStatus?: boolean;
+    showTemplateSummary?: boolean;
+    loadLabel?: string;
+    resetLabel?: string;
+    saveLabel?: string;
+}
+/**
+ * Assembles the prop object BioTemplatePackWorkspaceView binds onto the
+ * BioTemplateExperimentWorkspaceView it wraps: its own display props passed straight through,
+ * plus the pack-derived `target`/`label`/`status`/`actions` computed by the caller.
+ */
+export declare function bioTemplatePackWorkspaceProps<TTarget, TStatus, TActions>(props: BioTemplatePackWorkspacePassthroughProps, derived: {
+    target: TTarget;
+    label: string;
+    status: TStatus;
+    actions: TActions;
+}): {
+    target: TTarget;
+    kind: "collection";
+    label: string;
+    message: string | undefined;
+    status: TStatus;
+    actions: TActions;
+    dense: boolean | undefined;
+    readonly: boolean | undefined;
+    showStatus: boolean | undefined;
+    showTemplateSummary: boolean | undefined;
+    loadLabel: string | undefined;
+    resetLabel: string | undefined;
+    saveLabel: string | undefined;
+};
+export interface BioTemplatePresetWorkspaceOptionsProps<TOptions extends ControlWorkspaceOptions> {
+    workspaceOptions?: TOptions;
+    initialValues?: Record<string, unknown>;
+    modelValue?: Record<string, unknown>;
+    values?: Record<string, unknown>;
+}
+/**
+ * Resolves BioTemplatePresetWorkspaceView's `workspaceOptions`/`initialValues`/`modelValue`/
+ * `values` props into the single options object `useBioTemplatePresetWorkspace()` needs,
+ * reusing the same base/initialValues/external-values layering as {@link controlWorkspaceProps}.
+ */
+export declare function bioTemplatePresetWorkspaceProps<TOptions extends ControlWorkspaceOptions>(props: BioTemplatePresetWorkspaceOptionsProps<TOptions>): {
+    externalValues: Record<string, unknown> | undefined;
+    resolvedWorkspaceOptions: TOptions;
+};