@d34dman/flowdrop 0.0.37 → 0.0.39

package/dist/types/interruptState.js

@@ -0,0 +1,308 @@
+/**
+ * Interrupt State Machine
+ *
+ * Lightweight state machine pattern for interrupt handling.
+ * Ensures valid state transitions and prevents deadlocks.
+ *
+ * State Diagram:
+ * ```
+ *                    ┌─────────────┐
+ *                    │    idle     │
+ *                    └──────┬──────┘
+ *                           │
+ *            ┌──────────────┼──────────────┐
+ *            │ submit       │ cancel       │
+ *            ▼              │              ▼
+ *     ┌─────────────┐       │       ┌─────────────┐
+ *     │ submitting  │       │       │  cancelled  │
+ *     └──────┬──────┘       │       └─────────────┘
+ *            │              │
+ *     ┌──────┴──────┐       │
+ *     │             │       │
+ *     ▼ success     ▼ fail  │
+ * ┌─────────┐  ┌─────────┐  │
+ * │resolved │  │  error  │──┘ cancel
+ * └─────────┘  └────┬────┘
+ *                   │ retry
+ *                   ▼
+ *              ┌─────────────┐
+ *              │ submitting  │
+ *              └─────────────┘
+ * ```
+ *
+ * @module types/interruptState
+ */
+/**
+ * Initial idle state
+ */
+export const initialState = { status: 'idle' };
+/**
+ * Transition function for the interrupt state machine
+ *
+ * @param state - Current state
+ * @param action - Action to apply
+ * @returns New state after transition
+ *
+ * @example
+ * ```typescript
+ * let state = initialState;
+ *
+ * // User submits
+ * const result1 = transition(state, { type: "SUBMIT", value: true });
+ * if (result1.valid) state = result1.state;
+ *
+ * // API succeeds
+ * const result2 = transition(state, { type: "SUCCESS" });
+ * if (result2.valid) state = result2.state;
+ * ```
+ */
+export function transition(state, action) {
+    switch (state.status) {
+        case 'idle':
+            return transitionFromIdle(state, action);
+        case 'submitting':
+            return transitionFromSubmitting(state, action);
+        case 'error':
+            return transitionFromError(state, action);
+        case 'resolved':
+            return transitionFromResolved(state, action);
+        case 'cancelled':
+            return transitionFromCancelled(state, action);
+        default:
+            return {
+                state,
+                valid: false,
+                error: `Unknown state: ${state.status}`
+            };
+    }
+}
+/**
+ * Transitions from idle state
+ */
+function transitionFromIdle(_state, action) {
+    switch (action.type) {
+        case 'SUBMIT':
+            return {
+                state: {
+                    status: 'submitting',
+                    pendingValue: action.value,
+                    isCancelAction: false
+                },
+                valid: true
+            };
+        case 'CANCEL':
+            return {
+                state: {
+                    status: 'submitting',
+                    pendingValue: undefined,
+                    isCancelAction: true
+                },
+                valid: true
+            };
+        case 'RESET':
+            return { state: initialState, valid: true };
+        default:
+            return {
+                state: _state,
+                valid: false,
+                error: `Cannot ${action.type} from idle state`
+            };
+    }
+}
+/**
+ * Transitions from submitting state
+ */
+function transitionFromSubmitting(state, action) {
+    switch (action.type) {
+        case 'SUCCESS':
+            if (state.isCancelAction) {
+                return {
+                    state: {
+                        status: 'cancelled',
+                        cancelledAt: new Date().toISOString()
+                    },
+                    valid: true
+                };
+            }
+            return {
+                state: {
+                    status: 'resolved',
+                    value: state.pendingValue,
+                    resolvedAt: new Date().toISOString()
+                },
+                valid: true
+            };
+        case 'FAILURE':
+            return {
+                state: {
+                    status: 'error',
+                    error: action.error,
+                    failedValue: state.pendingValue,
+                    wasCancelAction: state.isCancelAction
+                },
+                valid: true
+            };
+        case 'RESET':
+            return { state: initialState, valid: true };
+        // Prevent double-submit
+        case 'SUBMIT':
+        case 'CANCEL':
+            return {
+                state,
+                valid: false,
+                error: 'Cannot submit/cancel while already submitting'
+            };
+        default:
+            return {
+                state,
+                valid: false,
+                error: `Cannot ${action.type} from submitting state`
+            };
+    }
+}
+/**
+ * Transitions from error state
+ */
+function transitionFromError(state, action) {
+    switch (action.type) {
+        case 'RETRY':
+            return {
+                state: {
+                    status: 'submitting',
+                    pendingValue: state.failedValue,
+                    isCancelAction: state.wasCancelAction
+                },
+                valid: true
+            };
+        case 'SUBMIT':
+            // Allow resubmitting with new value
+            return {
+                state: {
+                    status: 'submitting',
+                    pendingValue: action.value,
+                    isCancelAction: false
+                },
+                valid: true
+            };
+        case 'CANCEL':
+            return {
+                state: {
+                    status: 'submitting',
+                    pendingValue: undefined,
+                    isCancelAction: true
+                },
+                valid: true
+            };
+        case 'RESET':
+            return { state: initialState, valid: true };
+        default:
+            return {
+                state,
+                valid: false,
+                error: `Cannot ${action.type} from error state`
+            };
+    }
+}
+/**
+ * Transitions from resolved state (terminal - only reset allowed)
+ */
+function transitionFromResolved(state, action) {
+    if (action.type === 'RESET') {
+        return { state: initialState, valid: true };
+    }
+    return {
+        state,
+        valid: false,
+        error: `Cannot ${action.type} from resolved state - interrupt already completed`
+    };
+}
+/**
+ * Transitions from cancelled state (terminal - only reset allowed)
+ */
+function transitionFromCancelled(state, action) {
+    if (action.type === 'RESET') {
+        return { state: initialState, valid: true };
+    }
+    return {
+        state,
+        valid: false,
+        error: `Cannot ${action.type} from cancelled state - interrupt already cancelled`
+    };
+}
+// =========================================================================
+// Helper Functions
+// =========================================================================
+/**
+ * Check if the interrupt is in a terminal state (resolved or cancelled)
+ *
+ * @param state - The interrupt state
+ * @returns True if the interrupt is finished
+ */
+export function isTerminalState(state) {
+    return state.status === 'resolved' || state.status === 'cancelled';
+}
+/**
+ * Check if the interrupt is currently submitting
+ *
+ * @param state - The interrupt state
+ * @returns True if submitting
+ */
+export function isSubmitting(state) {
+    return state.status === 'submitting';
+}
+/**
+ * Check if the interrupt has an error
+ *
+ * @param state - The interrupt state
+ * @returns True if in error state
+ */
+export function hasError(state) {
+    return state.status === 'error';
+}
+/**
+ * Check if the interrupt can accept user input
+ *
+ * @param state - The interrupt state
+ * @returns True if idle or error (can submit)
+ */
+export function canSubmit(state) {
+    return state.status === 'idle' || state.status === 'error';
+}
+/**
+ * Get the error message if in error state
+ *
+ * @param state - The interrupt state
+ * @returns Error message or undefined
+ */
+export function getErrorMessage(state) {
+    return state.status === 'error' ? state.error : undefined;
+}
+/**
+ * Get the resolved value if in resolved state
+ *
+ * @param state - The interrupt state
+ * @returns Resolved value or undefined
+ */
+export function getResolvedValue(state) {
+    return state.status === 'resolved' ? state.value : undefined;
+}
+/**
+ * Map InterruptState status to legacy InterruptStatus for backward compatibility
+ *
+ * @param state - The interrupt state
+ * @returns Legacy status string
+ */
+export function toLegacyStatus(state) {
+    switch (state.status) {
+        case 'idle':
+        case 'submitting':
+        case 'error':
+            return 'pending';
+        case 'resolved':
+            return 'resolved';
+        case 'cancelled':
+            return 'cancelled';
+        default:
+            return 'pending';
+    }
+}

package/dist/utils/colors.js

@@ -8,6 +8,7 @@ import { getPortCompatibilityChecker } from './connections.js';
  * Category color mapping to reference tokens (CSS variables)
  */
 export const CATEGORY_COLOR_TOKENS = {
+    triggers: 'var(--color-ref-cyan-500)',
     inputs: 'var(--color-ref-emerald-500)',
     outputs: 'var(--color-ref-blue-600)',
     prompts: 'var(--color-ref-amber-500)',

package/dist/utils/connections.js

@@ -5,7 +5,7 @@
  * Loopback port name constant
  * This is the standard input port name used for loop iteration triggers
  */
-const LOOPBACK_PORT_NAME = "loop_back";
+const LOOPBACK_PORT_NAME = 'loop_back';
 /**
  * Determines if an edge is a loopback edge.
  * Loopback edges target the special `loop_back` input port on ForEach nodes.
@@ -21,7 +21,7 @@ const LOOPBACK_PORT_NAME = "loop_back";
  * ```
  */
 export function isLoopbackEdge(edge) {
-    const targetHandle = edge.targetHandle ?? "";
+    const targetHandle = edge.targetHandle ?? '';
     return targetHandle.includes(`-input-${LOOPBACK_PORT_NAME}`);
 }
 /**

package/dist/utils/icons.js

@@ -80,6 +80,7 @@ export const DEFAULT_ICONS = {
  * Category-specific icons matching Langflow's visual style
  */
 export const CATEGORY_ICONS = {
+    triggers: 'mdi:lightning-bolt',
     inputs: 'mdi:arrow-down-circle',
     outputs: 'mdi:arrow-up-circle',
     prompts: 'mdi:message-text',

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@d34dman/flowdrop",
 	"license": "MIT",
 	"private": false,
-	"version": "0.0.37",
+	"version": "0.0.39",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",