@d34dman/flowdrop 0.0.1 → 0.0.3

package/dist/utils/config.js

@@ -0,0 +1,248 @@
+/**
+ * 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;
+}
+/**
+ * Create configuration from environment variables
+ */
+export function createConfigFromEnv() {
+    const apiBaseUrl = import.meta.env.VITE_FLOWDROP_API_URL || '/api/flowdrop';
+    const endpointConfig = createEndpointConfig(apiBaseUrl);
+    const config = createDefaultConfig(endpointConfig);
+    // Override with environment variables
+    if (import.meta.env.VITE_FLOWDROP_THEME) {
+        config.theme = import.meta.env.VITE_FLOWDROP_THEME;
+    }
+    if (import.meta.env.VITE_FLOWDROP_TIMEOUT) {
+        config.api.timeout = parseInt(import.meta.env.VITE_FLOWDROP_TIMEOUT);
+    }
+    if (import.meta.env.VITE_FLOWDROP_AUTH_TYPE) {
+        config.api.auth.type = import.meta.env.VITE_FLOWDROP_AUTH_TYPE;
+    }
+    if (import.meta.env.VITE_FLOWDROP_AUTH_TOKEN) {
+        config.api.auth.token = import.meta.env.VITE_FLOWDROP_AUTH_TOKEN;
+    }
+    return config;
+}

package/dist/utils/connections.d.ts

@@ -1,9 +1,46 @@
 /**
  * Connection validation utilities for FlowDrop
  */
-import type { NodeMetadata, NodePort, NodeDataType, WorkflowNode, WorkflowEdge } from "../types/index.js";
+import type { NodeMetadata, NodePort, NodeDataType, WorkflowNode, WorkflowEdge, PortConfig, PortDataTypeConfig } from '../types/index.js';
 /**
- * Check if two data types are compatible for connection
+ * 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;
+/**
+ * Check if two data types are compatible for connection (legacy function)
+ * @deprecated Use PortCompatibilityChecker.areDataTypesCompatible() instead
  */
 export declare function areDataTypesCompatible(outputType: NodeDataType, inputType: NodeDataType): boolean;
 /**
@@ -33,7 +70,7 @@ export declare function getConnectionSuggestions(nodeId: string, nodes: Workflow
     nodeName: string;
     portId: string;
     portName: string;
-    portType: "input" | "output";
+    portType: 'input' | 'output';
     dataType: NodeDataType;
     compatible: boolean;
 }>;

package/dist/utils/connections.js

@@ -2,39 +2,110 @@
  * Connection validation utilities for FlowDrop
  */
 /**
- * Check if two data types are compatible for connection
+ * Configurable port compatibility checker
  */
-export function areDataTypesCompatible(outputType, inputType) {
-    // Direct type matches
-    if (outputType === inputType)
-        return true;
-    // String can be converted to most types
-    if (outputType === "string") {
-        return ["string", "number", "boolean"].includes(inputType);
+export class PortCompatibilityChecker {
+    portConfig;
+    compatibilityMap;
+    constructor(portConfig) {
+        this.portConfig = portConfig;
+        this.compatibilityMap = new Map();
+        this.buildCompatibilityMap();
     }
-    // Number can be converted to string
-    if (outputType === "number") {
-        return ["string", "number"].includes(inputType);
+    /**
+     * Build the compatibility map from configuration rules
+     */
+    buildCompatibilityMap() {
+        this.compatibilityMap.clear();
+        // First, add direct type matches (every type is compatible with itself)
+        for (const dataType of this.portConfig.dataTypes) {
+            if (!this.compatibilityMap.has(dataType.id)) {
+                this.compatibilityMap.set(dataType.id, new Set());
+            }
+            this.compatibilityMap.get(dataType.id).add(dataType.id);
+        }
+        // Then add configured compatibility rules
+        for (const rule of this.portConfig.compatibilityRules) {
+            if (!this.compatibilityMap.has(rule.from)) {
+                this.compatibilityMap.set(rule.from, new Set());
+            }
+            this.compatibilityMap.get(rule.from).add(rule.to);
+        }
+        // Add alias support
+        for (const dataType of this.portConfig.dataTypes) {
+            if (dataType.aliases) {
+                for (const alias of dataType.aliases) {
+                    // Make aliases point to the main type's compatibility set
+                    const mainCompatibility = this.compatibilityMap.get(dataType.id);
+                    if (mainCompatibility) {
+                        this.compatibilityMap.set(alias, new Set(mainCompatibility));
+                        // Also make the main type compatible with the alias
+                        mainCompatibility.add(alias);
+                    }
+                }
+            }
+        }
     }
-    // Boolean can be converted to string
-    if (outputType === "boolean") {
-        return ["string", "boolean"].includes(inputType);
+    /**
+     * Check if two data types are compatible for connection
+     */
+    areDataTypesCompatible(outputType, inputType) {
+        const compatibleTypes = this.compatibilityMap.get(outputType);
+        return compatibleTypes ? compatibleTypes.has(inputType) : false;
     }
-    // Object can be converted to string (JSON)
-    if (outputType === "object") {
-        return ["string", "object"].includes(inputType);
+    /**
+     * Get all compatible target types for a source type
+     */
+    getCompatibleTypes(sourceType) {
+        const compatibleTypes = this.compatibilityMap.get(sourceType);
+        return compatibleTypes ? Array.from(compatibleTypes) : [];
     }
-    // Array can be converted to string (JSON)
-    if (outputType === "array") {
-        return ["string", "array"].includes(inputType);
+    /**
+     * Get data type configuration by ID
+     */
+    getDataTypeConfig(dataTypeId) {
+        return this.portConfig.dataTypes.find((dt) => dt.id === dataTypeId || dt.aliases?.includes(dataTypeId));
     }
-    return false;
+    /**
+     * Get all enabled data types
+     */
+    getEnabledDataTypes() {
+        return this.portConfig.dataTypes.filter((dt) => dt.enabled !== false);
+    }
+}
+// Global instance - will be initialized with configuration
+let globalCompatibilityChecker = null;
+/**
+ * Initialize the global port compatibility checker
+ */
+export function initializePortCompatibility(portConfig) {
+    globalCompatibilityChecker = new PortCompatibilityChecker(portConfig);
+}
+/**
+ * Get the global port compatibility checker
+ */
+export function getPortCompatibilityChecker() {
+    if (!globalCompatibilityChecker) {
+        throw new Error('Port compatibility checker not initialized. Call initializePortCompatibility() first.');
+    }
+    return globalCompatibilityChecker;
+}
+/**
+ * Check if two data types are compatible for connection (legacy function)
+ * @deprecated Use PortCompatibilityChecker.areDataTypesCompatible() instead
+ */
+export function areDataTypesCompatible(outputType, inputType) {
+    if (!globalCompatibilityChecker) {
+        // Fallback to basic compatibility for backward compatibility
+        return outputType === inputType;
+    }
+    return globalCompatibilityChecker.areDataTypesCompatible(outputType, inputType);
 }
 /**
  * Get all possible connections from a source node to target nodes
  */
 export function getPossibleConnections(sourceNode, targetNodes, nodeTypes) {
-    const sourceMetadata = nodeTypes.find(nt => nt.id === sourceNode.data.metadata.id);
+    const sourceMetadata = nodeTypes.find((nt) => nt.id === sourceNode.data.metadata.id);
     if (!sourceMetadata)
         return [];
     const possibleConnections = [];
@@ -44,7 +115,7 @@ export function getPossibleConnections(sourceNode, targetNodes, nodeTypes) {
     for (const targetNode of targetNodes) {
         if (targetNode.id === sourceNode.id)
             continue; // Skip self-connection
-        const targetMetadata = nodeTypes.find(nt => nt.id === targetNode.data.metadata.id);
+        const targetMetadata = nodeTypes.find((nt) => nt.id === targetNode.data.metadata.id);
         if (!targetMetadata)
             continue;
         // Get all input ports from target node
@@ -72,39 +143,39 @@ export function getPossibleConnections(sourceNode, targetNodes, nodeTypes) {
  */
 export function validateConnection(sourceNodeId, sourcePortId, targetNodeId, targetPortId, nodes, nodeTypes) {
     // Check if nodes exist
-    const sourceNode = nodes.find(n => n.id === sourceNodeId);
-    const targetNode = nodes.find(n => n.id === targetNodeId);
+    const sourceNode = nodes.find((n) => n.id === sourceNodeId);
+    const targetNode = nodes.find((n) => n.id === targetNodeId);
     if (!sourceNode) {
-        return { valid: false, error: "Source node not found" };
+        return { valid: false, error: 'Source node not found' };
     }
     if (!targetNode) {
-        return { valid: false, error: "Target node not found" };
+        return { valid: false, error: 'Target node not found' };
     }
     // Check for self-connection
     if (sourceNodeId === targetNodeId) {
-        return { valid: false, error: "Cannot connect node to itself" };
+        return { valid: false, error: 'Cannot connect node to itself' };
     }
     // Get node metadata
-    const sourceMetadata = nodeTypes.find(nt => nt.id === sourceNode.data.metadata.id);
-    const targetMetadata = nodeTypes.find(nt => nt.id === targetNode.data.metadata.id);
+    const sourceMetadata = nodeTypes.find((nt) => nt.id === sourceNode.data.metadata.id);
+    const targetMetadata = nodeTypes.find((nt) => nt.id === targetNode.data.metadata.id);
     if (!sourceMetadata || !targetMetadata) {
-        console.log("Metadata lookup failed:", {
+        console.log('Metadata lookup failed:', {
             sourceNodeId,
             targetNodeId,
             sourceMetadataId: sourceNode.data.metadata.id,
             targetMetadataId: targetNode.data.metadata.id,
-            availableNodeTypes: nodeTypes.map(nt => nt.id)
+            availableNodeTypes: nodeTypes.map((nt) => nt.id)
         });
-        return { valid: false, error: "Node metadata not found" };
+        return { valid: false, error: 'Node metadata not found' };
     }
     // Find ports
-    const sourcePort = sourceMetadata.outputs.find(p => p.id === sourcePortId);
-    const targetPort = targetMetadata.inputs.find(p => p.id === targetPortId);
+    const sourcePort = sourceMetadata.outputs.find((p) => p.id === sourcePortId);
+    const targetPort = targetMetadata.inputs.find((p) => p.id === targetPortId);
     if (!sourcePort) {
-        return { valid: false, error: "Source port not found" };
+        return { valid: false, error: 'Source port not found' };
     }
     if (!targetPort) {
-        return { valid: false, error: "Target port not found" };
+        return { valid: false, error: 'Target port not found' };
     }
     // Check data type compatibility
     if (!areDataTypesCompatible(sourcePort.dataType, targetPort.dataType)) {
@@ -119,17 +190,17 @@ export function validateConnection(sourceNodeId, sourcePortId, targetNodeId, tar
  * Get connection suggestions for a node
  */
 export function getConnectionSuggestions(nodeId, nodes, nodeTypes) {
-    const node = nodes.find(n => n.id === nodeId);
+    const node = nodes.find((n) => n.id === nodeId);
     if (!node)
         return [];
-    const metadata = nodeTypes.find(nt => nt.id === node.data.metadata.id);
+    const metadata = nodeTypes.find((nt) => nt.id === node.data.metadata.id);
     if (!metadata)
         return [];
     const suggestions = [];
     // Get all other nodes
-    const otherNodes = nodes.filter(n => n.id !== nodeId);
+    const otherNodes = nodes.filter((n) => n.id !== nodeId);
     for (const otherNode of otherNodes) {
-        const otherMetadata = nodeTypes.find(nt => nt.id === otherNode.data.metadata.id);
+        const otherMetadata = nodeTypes.find((nt) => nt.id === otherNode.data.metadata.id);
         if (!otherMetadata)
             continue;
         // Check outputs from other nodes to inputs of current node
@@ -141,7 +212,7 @@ export function getConnectionSuggestions(nodeId, nodes, nodeTypes) {
                     nodeName: otherNode.data.label,
                     portId: output.id,
                     portName: output.name,
-                    portType: "output",
+                    portType: 'output',
                     dataType: output.dataType,
                     compatible
                 });
@@ -156,7 +227,7 @@ export function getConnectionSuggestions(nodeId, nodes, nodeTypes) {
                     nodeName: otherNode.data.label,
                     portId: input.id,
                     portName: input.name,
-                    portType: "input",
+                    portType: 'input',
                     dataType: input.dataType,
                     compatible
                 });
@@ -179,7 +250,7 @@ export function hasCycles(nodes, edges) {
         visited.add(nodeId);
         recursionStack.add(nodeId);
         // Get all outgoing edges from this node
-        const outgoingEdges = edges.filter(e => e.source === nodeId);
+        const outgoingEdges = edges.filter((e) => e.source === nodeId);
         for (const edge of outgoingEdges) {
             if (hasCycleUtil(edge.target))
                 return true;

package/dist/utils/icons.d.ts

@@ -2,7 +2,7 @@
  * Centralized icon management for FlowDrop
  * Ensures consistent icon usage across all components
  */
-import type { NodeCategory } from "../types/index.js";
+import type { NodeCategory } from '../types/index.js';
 /**
  * Default icons for different contexts
  */