@flowdrop/flowdrop 1.0.0

package/dist/utils/config.js

@@ -0,0 +1,226 @@
+/**
+ * Configuration utilities for FlowDrop Editor
+ */
+import { createEndpointConfig } from '../config/endpoints.js';
+/**
+ * Create default editor features configuration
+ */
+export function createDefaultFeatures() {
+    return {
+        dragAndDrop: true,
+        nodeEditing: true,
+        execution: true,
+        saveWorkflow: true,
+        loadWorkflow: true,
+        undoRedo: true,
+        nodeSearch: true,
+        nodeCategories: true,
+        nodeValidation: true,
+        collaboration: false,
+        templates: false,
+        importExport: false
+    };
+}
+/**
+ * Create default UI configuration
+ */
+export function createDefaultUIConfig() {
+    return {
+        showSidebar: true,
+        showToolbar: true,
+        showMinimap: true,
+        showGrid: true,
+        gridSize: 20,
+        nodeSpacing: 100,
+        canvasPadding: 50,
+        navbarHeight: 60, // Default navbar height in pixels (current demo height)
+        zoom: {
+            min: 0.1,
+            max: 2,
+            default: 1
+        },
+        colors: {
+            primary: '#3b82f6',
+            secondary: '#64748b',
+            accent: '#f59e0b',
+            background: '#ffffff',
+            text: '#1f2937'
+        },
+        cssClasses: {}
+    };
+}
+/**
+ * Create default API configuration
+ */
+export function createDefaultAPIConfig() {
+    return {
+        endpoints: createEndpointConfig('/api/flowdrop'),
+        timeout: 30000,
+        retry: {
+            enabled: true,
+            maxAttempts: 3,
+            delay: 1000
+        },
+        auth: {
+            type: 'none'
+        },
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    };
+}
+/**
+ * Create default execution configuration
+ */
+export function createDefaultExecutionConfig() {
+    return {
+        realTimeUpdates: true,
+        timeout: 300,
+        maxConcurrent: 5,
+        showProgress: true,
+        autoSaveState: true,
+        caching: {
+            enabled: true,
+            ttl: 3600
+        }
+    };
+}
+/**
+ * Create default storage configuration
+ */
+export function createDefaultStorageConfig() {
+    return {
+        type: 'api',
+        autoSaveInterval: 5000,
+        maxUndoSteps: 50,
+        keyPrefix: 'flowdrop_'
+    };
+}
+/**
+ * Create default workflow editor configuration
+ */
+export function createDefaultConfig(endpointConfig) {
+    return {
+        theme: 'auto',
+        features: createDefaultFeatures(),
+        ui: createDefaultUIConfig(),
+        api: {
+            ...createDefaultAPIConfig(),
+            endpoints: endpointConfig || createEndpointConfig('/api/flowdrop')
+        },
+        ports: {
+            dataTypes: [],
+            compatibilityRules: [],
+            defaultDataType: 'mixed'
+        },
+        execution: createDefaultExecutionConfig(),
+        storage: createDefaultStorageConfig()
+    };
+}
+/**
+ * Merge configuration with defaults
+ */
+export function mergeConfig(userConfig, defaultConfig) {
+    return {
+        ...defaultConfig,
+        ...userConfig,
+        features: {
+            ...defaultConfig.features,
+            ...userConfig.features
+        },
+        ui: {
+            ...defaultConfig.ui,
+            ...userConfig.ui,
+            zoom: {
+                ...defaultConfig.ui.zoom,
+                ...userConfig.ui?.zoom
+            },
+            colors: {
+                ...defaultConfig.ui.colors,
+                ...userConfig.ui?.colors
+            },
+            cssClasses: {
+                ...defaultConfig.ui.cssClasses,
+                ...userConfig.ui?.cssClasses
+            }
+        },
+        api: {
+            ...defaultConfig.api,
+            ...userConfig.api,
+            retry: {
+                ...defaultConfig.api.retry,
+                ...userConfig.api?.retry
+            },
+            auth: {
+                ...defaultConfig.api.auth,
+                ...userConfig.api?.auth
+            },
+            headers: {
+                ...defaultConfig.api.headers,
+                ...userConfig.api?.headers
+            },
+            endpoints: {
+                ...defaultConfig.api.endpoints,
+                ...userConfig.api?.endpoints
+            }
+        },
+        execution: {
+            ...defaultConfig.execution,
+            ...userConfig.execution,
+            caching: {
+                ...defaultConfig.execution.caching,
+                ...userConfig.execution?.caching
+            }
+        },
+        storage: {
+            ...defaultConfig.storage,
+            ...userConfig.storage
+        }
+    };
+}
+/**
+ * Validate configuration
+ */
+export function validateConfig(config) {
+    const errors = [];
+    if (!config.features) {
+        errors.push('features configuration is required');
+    }
+    if (!config.ui) {
+        errors.push('ui configuration is required');
+    }
+    if (!config.api) {
+        errors.push('api configuration is required');
+    }
+    if (!config.execution) {
+        errors.push('execution configuration is required');
+    }
+    if (!config.storage) {
+        errors.push('storage configuration is required');
+    }
+    // Validate API configuration
+    if (config.api.timeout <= 0) {
+        errors.push('API timeout must be greater than 0');
+    }
+    if (config.api.retry.maxAttempts < 0) {
+        errors.push('Retry max attempts must be non-negative');
+    }
+    // Validate execution configuration
+    if (config.execution.timeout <= 0) {
+        errors.push('Execution timeout must be greater than 0');
+    }
+    if (config.execution.maxConcurrent <= 0) {
+        errors.push('Max concurrent executions must be greater than 0');
+    }
+    // Validate UI configuration
+    if (config.ui.gridSize <= 0) {
+        errors.push('Grid size must be greater than 0');
+    }
+    if (config.ui.nodeSpacing <= 0) {
+        errors.push('Node spacing must be greater than 0');
+    }
+    if (config.ui.zoom.min >= config.ui.zoom.max) {
+        errors.push('Zoom min must be less than zoom max');
+    }
+    return errors;
+}

package/dist/utils/connections.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Connection validation utilities for FlowDrop
+ */
+import type { NodeMetadata, NodePort, NodeDataType, WorkflowNode, WorkflowEdge, PortConfig, PortDataTypeConfig } from '../types/index.js';
+/**
+ * Determines if an edge is a loopback edge.
+ * Loopback edges target the special `loop_back` input port on ForEach nodes.
+ * These edges are used to trigger the next iteration in a loop construct.
+ *
+ * @param edge - The edge to check
+ * @returns True if the edge is a loopback edge
+ *
+ * @example
+ * ```typescript
+ * const edge = { targetHandle: "foreach.1-input-loop_back", ... };
+ * const isLoop = isLoopbackEdge(edge); // true
+ * ```
+ */
+export declare function isLoopbackEdge(edge: WorkflowEdge): boolean;
+/**
+ * Checks if a cycle consists entirely of loopback edges.
+ * A valid loopback cycle only contains edges that target loop_back ports.
+ *
+ * @param cycleEdges - Array of edges that form a cycle
+ * @returns True if all edges in the cycle are loopback edges
+ */
+export declare function isValidLoopbackCycle(cycleEdges: WorkflowEdge[]): boolean;
+/**
+ * Configurable port compatibility checker
+ */
+export declare class PortCompatibilityChecker {
+    private portConfig;
+    private compatibilityMap;
+    constructor(portConfig: PortConfig);
+    /**
+     * Build the compatibility map from configuration rules
+     */
+    private buildCompatibilityMap;
+    /**
+     * Check if two data types are compatible for connection
+     */
+    areDataTypesCompatible(outputType: NodeDataType, inputType: NodeDataType): boolean;
+    /**
+     * Get all compatible target types for a source type
+     */
+    getCompatibleTypes(sourceType: NodeDataType): NodeDataType[];
+    /**
+     * Get data type configuration by ID
+     */
+    getDataTypeConfig(dataTypeId: string): PortDataTypeConfig | undefined;
+    /**
+     * Get all enabled data types
+     */
+    getEnabledDataTypes(): PortDataTypeConfig[];
+}
+/**
+ * Initialize the global port compatibility checker
+ */
+export declare function initializePortCompatibility(portConfig: PortConfig): void;
+/**
+ * Get the global port compatibility checker
+ */
+export declare function getPortCompatibilityChecker(): PortCompatibilityChecker;
+/**
+ * Get all possible connections from a source node to target nodes
+ */
+export declare function getPossibleConnections(sourceNode: WorkflowNode, targetNodes: WorkflowNode[], nodeTypes: NodeMetadata[]): Array<{
+    sourceNodeId: string;
+    sourcePortId: string;
+    sourcePort: NodePort;
+    targetNodeId: string;
+    targetPortId: string;
+    targetPort: NodePort;
+    compatible: boolean;
+}>;
+/**
+ * Validate if a specific connection is valid
+ */
+export declare function validateConnection(sourceNodeId: string, sourcePortId: string, targetNodeId: string, targetPortId: string, nodes: WorkflowNode[], nodeTypes: NodeMetadata[]): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Get connection suggestions for a node
+ */
+export declare function getConnectionSuggestions(nodeId: string, nodes: WorkflowNode[], nodeTypes: NodeMetadata[]): Array<{
+    nodeId: string;
+    nodeName: string;
+    portId: string;
+    portName: string;
+    portType: 'input' | 'output';
+    dataType: NodeDataType;
+    compatible: boolean;
+}>;
+/**
+ * Check if a workflow has any cycles (prevent infinite loops)
+ * Note: This function detects ALL cycles, including valid loopback cycles.
+ * Use `hasInvalidCycles` to check only for cycles that could cause infinite execution.
+ *
+ * @param nodes - Array of workflow nodes
+ * @param edges - Array of workflow edges
+ * @returns True if any cycle exists in the workflow
+ */
+export declare function hasCycles(nodes: WorkflowNode[], edges: WorkflowEdge[]): boolean;
+/**
+ * Check if a workflow has any invalid cycles (non-loopback cycles).
+ * This excludes valid loopback cycles used for ForEach iteration.
+ * Only cycles that could cause infinite execution are detected.
+ *
+ * @param nodes - Array of workflow nodes
+ * @param edges - Array of workflow edges
+ * @returns True if any invalid (non-loopback) cycle exists
+ *
+ * @example
+ * ```typescript
+ * // A cycle through a loopback edge is valid (returns false)
+ * // A cycle through regular data edges is invalid (returns true)
+ * const hasInvalid = hasInvalidCycles(nodes, edges);
+ * ```
+ */
+export declare function hasInvalidCycles(nodes: WorkflowNode[], edges: WorkflowEdge[]): boolean;
+/**
+ * Get the execution order for a workflow (topological sort)
+ */
+export declare function getExecutionOrder(nodes: WorkflowNode[], edges: WorkflowEdge[]): string[];