@flowdrop/flowdrop 1.4.0 → 1.6.0

package/dist/helpers/proximityConnect.js

@@ -5,36 +5,36 @@
  * When a node is dragged near another node, this helper finds the best
  * compatible port pair and creates a preview/permanent edge.
  */
-import { dynamicPortToNodePort } from "../types/index.js";
-import { getPortCompatibilityChecker } from "../utils/connections.js";
-import { v4 as uuidv4 } from "uuid";
+import { dynamicPortToNodePort } from '../types/index.js';
+import { getPortCompatibilityChecker } from '../utils/connections.js';
+import { v4 as uuidv4 } from 'uuid';
 /** CSS class applied to proximity preview edges */
-const PROXIMITY_EDGE_CLASS = "flowdrop--edge--proximity-preview";
+const PROXIMITY_EDGE_CLASS = 'flowdrop--edge--proximity-preview';
 export class ProximityConnectHelper {
     /**
      * Get ALL ports (static + dynamic + gateway branches) for a node.
      */
     static getAllPorts(node, direction) {
         // Static ports from metadata
-        const staticPorts = direction === "output"
+        const staticPorts = direction === 'output'
             ? (node.data?.metadata?.outputs ?? [])
             : (node.data?.metadata?.inputs ?? []);
         // Dynamic ports from config
-        const dynamicKey = direction === "output" ? "dynamicOutputs" : "dynamicInputs";
+        const dynamicKey = direction === 'output' ? 'dynamicOutputs' : 'dynamicInputs';
         const rawDynamic = node.data?.config?.[dynamicKey] ?? [];
         const dynamicPorts = rawDynamic.map((p) => dynamicPortToNodePort(p, direction));
         // Gateway branches (output only, dataType = 'trigger')
-        if (direction === "output") {
+        if (direction === 'output') {
             const branches = node.data?.config?.branches;
             const nodeType = node.data?.metadata?.type || node.type;
-            if (nodeType === "gateway" && branches?.length) {
+            if (nodeType === 'gateway' && branches?.length) {
                 const branchPorts = branches
                     .filter((b) => !staticPorts.some((sp) => sp.id === b.name))
                     .map((b) => ({
                     id: b.name,
                     name: b.name,
-                    type: "output",
-                    dataType: "trigger",
+                    type: 'output',
+                    dataType: 'trigger'
                 }));
                 return [...staticPorts, ...dynamicPorts, ...branchPorts];
             }
@@ -88,10 +88,10 @@ export class ProximityConnectHelper {
         }
         if (!closestNode)
             return [];
-        const draggedOutputs = this.getAllPorts(draggedNode, "output");
-        const draggedInputs = this.getAllPorts(draggedNode, "input");
-        const nearbyInputs = this.getAllPorts(closestNode, "input");
-        const nearbyOutputs = this.getAllPorts(closestNode, "output");
+        const draggedOutputs = this.getAllPorts(draggedNode, 'output');
+        const draggedInputs = this.getAllPorts(draggedNode, 'input');
+        const nearbyInputs = this.getAllPorts(closestNode, 'input');
+        const nearbyOutputs = this.getAllPorts(closestNode, 'output');
         // Collect all compatible pairs, then pick the best one
         let exactMatch = null;
         let compatibleMatch = null;
@@ -100,8 +100,8 @@ export class ProximityConnectHelper {
             for (const inPort of nearbyInputs) {
                 if (!checker.areDataTypesCompatible(outPort.dataType, inPort.dataType))
                     continue;
-                const sourceHandle = this.buildHandleId(draggedNode.id, "output", outPort.id);
-                const targetHandle = this.buildHandleId(closestNode.id, "input", inPort.id);
+                const sourceHandle = this.buildHandleId(draggedNode.id, 'output', outPort.id);
+                const targetHandle = this.buildHandleId(closestNode.id, 'input', inPort.id);
                 const edgeKey = `${draggedNode.id}:${sourceHandle}->${closestNode.id}:${targetHandle}`;
                 if (existingEdgeSet.has(edgeKey))
                     continue;
@@ -112,7 +112,7 @@ export class ProximityConnectHelper {
                     sourceHandle,
                     targetHandle,
                     sourcePortDataType: outPort.dataType,
-                    targetPortDataType: inPort.dataType,
+                    targetPortDataType: inPort.dataType
                 };
                 if (outPort.dataType === inPort.dataType) {
                     if (!exactMatch)
@@ -135,8 +135,8 @@ export class ProximityConnectHelper {
                 for (const inPort of draggedInputs) {
                     if (!checker.areDataTypesCompatible(outPort.dataType, inPort.dataType))
                         continue;
-                    const sourceHandle = this.buildHandleId(closestNode.id, "output", outPort.id);
-                    const targetHandle = this.buildHandleId(draggedNode.id, "input", inPort.id);
+                    const sourceHandle = this.buildHandleId(closestNode.id, 'output', outPort.id);
+                    const targetHandle = this.buildHandleId(draggedNode.id, 'input', inPort.id);
                     const edgeKey = `${closestNode.id}:${sourceHandle}->${draggedNode.id}:${targetHandle}`;
                     if (existingEdgeSet.has(edgeKey))
                         continue;
@@ -147,7 +147,7 @@ export class ProximityConnectHelper {
                         sourceHandle,
                         targetHandle,
                         sourcePortDataType: outPort.dataType,
-                        targetPortDataType: inPort.dataType,
+                        targetPortDataType: inPort.dataType
                     };
                     if (outPort.dataType === inPort.dataType) {
                         if (!exactMatch)
@@ -193,13 +193,13 @@ export class ProximityConnectHelper {
         const otherOutputsByType = new Map();
         for (const coord of portCoordinates.values()) {
             if (coord.nodeId === draggedNodeId) {
-                if (coord.direction === "output")
+                if (coord.direction === 'output')
                     draggedOutputs.push(coord);
                 else
                     draggedInputs.push(coord);
             }
             else {
-                const groupMap = coord.direction === "input" ? otherInputsByType : otherOutputsByType;
+                const groupMap = coord.direction === 'input' ? otherInputsByType : otherOutputsByType;
                 let group = groupMap.get(coord.dataType);
                 if (!group) {
                     group = [];
@@ -224,8 +224,7 @@ export class ProximityConnectHelper {
                 return;
             const isExact = sourceCoord.dataType === targetCoord.dataType;
             // Prefer exact match, then closest distance
-            if ((isExact && !bestIsExact) ||
-                (isExact === bestIsExact && dist < bestDistance)) {
+            if ((isExact && !bestIsExact) || (isExact === bestIsExact && dist < bestDistance)) {
                 bestCandidate = {
                     id: `proximity-${uuidv4()}`,
                     source: sourceCoord.nodeId,
@@ -233,15 +232,22 @@ export class ProximityConnectHelper {
                     sourceHandle: sourceCoord.handleId,
                     targetHandle: targetCoord.handleId,
                     sourcePortDataType: sourceCoord.dataType,
-                    targetPortDataType: targetCoord.dataType,
+                    targetPortDataType: targetCoord.dataType
                 };
                 bestDistance = dist;
                 bestIsExact = isExact;
             }
         };
+        // Cache compatible types per dataType to avoid redundant lookups
+        const compatCache = new Map();
+        for (const srcPort of draggedOutputs) {
+            if (!compatCache.has(srcPort.dataType)) {
+                compatCache.set(srcPort.dataType, checker.getCompatibleTypes(srcPort.dataType));
+            }
+        }
         // Direction A: dragged outputs → other inputs (only compatible types)
         for (const srcPort of draggedOutputs) {
-            const compatibleTypes = checker.getCompatibleTypes(srcPort.dataType);
+            const compatibleTypes = compatCache.get(srcPort.dataType);
             for (const targetType of compatibleTypes) {
                 const targets = otherInputsByType.get(targetType);
                 if (!targets)
@@ -274,17 +280,17 @@ export class ProximityConnectHelper {
             sourceHandle: c.sourceHandle,
             targetHandle: c.targetHandle,
             class: PROXIMITY_EDGE_CLASS,
-            style: "stroke-dasharray: 5 5; opacity: 0.6;",
+            style: 'stroke-dasharray: 5 5; opacity: 0.6;',
             animated: true,
             selectable: false,
             deletable: false,
             data: {
                 metadata: {
-                    edgeType: "data",
+                    edgeType: 'data',
                     sourcePortDataType: c.sourcePortDataType,
-                    isProximityPreview: true,
-                },
-            },
+                    isProximityPreview: true
+                }
+            }
         }));
     }
     /**
@@ -296,16 +302,15 @@ export class ProximityConnectHelper {
             source: c.source,
             target: c.target,
             sourceHandle: c.sourceHandle,
-            targetHandle: c.targetHandle,
+            targetHandle: c.targetHandle
         }));
     }
     /**
      * Check if an edge is a temporary proximity preview edge.
      */
     static isProximityPreviewEdge(edge) {
-        return (edge.id.startsWith("proximity-") ||
-            edge.data?.metadata?.isProximityPreview ===
-                true);
+        return (edge.id.startsWith('proximity-') ||
+            edge.data?.metadata?.isProximityPreview === true);
     }
     /**
      * Remove all proximity preview edges from an edge array.

package/dist/helpers/workflowEditorHelper.d.ts

@@ -2,14 +2,9 @@
  * Workflow Editor Helper
  * Contains business logic for workflow operations
  */
-import type { WorkflowNode as WorkflowNodeType, NodeMetadata, Workflow, WorkflowEdge, NodeExecutionInfo } from "../types/index.js";
-import type { EndpointConfig } from "../config/endpoints.js";
-/**
- * Generate a unique node ID based on node type and existing nodes
- * Format: <node_type>.<number>
- * Example: boolean_gateway.1, calculator.2
- */
-export declare function generateNodeId(nodeTypeId: string, existingNodes: WorkflowNodeType[]): string;
+import type { WorkflowNode as WorkflowNodeType, NodeMetadata, Workflow, WorkflowEdge, NodeExecutionInfo } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
+export { generateNodeId, extractConfigDefaults } from '../utils/nodeIds.js';
 /**
  * Edge category type for styling purposes
  * - trigger: For control flow connections (dataType: "trigger")
@@ -17,63 +12,18 @@ export declare function generateNodeId(nodeTypeId: string, existingNodes: Workfl
  * - loopback: Dashed gray line for loop iteration connections (targets loop_back port)
  * - data: Normal gray line for all other data connections
  */
-export type EdgeCategory = "trigger" | "tool" | "loopback" | "data";
+export type EdgeCategory = 'trigger' | 'tool' | 'loopback' | 'data';
 /**
- * Edge styling configuration based on source port data type
+ * Edge styling configuration based on source port data type.
+ * Delegates to standalone functions in utils/edgeStyling.ts.
  */
 export declare class EdgeStylingHelper {
-    /**
-     * Extract the port ID from a handle ID
-     * @param handleId - The handle ID string (e.g., "sample-node.1-output-trigger" or "trigger")
-     * @returns The port ID (e.g., "trigger") or the handleId itself for short format
-     */
     static extractPortIdFromHandle(handleId: string | undefined): string | null;
-    /**
-     * Check if a port ID matches a dynamic branch in a Gateway node
-     * Gateway nodes store branches in config.branches array
-     * @param node - The workflow node to check
-     * @param portId - The port ID to look up
-     * @returns true if the portId matches a gateway branch
-     */
     static isGatewayBranch(node: WorkflowNodeType, portId: string): boolean;
-    /**
-     * Get the data type of a port from a node's metadata
-     * Also handles dynamic ports like Gateway branches
-     * @param node - The workflow node containing the port
-     * @param portId - The port ID to look up
-     * @param portType - Whether to look in "inputs" or "outputs"
-     * @returns The port's dataType or null if not found
-     */
-    static getPortDataType(node: WorkflowNodeType, portId: string, portType: "input" | "output"): string | null;
-    /**
-     * Determine the edge category based on source port data type
-     * Note: This method does not check for loopback edges.
-     * Use getEdgeCategoryWithLoopback() for full edge categorization.
-     *
-     * @param sourcePortDataType - The data type of the source output port
-     * @returns The edge category for styling
-     */
+    static getPortDataType(node: WorkflowNodeType, portId: string, portType: 'input' | 'output'): string | null;
     static getEdgeCategory(sourcePortDataType: string | null): EdgeCategory;
-    /**
-     * Determine the full edge category including loopback detection
-     * Loopback edges take precedence over source port data type
-     *
-     * @param edge - The edge to categorize
-     * @param sourcePortDataType - The data type of the source output port
-     * @returns The edge category for styling
-     */
     static getEdgeCategoryWithLoopback(edge: WorkflowEdge, sourcePortDataType: string | null): EdgeCategory;
-    /**
-     * Apply custom styling to connection edges based on edge type:
-     * - Loopback: Dashed gray line for loop iteration (targets loop_back port)
-     * - Trigger ports: Solid black line with arrow
-     * - Tool ports: Dashed amber line with arrow
-     * - Data ports: Normal gray line with arrow
-     */
     static applyConnectionStyling(edge: WorkflowEdge, sourceNode: WorkflowNodeType, targetNode: WorkflowNodeType): void;
-    /**
-     * Update existing edges with custom styling rules
-     */
     static updateEdgeStyles(edges: WorkflowEdge[], nodes: WorkflowNodeType[]): WorkflowEdge[];
 }
 /**
@@ -103,7 +53,7 @@ export declare class WorkflowOperationsHelper {
     /**
      * Generate workflow metadata for updates
      */
-    static generateMetadata(existingMetadata?: Workflow["metadata"]): Workflow["metadata"];
+    static generateMetadata(existingMetadata?: Workflow['metadata']): Workflow['metadata'];
     /**
      * Update workflow with new nodes/edges and generate new metadata
      */