@digiform/wizard 0.1.7 → 0.2.2

package/features/state-management/machines/actions/componentActions.d.ts

@@ -0,0 +1,10 @@
+import { ActionArgs } from 'xstate';
+import { FormMachineContext, FormMachineEvents } from '../types';
+/**
+ * Custom action to evaluate component triggers
+ */
+export declare const evaluateComponentTriggers: ({ context, event, self, }: ActionArgs<FormMachineContext, FormMachineEvents, FormMachineEvents>) => void;
+/**
+ * Custom action to execute a specific component action
+ */
+export declare const executeComponentAction: ({ context, event, self, }: ActionArgs<FormMachineContext, FormMachineEvents, FormMachineEvents>) => void;

package/features/state-management/machines/actions/navigationActions.d.ts

@@ -0,0 +1,50 @@
+import { ActionArgs } from 'xstate';
+import { FormMachineContext, FormMachineEvents } from '../types';
+/**
+ * Navigate to the next step
+ */
+export declare const navigateToNextStep: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Navigate to the previous step
+ */
+export declare const navigateToPreviousStep: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Navigate to a specific step by ID
+ */
+export declare const navigateToStep: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Navigate to a specific step by pending navigation
+ */
+export declare const navigateToStepFromPending: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Set pending navigation for next step
+ */
+export declare const setPendingNextNavigation: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Set pending navigation for previous step
+ */
+export declare const setPendingPreviousNavigation: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Set pending navigation for specific step
+ */
+export declare const setPendingStepNavigation: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Set pending navigation based on event
+ */
+export declare const setPendingNavigationFromEvent: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Clear pending navigation and allow navigation
+ */
+export declare const clearPendingNavigation: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Clear pending navigation and block navigation
+ */
+export declare const clearPendingNavigationAndBlock: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Reset form to initial state
+ */
+export declare const resetForm: import('xstate').ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Execute pending navigation by sending appropriate event
+ */
+export declare const executePendingNavigation: ({ context, self, }: ActionArgs<FormMachineContext, FormMachineEvents, FormMachineEvents>) => void;

package/features/state-management/machines/actions/saveActions.d.ts

@@ -0,0 +1,38 @@
+import { ActionArgs } from 'xstate';
+import { FormMachineContext, FormMachineEvents } from '../types';
+/**
+ * Start save process
+ */
+export declare const startSave: import('xstate').ActionFunction<FormMachineContext, FormMachineEvents, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Mark save dialog as shown
+ */
+export declare const markSaveDialogShown: import('xstate').ActionFunction<FormMachineContext, FormMachineEvents, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Create execution plan for save context
+ */
+export declare const createSaveExecutionPlan: import('xstate').ActionFunction<FormMachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Execute save actions from plan
+ */
+export declare const executeSaveActions: ({ context, self, }: ActionArgs<FormMachineContext, FormMachineEvents, FormMachineEvents>) => void;
+/**
+ * Complete save verification
+ */
+export declare const completeSaveVerification: import('xstate').ActionFunction<FormMachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Cancel save verification
+ */
+export declare const cancelSaveVerification: import('xstate').ActionFunction<FormMachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Complete save process and reset state
+ */
+export declare const completeSave: import('xstate').ActionFunction<FormMachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Check if all verifications are complete and send completion event
+ */
+export declare const checkSaveVerificationCompletion: ({ context, self, }: ActionArgs<FormMachineContext, FormMachineEvents, FormMachineEvents>) => void;
+/**
+ * Execute pending navigation after save completion
+ */
+export declare const executePendingNavigationAfterSave: ({ context, self, }: ActionArgs<FormMachineContext, FormMachineEvents, FormMachineEvents>) => void;

package/features/state-management/machines/actions/validationActions.d.ts

@@ -0,0 +1,68 @@
+import { ActionFunction } from 'xstate';
+import { FormMachineContext, FormMachineEvents } from '../types';
+/**
+ * Set form data for a specific field (optimized to reduce object spreading)
+ */
+export declare const setFormData: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Set field state for a component (optimized to reduce deep object spreading)
+ */
+export declare const setFieldState: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Mark field as touched during validation (optimized to avoid unnecessary updates)
+ */
+export declare const markFieldTouched: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Set form validation errors
+ */
+export declare const setFormErrors: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Set submission state
+ */
+export declare const setSubmittingTrue: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+export declare const setSubmittingFalse: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Set form submission errors
+ */
+export declare const setSubmissionError: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Start section editing by creating backup (optimized backup creation)
+ */
+export declare const startSectionEdit: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Cancel section editing by restoring from backup (optimized restoration)
+ */
+export declare const cancelSectionEdit: ActionFunction<any, any, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Set field change validation warning
+ */
+export declare const setFieldValidationWarning: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Dismiss field validation warning
+ */
+export declare const dismissFieldValidationWarning: ActionFunction<any, any, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Start field verification process
+ */
+export declare const startFieldVerification: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Complete field verification process
+ */
+export declare const completeFieldVerification: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Clear field changes and validation state
+ */
+export declare const clearFieldChanges: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Update form validity based on current step
+ */
+export declare const updateFormValidity: ActionFunction<import('xstate').MachineContext, import('xstate').AnyEventObject, import('xstate').EventObject, import('xstate').NonReducibleUnknown, import('xstate').ProvidedActor, never, never, never, never>;
+/**
+ * Reset TanStack Form dirty state for a specific field
+ * This action is called via event to reset TanStack Form's field meta state
+ */
+export declare const resetFieldTanStackState: ({ context, event, self, }: {
+    context: FormMachineContext;
+    event: FormMachineEvents;
+    self: any;
+}) => void;

package/features/state-management/machines/componentTriggerEngine.d.ts

@@ -0,0 +1,90 @@
+import { ComponentAction, ComponentTrigger, FormWizardConfig, TriggerContext } from '../../../../../core/src/index.ts';
+import { FormMachineContext } from './types';
+export interface TriggerEvaluationContext {
+    componentId: string;
+    currentValue: unknown;
+    originalValue: unknown;
+    eventType: "valueChange" | "focus" | "blur" | "navigationAttempt";
+    triggerContext: TriggerContext;
+    formData: Record<string, unknown>;
+    formContext: FormMachineContext;
+}
+export interface TriggerExecution {
+    trigger: ComponentTrigger;
+    componentId: string;
+    context: TriggerContext;
+    actions: ComponentAction[];
+    timestamp: number;
+}
+export interface ContextExecutionPlan {
+    context: TriggerContext;
+    executions: TriggerExecution[];
+    totalActions: number;
+    requiresUserInteraction: boolean;
+    timestamp?: number;
+}
+/**
+ * Create execution plan for a specific trigger context (optimized with caching)
+ */
+export declare function createExecutionPlan(config: FormWizardConfig, context: TriggerContext, stepIndex: number, formContext: FormMachineContext): ContextExecutionPlan;
+/**
+ * Determine trigger context based on event type and form state
+ */
+export declare function determineTriggerContext(eventType: string, _formState?: unknown): TriggerContext;
+/**
+ * Evaluate all triggers for a component and return which ones should fire
+ */
+export declare function evaluateComponentTriggers(config: FormWizardConfig, context: TriggerEvaluationContext): {
+    trigger: ComponentTrigger;
+    shouldFire: boolean;
+}[];
+/**
+ * Find all triggers for a specific component (optimized with cache)
+ */
+export declare function findComponentTriggers(config: FormWizardConfig, componentId: string): ComponentTrigger[];
+/**
+ * Find all actions for a specific component (optimized with cache)
+ */
+export declare function findComponentActions(config: FormWizardConfig, componentId: string): ComponentAction[];
+/**
+ * Get triggers that are associated with specific actions
+ */
+export declare function getTriggersForAction(config: FormWizardConfig, componentId: string, _actionId: string): ComponentTrigger[];
+/**
+ * Check if a component has any triggers configured
+ */
+export declare function hasComponentTriggers(config: FormWizardConfig, componentId: string): boolean;
+/**
+ * Check if a component has any actions configured
+ */
+export declare function hasComponentActions(config: FormWizardConfig, componentId: string): boolean;
+/**
+ * Find components with dirty triggers that should execute in a specific context
+ * Used for navigation evaluation to check if triggers should be executed before allowing navigation
+ */
+export declare function findDirtyComponentsWithTriggers(config: FormWizardConfig, currentStepIndex: number, formContext: FormMachineContext, triggerContext?: TriggerContext): Array<{
+    componentId: string;
+    trigger: ComponentTrigger;
+    actions: ComponentAction[];
+}>;
+/**
+ * Find components with dirty triggers for navigation contexts
+ * This is a convenience method for step navigation scenarios
+ */
+export declare function findDirtyComponentsForNavigation(config: FormWizardConfig, currentStepIndex: number, formContext: FormMachineContext, navigationType?: "step" | "section"): {
+    componentId: string;
+    trigger: ComponentTrigger;
+    actions: ComponentAction[];
+}[];
+export declare const ComponentTriggerEngine: {
+    createExecutionPlan: typeof createExecutionPlan;
+    determineTriggerContext: typeof determineTriggerContext;
+    evaluateComponentTriggers: typeof evaluateComponentTriggers;
+    findComponentTriggers: typeof findComponentTriggers;
+    findComponentActions: typeof findComponentActions;
+    getTriggersForAction: typeof getTriggersForAction;
+    hasComponentTriggers: typeof hasComponentTriggers;
+    hasComponentActions: typeof hasComponentActions;
+    findDirtyComponentsWithTriggers: typeof findDirtyComponentsWithTriggers;
+    findDirtyComponentsForNavigation: typeof findDirtyComponentsForNavigation;
+};

package/features/state-management/machines/formMachine.d.ts

@@ -0,0 +1,216 @@
+import { DialogConfig } from '../../../../../core/src/index.ts';
+import { FormFieldValue, FormMachineContext } from './types';
+export declare const formMachine: import('xstate').StateMachine<FormMachineContext, {
+    type: "SET_DATA";
+    key: string;
+    value: FormFieldValue;
+} | {
+    type: "SET_FIELD_STATE";
+    componentId: string;
+    state: Partial<FormMachineContext["fieldStates"][string]>;
+} | {
+    type: "VALIDATE_FIELD";
+    componentId: string;
+} | {
+    type: "VALIDATE_SECTION";
+    sectionId: string;
+} | {
+    type: "VALIDATE_STEP";
+    stepId: string;
+} | {
+    type: "VALIDATE_FORM";
+} | {
+    type: "START_SECTION_EDIT";
+    sectionId: string;
+    componentIds: string[];
+} | {
+    type: "CANCEL_SECTION_EDIT";
+    sectionId: string;
+} | {
+    type: "NEXT";
+} | {
+    type: "PREVIOUS";
+} | {
+    type: "GO_TO_STEP";
+    stepId: string;
+} | {
+    type: "REQUEST_NAVIGATION";
+    navigationType: "next" | "previous" | "step";
+    stepId?: string;
+} | {
+    type: "SUBMIT";
+} | {
+    type: "SUBMIT_SUCCESS";
+} | {
+    type: "SUBMIT_ERROR";
+    error: Error;
+} | {
+    type: "RESET";
+} | {
+    type: "EXECUTE_ACTIONS";
+    trigger: import('../../../../../core/src/index.ts').ActionTrigger;
+} | {
+    type: "EXECUTE_TRIGGER";
+    trigger: import('../../../../../core/src/index.ts').ActionTrigger;
+} | {
+    type: "ACTION_START";
+    actionId: string;
+} | {
+    type: "ACTION_SUCCESS";
+    actionId: string;
+    result: unknown;
+} | {
+    type: "ACTION_ERROR";
+    actionId: string;
+    error: Error;
+} | {
+    type: "ACTIONS_COMPLETED";
+    results: Record<string, unknown>;
+} | {
+    type: "SHOW_ACTION_DIALOG";
+    dialogConfig: DialogConfig;
+} | {
+    type: "HIDE_ACTION_DIALOG";
+} | {
+    type: "DIALOG_BUTTON_CLICK";
+    buttonAction: string;
+} | {
+    type: "FIELD_CHANGED";
+    fieldId: string;
+    oldValue: unknown;
+    newValue: unknown;
+} | {
+    type: "TRIGGER_FIELD_WARNING";
+    fieldId: string;
+    warning: import('../../../../../core/src/index.ts').FieldWarning;
+} | {
+    type: "DISMISS_FIELD_WARNING";
+    fieldId: string;
+    warningId?: string;
+} | {
+    type: "SHOW_FIELD_WARNING";
+    fieldId: string;
+    warningId: string;
+    message: string;
+    warningType?: "warning" | "error" | "info";
+} | {
+    type: "START_FIELD_VERIFICATION";
+    fieldId: string;
+    config: import('../../../../../core/src/index.ts').VerificationConfig;
+} | {
+    type: "FIELD_VERIFICATION_COMPLETE";
+    fieldId: string;
+    result: unknown;
+    success: boolean;
+} | {
+    type: "CLEAR_FIELD_CHANGES";
+    fieldId?: string;
+} | {
+    type: "EVALUATE_COMPONENT_TRIGGERS";
+    componentId: string;
+    eventType: "valueChange" | "focus" | "blur";
+    value?: unknown;
+} | {
+    type: "TRIGGER_COMPONENT_ACTION";
+    componentId: string;
+    triggerId: string;
+    actionId: string;
+    eventType?: "valueChange" | "focus" | "blur" | "navigationAttempt" | "sectionSave";
+} | {
+    type: "COMPONENT_ACTION_START";
+    componentId: string;
+    actionId: string;
+} | {
+    type: "COMPONENT_ACTION_COMPLETE";
+    componentId: string;
+    actionId: string;
+    result?: unknown;
+} | {
+    type: "COMPONENT_ACTION_FAILED";
+    componentId: string;
+    actionId: string;
+    error: Error;
+} | {
+    type: "SHOW_COMPONENT_ALERT";
+    componentId: string;
+    alert: import('./types').ComponentAlert;
+} | {
+    type: "DISMISS_COMPONENT_ALERT";
+    componentId: string;
+    alertId?: string;
+} | {
+    type: "CLEAR_COMPONENT_ALERT";
+    componentId: string;
+} | {
+    type: "SET_COMPONENT_ORIGINAL_VALUE";
+    componentId: string;
+    value: unknown;
+    source?: "initialized" | "api_populated" | "user_reset" | "user_verified" | "edit_start";
+} | {
+    type: "MARK_COMPONENT_AS_POPULATED";
+    componentId: string;
+    value: unknown;
+} | {
+    type: "EXECUTE_CONTEXT_ACTION";
+    execution: import('./componentTriggerEngine').TriggerExecution;
+    action: import('../../../../../core/src/index.ts').ComponentAction;
+} | {
+    type: "CONTEXT_ACTION_COMPLETE";
+    componentId: string;
+    actionId: string;
+    result: unknown;
+} | {
+    type: "CONTEXT_ACTIONS_COMPLETE";
+    results?: Record<string, unknown>;
+} | {
+    type: "EXECUTE_CONTEXT_ACTIONS";
+    executionPlan: import('./componentTriggerEngine').ContextExecutionPlan;
+} | {
+    type: "EXECUTE_FIELD_CHANGE_ACTIONS";
+    executionPlan: import('./componentTriggerEngine').ContextExecutionPlan;
+    componentId: string;
+    eventType: string;
+    value: unknown;
+} | {
+    type: "SHOW_DIALOG";
+    dialog: DialogConfig;
+} | {
+    type: "TRIGGER_ACTIONS_COMPLETE";
+} | {
+    type: "DIALOG_VERIFIED";
+} | {
+    type: "DIALOG_CANCELLED";
+} | {
+    type: "RESET_FIELD_TANSTACK_STATE";
+    componentId: string;
+    form?: import('./types').MinimalFormApi;
+} | {
+    type: "UPDATE_COMPONENT_ORIGINAL_VALUE";
+    componentId: string;
+} | {
+    type: "COMPONENT_ACTION_ERROR";
+    componentId: string;
+    actionId: string;
+    error: Error;
+} | {
+    type: "START_SAVE";
+    initiator: "sectionButton" | "navigation";
+    sectionId: string;
+} | {
+    type: "SAVE_VALIDATION_SUCCESS";
+    sectionId: string;
+    executionPlan: import('./componentTriggerEngine').ContextExecutionPlan;
+} | {
+    type: "SAVE_VALIDATION_FAILED";
+    sectionId: string;
+    errors: Record<string, string[]>;
+} | {
+    type: "SAVE_DIALOG_SHOWN";
+    componentId: string;
+    actionId: string;
+    dialogId: string;
+} | {
+    type: "SAVE_ACTIONS_COMPLETE";
+    sectionId: string;
+    results: Record<string, unknown>;
+}, Record<string, import('xstate').AnyActorRef>, import('xstate').ProvidedActor, import('xstate').ParameterizedObject, import('xstate').ParameterizedObject, string, import('xstate').StateValue, string, Partial<FormMachineContext>, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, any>;

package/features/state-management/machines/guards/navigationGuards.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Check if navigation is allowed (fast property access)
+ */
+export declare const canNavigate: ({ context }: any) => any;
+/**
+ * Check if pending navigation is for next step
+ */
+export declare const isPendingNextNavigation: ({ context }: any) => boolean;
+/**
+ * Check if pending navigation is for previous step
+ */
+export declare const isPendingPreviousNavigation: ({ context }: any) => boolean;
+/**
+ * Check if pending navigation is for specific step
+ */
+export declare const isPendingStepNavigation: ({ context }: any) => boolean;
+/**
+ * Check if there are save triggers that need execution before next navigation (cached)
+ */
+export declare const hasSaveTriggersForNext: ({ context }: any) => boolean;
+/**
+ * Check if there are dirty components with triggers for next navigation (optimized with early returns)
+ */
+export declare const hasDirtyComponentsForNextNavigation: ({ context }: any) => boolean;
+/**
+ * Check if navigation should proceed normally without triggers (optimized with early returns)
+ */
+export declare const shouldProceedWithNormalNavigation: ({ context }: any) => boolean;
+/**
+ * Check if save context has actions to execute (cached)
+ */
+export declare const hasSaveContextActions: ({ context }: any) => boolean;

package/features/state-management/machines/guards/saveGuards.d.ts

@@ -0,0 +1,55 @@
+import { FormMachineContext } from '../types';
+/**
+ * Check if save validation passes and has actions to execute
+ */
+export declare const canExecuteSaveActions: ({ context, }: {
+    context: FormMachineContext;
+}) => boolean;
+/**
+ * Check if save is in progress
+ */
+export declare const isSaveInProgress: ({ context, }: {
+    context: FormMachineContext;
+}) => boolean;
+/**
+ * Check if there's a section being saved
+ */
+export declare const hasSavingSection: ({ context, }: {
+    context: FormMachineContext;
+}) => boolean;
+/**
+ * Check if save has validation errors
+ */
+export declare const hasSaveValidationErrors: ({ context, }: {
+    context: FormMachineContext;
+}) => boolean;
+/**
+ * Check if all save verifications are complete
+ */
+export declare const allSaveVerificationsComplete: ({ context, }: {
+    context: FormMachineContext;
+}) => boolean;
+/**
+ * Check if section mode is editable
+ */
+export declare const isSectionEditable: ({ context, }: {
+    context: FormMachineContext;
+}) => boolean;
+/**
+ * Check if save was initiated by navigation
+ */
+export declare const isSaveInitiatedByNavigation: ({ context, }: {
+    context: FormMachineContext;
+}) => boolean;
+/**
+ * Check if save execution plan exists and has actions
+ */
+export declare const hasSaveExecutionPlan: ({ context, }: {
+    context: FormMachineContext;
+}) => boolean | null;
+/**
+ * Check if save actions are completed
+ */
+export declare const areSaveActionsCompleted: ({ context, }: {
+    context: FormMachineContext;
+}) => boolean;

package/features/state-management/machines/guards/triggerGuards.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Check if there are dirty components with triggers for navigation (optimized with early returns)
+ */
+export declare const hasDirtyComponentsWithTriggers: ({ context }: any) => boolean;
+/**
+ * Check if component trigger actions need to be executed (optimized with early returns)
+ */
+export declare const needsComponentTriggerActions: ({ context }: any) => boolean;
+/**
+ * Check if all component trigger actions are completed (optimized with early returns)
+ */
+export declare const allComponentTriggerActionsCompleted: ({ context }: any) => boolean;
+/**
+ * Check if component has pending actions (optimized with early returns)
+ */
+export declare const componentHasPendingActions: ({ context, event }: any) => boolean;
+/**
+ * Check if trigger is waiting for user action (fast property access)
+ */
+export declare const isTriggerWaitingForAction: ({ context }: any) => boolean;
+/**
+ * Check if trigger execution is complete (optimized boolean check)
+ */
+export declare const isTriggerExecutionComplete: ({ context }: any) => boolean;

package/features/state-management/machines/helpers/triggerHelpers.d.ts

@@ -0,0 +1,14 @@
+import { ComponentAction, ComponentTrigger, FormWizardConfig } from '../../../../../../core/src/index.ts';
+import { FormMachineContext } from '../types';
+/**
+ * Helper function to find component triggers in the config (optimized with ComponentTriggerEngine cache)
+ */
+export declare function findComponentTriggers(config: FormWizardConfig, componentId: string): ComponentTrigger[];
+/**
+ * Helper function to find component actions in the config (optimized with ComponentTriggerEngine cache)
+ */
+export declare function findComponentActions(config: FormWizardConfig, componentId: string): ComponentAction[];
+/**
+ * Helper function to evaluate if a trigger condition is met (optimized with early returns)
+ */
+export declare function evaluateTriggerCondition(trigger: ComponentTrigger, componentId: string, value: unknown, eventType: "valueChange" | "focus" | "blur", context: FormMachineContext): boolean;

package/features/state-management/machines/index.d.ts

@@ -0,0 +1,4 @@
+export { ComponentTriggerEngine } from './componentTriggerEngine';
+export { formMachine } from './formMachine';
+export type { ComponentActionExecution, ComponentAlert, ComponentTriggerState, FormMachineContext as FormMachineContextType, FormMachineEvents, } from './types';
+export { FormMachineContext, useFormMachine, useFormMachineProvider, } from './useFormMachine';

package/features/state-management/machines/lazyLoading.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Lazy loading utilities for form machine modules
+ * Enables code splitting and reduced initial bundle size
+ */
+export declare const lazyImports: {
+    ComponentTriggerEngine: () => Promise<{
+        createExecutionPlan: typeof import('./componentTriggerEngine').createExecutionPlan;
+        determineTriggerContext: typeof import('./componentTriggerEngine').determineTriggerContext;
+        evaluateComponentTriggers: typeof import('./componentTriggerEngine').evaluateComponentTriggers;
+        findComponentTriggers: typeof import('./componentTriggerEngine').findComponentTriggers;
+        findComponentActions: typeof import('./componentTriggerEngine').findComponentActions;
+        getTriggersForAction: typeof import('./componentTriggerEngine').getTriggersForAction;
+        hasComponentTriggers: typeof import('./componentTriggerEngine').hasComponentTriggers;
+        hasComponentActions: typeof import('./componentTriggerEngine').hasComponentActions;
+        findDirtyComponentsWithTriggers: typeof import('./componentTriggerEngine').findDirtyComponentsWithTriggers;
+        findDirtyComponentsForNavigation: typeof import('./componentTriggerEngine').findDirtyComponentsForNavigation;
+    }>;
+    saveActions: () => Promise<typeof import("./actions/saveActions")>;
+    validationActions: () => Promise<typeof import("./actions/validationActions")>;
+    navigationGuards: () => Promise<typeof import("./guards/navigationGuards")>;
+    triggerGuards: () => Promise<typeof import("./guards/triggerGuards")>;
+    saveGuards: () => Promise<typeof import("./guards/saveGuards")>;
+};
+export declare const featureModules: {
+    advancedTriggers: Promise<any>;
+    complexValidation: Promise<any>;
+    saveFeatures: Promise<any>;
+};
+export declare const preloadCriticalModules: () => Promise<void>;
+export declare const isModuleLoaded: (moduleName: keyof typeof lazyImports) => boolean;
+export declare const bundleMonitor: {
+    trackModuleLoad: (moduleName: string, size?: number) => void;
+    trackBundleSize: () => void;
+};