@flowdrop/flowdrop 1.0.0

package/dist/stores/historyStore.svelte.js

@@ -0,0 +1,207 @@
+/**
+ * History Store for FlowDrop (Svelte 5 Runes)
+ *
+ * Provides reactive Svelte 5 rune-based bindings for the history service.
+ * Exposes undo/redo state and actions for the workflow editor.
+ *
+ * @module stores/historyStore
+ */
+import { historyService } from '../services/historyService.js';
+// =========================================================================
+// Reactive State (Runes)
+// =========================================================================
+/**
+ * Internal reactive state for history, powered by $state.
+ */
+let historyState = $state({
+    canUndo: false,
+    canRedo: false,
+    currentIndex: 0,
+    historyLength: 0,
+    isInTransaction: false
+});
+// Subscribe to history service changes and update the rune state.
+// The unsubscribe function is stored so it can be called via
+// cleanupHistorySubscription() when the store is torn down.
+const _unsubscribeHistoryService = historyService.subscribe((state) => {
+    historyState = state;
+});
+/**
+ * Clean up the historyService subscription created at module initialisation.
+ * Call this when tearing down the history store (e.g., in tests or on app
+ * unmount) to prevent memory leaks.
+ */
+export function cleanupHistorySubscription() {
+    _unsubscribeHistoryService();
+}
+// =========================================================================
+// Reactive Getters
+// =========================================================================
+/**
+ * Get the current history state snapshot.
+ *
+ * Use this for binding to UI elements like undo/redo buttons.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { getHistoryState } from "./historyStore.svelte.js";
+ *
+ *   const state = $derived(getHistoryState());
+ * </script>
+ *
+ * <button disabled={!state.canUndo} onclick={historyActions.undo}>
+ *   Undo
+ * </button>
+ * ```
+ */
+export function getHistoryState() {
+    return historyState;
+}
+/**
+ * Convenience getter for canUndo state.
+ *
+ * @returns Whether undo is currently available
+ */
+export function getCanUndo() {
+    return historyState.canUndo;
+}
+/**
+ * Convenience getter for canRedo state.
+ *
+ * @returns Whether redo is currently available
+ */
+export function getCanRedo() {
+    return historyState.canRedo;
+}
+// =========================================================================
+// History Actions
+// =========================================================================
+/**
+ * Callback for when workflow state is restored from history
+ *
+ * Set this to handle the restored workflow state (e.g., update the workflow store)
+ */
+let onRestoreCallback = null;
+/**
+ * Set the callback for restoring workflow state
+ *
+ * This callback is invoked when undo/redo operations return a workflow.
+ * Use this to update the workflow store or other state management.
+ *
+ * @param callback - Function to call with restored workflow
+ */
+export function setOnRestoreCallback(callback) {
+    onRestoreCallback = callback;
+}
+/**
+ * History actions for undo/redo operations
+ *
+ * Use these functions to interact with the history service.
+ * They handle the coordination between history and workflow state.
+ */
+export const historyActions = {
+    /**
+     * Initialize history with the current workflow
+     *
+     * Call this when loading a new workflow to reset history.
+     *
+     * @param workflow - The initial workflow state
+     */
+    initialize: (workflow) => {
+        historyService.initialize(workflow);
+    },
+    /**
+     * Push the current state to history before making changes
+     *
+     * Call this BEFORE modifying the workflow to capture the "before" state.
+     *
+     * @param workflow - The current workflow state (before changes)
+     * @param options - Options for this history entry
+     */
+    pushState: (workflow, options) => {
+        historyService.push(workflow, options);
+    },
+    /**
+     * Undo the last change
+     *
+     * Restores the previous workflow state and invokes the restore callback.
+     *
+     * @returns true if undo was successful, false if at beginning of history
+     */
+    undo: () => {
+        const previousState = historyService.undo();
+        if (previousState && onRestoreCallback) {
+            onRestoreCallback(previousState);
+            return true;
+        }
+        return previousState !== null;
+    },
+    /**
+     * Redo the last undone change
+     *
+     * Restores the next workflow state and invokes the restore callback.
+     *
+     * @returns true if redo was successful, false if at end of history
+     */
+    redo: () => {
+        const nextState = historyService.redo();
+        if (nextState && onRestoreCallback) {
+            onRestoreCallback(nextState);
+            return true;
+        }
+        return false;
+    },
+    /**
+     * Start a transaction for grouping multiple changes
+     *
+     * All changes during a transaction are combined into a single undo entry.
+     *
+     * @param workflow - The current workflow state (before changes)
+     * @param description - Description for the combined change
+     */
+    startTransaction: (workflow, description) => {
+        historyService.startTransaction(workflow, description);
+    },
+    /**
+     * Commit the current transaction
+     */
+    commitTransaction: () => {
+        historyService.commitTransaction();
+    },
+    /**
+     * Cancel the current transaction without committing
+     */
+    cancelTransaction: () => {
+        historyService.cancelTransaction();
+    },
+    /**
+     * Clear all history
+     *
+     * @param currentWorkflow - If provided, keeps this as the initial state
+     */
+    clear: (currentWorkflow) => {
+        historyService.clear(currentWorkflow);
+    },
+    /**
+     * Check if undo is available
+     */
+    canUndo: () => {
+        return historyService.canUndo();
+    },
+    /**
+     * Check if redo is available
+     */
+    canRedo: () => {
+        return historyService.canRedo();
+    },
+    /**
+     * Get the current history state synchronously
+     *
+     * @returns The current history state
+     */
+    getState: () => {
+        return historyState;
+    }
+};
+export { HistoryService, historyService } from '../services/historyService.js';

package/dist/stores/interruptStore.svelte.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Interrupt Store (Svelte 5 Runes)
+ *
+ * Rune-based reactive state for managing interrupt state using a lightweight state machine.
+ * Ensures valid state transitions and prevents deadlocks.
+ *
+ * @module stores/interruptStore
+ */
+import { SvelteMap } from 'svelte/reactivity';
+import type { Interrupt } from '../types/interrupt.js';
+import { type InterruptState, type TransitionResult } from '../types/interruptState.js';
+/**
+ * Extended interrupt with state machine
+ */
+export interface InterruptWithState extends Interrupt {
+    /** State machine state for UI interaction tracking */
+    machineState: InterruptState;
+}
+/**
+ * Get the reactive interrupts map.
+ * Use this in components within $derived() for reactivity.
+ */
+export declare function getInterruptsMap(): SvelteMap<string, InterruptWithState>;
+/**
+ * Get pending interrupt IDs (interrupts not in a terminal state)
+ */
+export declare function getPendingInterruptIds(): string[];
+/**
+ * Get pending interrupts array (interrupts not in a terminal state)
+ */
+export declare function getPendingInterrupts(): InterruptWithState[];
+/**
+ * Get count of pending interrupts
+ */
+export declare function getPendingInterruptCount(): number;
+/**
+ * Get resolved interrupts array
+ */
+export declare function getResolvedInterrupts(): InterruptWithState[];
+/**
+ * Check if any interrupt is currently submitting
+ */
+export declare function getIsAnySubmitting(): boolean;
+/**
+ * Interrupt store actions for modifying state
+ */
+export declare const interruptActions: {
+    /**
+     * Add or update an interrupt in the store
+     *
+     * @param interrupt - The interrupt to add or update
+     */
+    addInterrupt: (interrupt: Interrupt) => void;
+    /**
+     * Add multiple interrupts to the store
+     *
+     * @param interruptList - Array of interrupts to add
+     */
+    addInterrupts: (interruptList: Interrupt[]) => void;
+    /**
+     * Start submitting an interrupt (user clicked submit)
+     *
+     * @param interruptId - The interrupt ID
+     * @param value - The value being submitted
+     * @returns Transition result
+     */
+    startSubmit: (interruptId: string, value: unknown) => TransitionResult;
+    /**
+     * Start cancelling an interrupt (user clicked cancel)
+     *
+     * @param interruptId - The interrupt ID
+     * @returns Transition result
+     */
+    startCancel: (interruptId: string) => TransitionResult;
+    /**
+     * Mark submission as successful
+     *
+     * @param interruptId - The interrupt ID
+     * @returns Transition result
+     */
+    submitSuccess: (interruptId: string) => TransitionResult;
+    /**
+     * Mark submission as failed
+     *
+     * @param interruptId - The interrupt ID
+     * @param error - Error message
+     * @returns Transition result
+     */
+    submitFailure: (interruptId: string, error: string) => TransitionResult;
+    /**
+     * Retry a failed submission
+     *
+     * @param interruptId - The interrupt ID
+     * @returns Transition result
+     */
+    retry: (interruptId: string) => TransitionResult;
+    /**
+     * Reset an interrupt to idle state
+     *
+     * @param interruptId - The interrupt ID
+     * @returns Transition result
+     */
+    resetInterrupt: (interruptId: string) => TransitionResult;
+    /**
+     * Mark an interrupt as resolved with the user's response
+     *
+     * @param interruptId - The interrupt ID
+     * @param value - The resolved value
+     */
+    resolveInterrupt: (interruptId: string, value: unknown) => void;
+    /**
+     * Mark an interrupt as cancelled
+     *
+     * @param interruptId - The interrupt ID
+     */
+    cancelInterrupt: (interruptId: string) => void;
+    /**
+     * Remove an interrupt from the store
+     *
+     * @param interruptId - The interrupt ID to remove
+     */
+    removeInterrupt: (interruptId: string) => void;
+    /**
+     * Clear all interrupts for a specific session
+     *
+     * @param sessionId - The session ID to clear interrupts for
+     */
+    clearSessionInterrupts: (sessionId: string) => void;
+    /**
+     * Alias for clearSessionInterrupts
+     */
+    clearInterrupts: () => void;
+    /**
+     * Reset all interrupt state
+     */
+    reset: () => void;
+};
+/**
+ * Get an interrupt by ID
+ *
+ * @param interruptId - The interrupt ID
+ * @returns The interrupt or undefined
+ */
+export declare function getInterrupt(interruptId: string): InterruptWithState | undefined;
+/**
+ * Check if an interrupt is pending (not resolved or cancelled)
+ *
+ * @param interruptId - The interrupt ID
+ * @returns True if the interrupt exists and is pending
+ */
+export declare function isInterruptPending(interruptId: string): boolean;
+/**
+ * Check if an interrupt is currently submitting
+ *
+ * @param interruptId - The interrupt ID
+ * @returns True if the interrupt is being submitted
+ */
+export declare function isInterruptSubmitting(interruptId: string): boolean;
+/**
+ * Get the error for an interrupt
+ *
+ * @param interruptId - The interrupt ID
+ * @returns The error message or undefined
+ */
+export declare function getInterruptError(interruptId: string): string | undefined;
+/**
+ * Get an interrupt by its associated message ID
+ *
+ * @param messageId - The message ID
+ * @returns The interrupt or undefined
+ */
+export declare function getInterruptByMessageId(messageId: string): InterruptWithState | undefined;
+/**
+ * Check if an interrupt has an error
+ *
+ * @param interruptId - The interrupt ID
+ * @returns True if the interrupt has an error
+ */
+export declare function interruptHasError(interruptId: string): boolean;