@flowdrop/flowdrop 1.5.0 → 1.7.0

package/dist/utils/nodeSwap.js

@@ -6,23 +6,19 @@
  *
  * @module utils/nodeSwap
  */
-import { buildHandleId, extractPortId, extractDirection } from "./handleIds.js";
-import { generateNodeId } from "./nodeIds.js";
+import { buildHandleId, extractPortId, extractDirection } from './handleIds.js';
+import { generateNodeId } from './nodeIds.js';
 /** Error class for swap validation failures. */
 export class SwapValidationError extends Error {
     constructor(message) {
         super(message);
-        this.name = "SwapValidationError";
+        this.name = 'SwapValidationError';
     }
 }
 // =========================================================================
 // Dynamic port keys that should never be carried over
 // =========================================================================
-const DYNAMIC_PORT_KEYS = new Set([
-    "dynamicInputs",
-    "dynamicOutputs",
-    "branches",
-]);
+const DYNAMIC_PORT_KEYS = new Set(['dynamicInputs', 'dynamicOutputs', 'branches']);
 // =========================================================================
 // Semver comparison
 // =========================================================================
@@ -34,10 +30,10 @@ const DYNAMIC_PORT_KEYS = new Set([
  */
 export function compareSemver(a, b) {
     // Split off pre-release tag
-    const [aCore, aPre] = a.split("-", 2);
-    const [bCore, bPre] = b.split("-", 2);
-    const aParts = aCore.split(".").map(Number);
-    const bParts = bCore.split(".").map(Number);
+    const [aCore, aPre] = a.split('-', 2);
+    const [bCore, bPre] = b.split('-', 2);
+    const aParts = aCore.split('.').map(Number);
+    const bParts = bCore.split('.').map(Number);
     const maxLen = Math.max(aParts.length, bParts.length);
     for (let i = 0; i < maxLen; i++) {
         const av = aParts[i] ?? 0;
@@ -107,7 +103,7 @@ function findMatchingPort(oldPort, newPorts, usedPortIds, checker) {
         if (!checker)
             return a.dataType === b.dataType;
         // Check both directions since the port role (input vs output) matters
-        if (oldPort.type === "input") {
+        if (oldPort.type === 'input') {
             // Old port is input → old dataType was the target; check any source can feed into new port
             return checker.areDataTypesCompatible(a.dataType, b.dataType);
         }
@@ -135,9 +131,7 @@ function resolvePort(node, handleId, direction) {
     const portId = extractPortId(handleId);
     if (!portId)
         return null;
-    const ports = direction === "input"
-        ? node.data.metadata.inputs
-        : node.data.metadata.outputs;
+    const ports = direction === 'input' ? node.data.metadata.inputs : node.data.metadata.outputs;
     return ports.find((p) => p.id === portId) ?? null;
 }
 // =========================================================================
@@ -161,7 +155,7 @@ export function computeSwapPreview(oldNode, newMetadata, edges, allNodes, checke
     const droppedEdges = [];
     for (const edge of connectedEdges) {
         const isSource = edge.source === oldNodeId;
-        const direction = isSource ? "output" : "input";
+        const direction = isSource ? 'output' : 'input';
         const handleId = isSource ? edge.sourceHandle : edge.targetHandle;
         const usedPorts = isSource ? usedOutputPortIds : usedInputPortIds;
         // Resolve the old port
@@ -169,17 +163,17 @@ export function computeSwapPreview(oldNode, newMetadata, edges, allNodes, checke
         if (!oldPort) {
             droppedEdges.push({
                 edge,
-                reason: `Port not found on original node`,
+                reason: `Port not found on original node`
             });
             continue;
         }
         // Find matching port on new node
-        const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+        const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
         const match = findMatchingPort(oldPort, newPorts, usedPorts, checker);
         if (!match) {
             droppedEdges.push({
                 edge,
-                reason: `No compatible ${direction} port found on "${newMetadata.name}"`,
+                reason: `No compatible ${direction} port found on "${newMetadata.name}"`
             });
             continue;
         }
@@ -205,7 +199,7 @@ export function computeSwapPreview(oldNode, newMetadata, edges, allNodes, checke
         hasDataLoss: droppedEdges.length > 0,
         newNodeId,
         configCarriedOver: carriedOver,
-        configReset: reset,
+        configReset: reset
     };
 }
 // =========================================================================
@@ -225,20 +219,20 @@ export function executeSwap(oldNode, newMetadata, preview, allNodes, allEdges) {
     const extensions = {
         ...oldNode.data.extensions,
         swap: {
-            previousNodeId: oldNodeId,
-        },
+            previousNodeId: oldNodeId
+        }
     };
     const newNode = {
         id: newNodeId,
-        type: "universalNode",
+        type: 'universalNode',
         position: { ...oldNode.position },
         deletable: oldNode.deletable,
         data: {
             label: newMetadata.name,
             config: mappedConfig,
             metadata: newMetadata,
-            extensions,
-        },
+            extensions
+        }
     };
     // Build dropped edge IDs set for fast lookup
     const droppedEdgeIds = new Set(preview.droppedEdges.map((d) => d.edge.id));
@@ -261,7 +255,7 @@ export function executeSwap(oldNode, newMetadata, preview, allNodes, allEdges) {
         }
     }
     // Build updated nodes: replace old node with new node (preserving array order)
-    const updatedNodes = allNodes.map((node) => node.id === oldNodeId ? newNode : node);
+    const updatedNodes = allNodes.map((node) => (node.id === oldNodeId ? newNode : node));
     return { updatedNodes, updatedEdges };
 }
 // =========================================================================
@@ -292,12 +286,12 @@ export function getVersionUpgrade(currentMetadata, allNodeTypes) {
  */
 function classifyMatch(oldPort, matchedPort) {
     if (!matchedPort)
-        return "unmapped";
+        return 'unmapped';
     if (matchedPort.id === oldPort.id)
-        return "id";
+        return 'id';
     if (matchedPort.name.toLowerCase() === oldPort.name.toLowerCase())
-        return "name";
-    return "type";
+        return 'name';
+    return 'type';
 }
 /**
  * Compute a swap preview with full options support (strategies, overrides).
@@ -323,7 +317,7 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
             newMetadata,
             edges,
             allNodes,
-            checker,
+            checker
         };
         for (const strategy of options.strategies) {
             if (strategy.canHandle(ctx)) {
@@ -345,12 +339,12 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
     const droppedEdges = [];
     for (const edge of connectedEdges) {
         const isSource = edge.source === oldNodeId;
-        const direction = isSource ? "output" : "input";
+        const direction = isSource ? 'output' : 'input';
         const handleId = isSource ? edge.sourceHandle : edge.targetHandle;
         const usedPorts = isSource ? usedOutputPortIds : usedInputPortIds;
         const oldPort = resolvePort(oldNode, handleId, direction);
         if (!oldPort) {
-            droppedEdges.push({ edge, reason: "Port not found on original node" });
+            droppedEdges.push({ edge, reason: 'Port not found on original node' });
             continue;
         }
         // Priority 1: Manual port override
@@ -358,10 +352,10 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
         if (portOverrideLookup.has(overrideKey)) {
             const overrideNewPortId = portOverrideLookup.get(overrideKey);
             if (overrideNewPortId === null) {
-                droppedEdges.push({ edge, reason: "Manually dropped" });
+                droppedEdges.push({ edge, reason: 'Manually dropped' });
                 continue;
             }
-            const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+            const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
             const overridePort = newPorts.find((p) => p.id === overrideNewPortId);
             if (overridePort) {
                 usedPorts.add(overridePort.id);
@@ -383,10 +377,10 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
         if (strategyPortMap && oldPort.id in strategyPortMap) {
             const strategyNewPortId = strategyPortMap[oldPort.id];
             if (strategyNewPortId === null) {
-                droppedEdges.push({ edge, reason: "Dropped by strategy" });
+                droppedEdges.push({ edge, reason: 'Dropped by strategy' });
                 continue;
             }
-            const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+            const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
             const strategyPort = newPorts.find((p) => p.id === strategyNewPortId);
             if (strategyPort && !usedPorts.has(strategyPort.id)) {
                 usedPorts.add(strategyPort.id);
@@ -405,12 +399,12 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
             }
         }
         // Priority 3: Built-in 3-pass matching
-        const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+        const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
         const match = findMatchingPort(oldPort, newPorts, usedPorts, checker);
         if (!match) {
             droppedEdges.push({
                 edge,
-                reason: `No compatible ${direction} port found on "${newMetadata.name}"`,
+                reason: `No compatible ${direction} port found on "${newMetadata.name}"`
             });
             continue;
         }
@@ -432,14 +426,14 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
     // Apply strategy config overrides
     if (strategyConfigMap) {
         for (const [key, mapping] of Object.entries(strategyConfigMap)) {
-            if (mapping.action === "carry" && key in oldNode.data.config) {
+            if (mapping.action === 'carry' && key in oldNode.data.config) {
                 if (!carriedOver.includes(key))
                     carriedOver.push(key);
                 const resetIdx = reset.indexOf(key);
                 if (resetIdx >= 0)
                     reset.splice(resetIdx, 1);
             }
-            else if (mapping.action === "reset") {
+            else if (mapping.action === 'reset') {
                 if (!reset.includes(key))
                     reset.push(key);
                 const carryIdx = carriedOver.indexOf(key);
@@ -450,21 +444,21 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
     }
     // Apply manual config overrides (highest priority)
     for (const override of options.configOverrides ?? []) {
-        if (override.action === "carry" && override.key in oldNode.data.config) {
+        if (override.action === 'carry' && override.key in oldNode.data.config) {
             if (!carriedOver.includes(override.key))
                 carriedOver.push(override.key);
             const resetIdx = reset.indexOf(override.key);
             if (resetIdx >= 0)
                 reset.splice(resetIdx, 1);
         }
-        else if (override.action === "reset") {
+        else if (override.action === 'reset') {
             if (!reset.includes(override.key))
                 reset.push(override.key);
             const carryIdx = carriedOver.indexOf(override.key);
             if (carryIdx >= 0)
                 carriedOver.splice(carryIdx, 1);
         }
-        else if (override.action === "set") {
+        else if (override.action === 'set') {
             if (!carriedOver.includes(override.key))
                 carriedOver.push(override.key);
             const resetIdx = reset.indexOf(override.key);
@@ -478,7 +472,7 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
         hasDataLoss: droppedEdges.length > 0,
         newNodeId,
         configCarriedOver: carriedOver,
-        configReset: reset,
+        configReset: reset
     };
 }
 /**
@@ -507,15 +501,15 @@ export function computeInteractiveState(oldNode, newMetadata, edges, allNodes, o
     const portMappings = [];
     for (const edge of connectedEdges) {
         const isSource = edge.source === oldNodeId;
-        const direction = isSource ? "output" : "input";
+        const direction = isSource ? 'output' : 'input';
         const handleId = isSource ? edge.sourceHandle : edge.targetHandle;
         const oldPort = resolvePort(oldNode, handleId, direction);
         if (!oldPort)
             continue;
         const matchedPortId = keptEdgePortMap.get(edge.id) ?? null;
-        const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+        const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
         const matchedPort = matchedPortId
-            ? newPorts.find((p) => p.id === matchedPortId) ?? null
+            ? (newPorts.find((p) => p.id === matchedPortId) ?? null)
             : null;
         const matchQuality = classifyMatch(oldPort, matchedPort);
         portMappings.push({
@@ -525,7 +519,7 @@ export function computeInteractiveState(oldNode, newMetadata, edges, allNodes, o
             selectedNewPortId: matchedPortId,
             matchQuality,
             autoSuggestedPortId: matchedPortId,
-            isOverridden: false,
+            isOverridden: false
         });
     }
     // Build config mappings
@@ -548,7 +542,7 @@ export function computeInteractiveState(oldNode, newMetadata, edges, allNodes, o
                 newDefault,
                 carryOver: hasOldValue && isFlat,
                 autoCarryOver: hasOldValue && isFlat,
-                isFlat,
+                isFlat
             });
         }
     }
@@ -559,7 +553,7 @@ export function computeInteractiveState(oldNode, newMetadata, edges, allNodes, o
         portMappings,
         configMappings,
         availableNewInputs: [...newMetadata.inputs],
-        availableNewOutputs: [...newMetadata.outputs],
+        availableNewOutputs: [...newMetadata.outputs]
     };
 }
 /** Check if a value is a primitive (string, number, boolean, null, undefined). */
@@ -567,7 +561,7 @@ function isPrimitive(value) {
     if (value === null || value === undefined)
         return true;
     const t = typeof value;
-    return t === "string" || t === "number" || t === "boolean";
+    return t === 'string' || t === 'number' || t === 'boolean';
 }
 /**
  * Convert user-edited InteractiveSwapState back into a SwapPreview
@@ -580,9 +574,9 @@ export function buildSwapPreviewFromState(state, allEdges) {
         if (!mapping.selectedNewPortId) {
             droppedEdges.push({
                 edge: mapping.edge,
-                reason: mapping.matchQuality === "unmapped"
+                reason: mapping.matchQuality === 'unmapped'
                     ? `No compatible ${mapping.direction} port found on "${state.newMetadata.name}"`
-                    : "Manually dropped",
+                    : 'Manually dropped'
             });
             continue;
         }
@@ -616,7 +610,7 @@ export function buildSwapPreviewFromState(state, allEdges) {
         hasDataLoss: droppedEdges.length > 0,
         newNodeId: state.newNodeId,
         configCarriedOver,
-        configReset,
+        configReset
     };
 }
 /**
@@ -672,13 +666,13 @@ export function validateSwapResult(result) {
         if (!nodeIds.has(edge.source)) {
             return {
                 valid: false,
-                error: `Dangling edge "${edge.id}": source node "${edge.source}" not found`,
+                error: `Dangling edge "${edge.id}": source node "${edge.source}" not found`
             };
         }
         if (!nodeIds.has(edge.target)) {
             return {
                 valid: false,
-                error: `Dangling edge "${edge.id}": target node "${edge.target}" not found`,
+                error: `Dangling edge "${edge.id}": target node "${edge.target}" not found`
             };
         }
     }

package/dist/utils/nodeTypes.d.ts

@@ -9,7 +9,7 @@
  *
  * Works with both built-in types and custom registered types.
  */
-import type { NodeType, NodeMetadata } from "../types/index.js";
+import type { NodeType, NodeMetadata } from '../types/index.js';
 /**
  * Gets the SvelteFlow component name for a given NodeType.
  * Uses the node component registry to resolve types.

package/dist/utils/nodeTypes.js

@@ -9,19 +9,19 @@
  *
  * Works with both built-in types and custom registered types.
  */
-import { nodeComponentRegistry } from "../registry/nodeComponentRegistry.js";
-import { resolveBuiltinAlias, isBuiltinType, } from "../registry/builtinNodes.js";
+import { nodeComponentRegistry } from '../registry/nodeComponentRegistry.js';
+import { resolveBuiltinAlias, isBuiltinType } from '../registry/builtinNodes.js';
 /**
  * Display names for built-in node types.
  */
 const TYPE_DISPLAY_NAMES = {
-    note: "Note (sticky note style)",
-    simple: "Simple (compact layout)",
-    square: "Square (geometric layout)",
-    tool: "Tool (specialized for agent tools)",
-    gateway: "Gateway (branching control flow)",
-    terminal: "Terminal (start/end/exit)",
-    default: "Default (standard workflow node)",
+    note: 'Note (sticky note style)',
+    simple: 'Simple (compact layout)',
+    square: 'Square (geometric layout)',
+    tool: 'Tool (specialized for agent tools)',
+    gateway: 'Gateway (branching control flow)',
+    terminal: 'Terminal (start/end/exit)',
+    default: 'Default (standard workflow node)'
 };
 /**
  * Gets the SvelteFlow component name for a given NodeType.
@@ -38,7 +38,7 @@ export function getComponentNameForNodeType(nodeType) {
         return resolvedType;
     }
     // Unknown type - return workflowNode as default
-    return "workflowNode";
+    return 'workflowNode';
 }
 /**
  * Gets the available node types for a given NodeMetadata.
@@ -54,7 +54,7 @@ export function getAvailableNodeTypes(metadata) {
     if (metadata.type) {
         return [metadata.type];
     }
-    return ["default"];
+    return ['default'];
 }
 /**
  * Gets the primary (default) node type for a given NodeMetadata.
@@ -92,8 +92,7 @@ export function resolveNodeType(metadata, configNodeType) {
             return configNodeType;
         }
         // Check if it's a registered custom type
-        if (nodeComponentRegistry.has(configNodeType) ||
-            nodeComponentRegistry.has(resolvedConfig)) {
+        if (nodeComponentRegistry.has(configNodeType) || nodeComponentRegistry.has(resolvedConfig)) {
             return configNodeType;
         }
     }
@@ -172,7 +171,7 @@ export function getNodeTypeOneOfOptions(metadata, includeCustomTypes = false) {
     // Optionally include all registered custom types
     if (includeCustomTypes) {
         const registrations = nodeComponentRegistry.filter({
-            predicate: (reg) => !isBuiltinType(reg.type) && !includedTypes.has(reg.type),
+            predicate: (reg) => !isBuiltinType(reg.type) && !includedTypes.has(reg.type)
         });
         for (const reg of registrations) {
             options.push({ const: reg.type, title: reg.displayName });
@@ -195,11 +194,11 @@ export function createNodeTypeConfigProperty(metadata, defaultType) {
     const oneOf = getNodeTypeOneOfOptions(metadata);
     const primaryType = defaultType ?? getPrimaryNodeType(metadata);
     return {
-        type: "string",
-        title: "Node Type",
-        description: "Choose the visual representation for this node",
+        type: 'string',
+        title: 'Node Type',
+        description: 'Choose the visual representation for this node',
         default: primaryType,
-        oneOf,
+        oneOf
     };
 }
 /**
@@ -227,12 +226,12 @@ export function getAllNodeTypes() {
  */
 function formatTypeName(type) {
     // Handle namespaced types (e.g., "mylib:fancy" -> "Mylib: Fancy")
-    if (type.includes(":")) {
-        const [namespace, name] = type.split(":");
+    if (type.includes(':')) {
+        const [namespace, name] = type.split(':');
         return `${capitalize(namespace)}: ${capitalize(name)}`;
     }
     // Capitalize and add spaces for camelCase
-    return capitalize(type.replace(/([A-Z])/g, " $1").trim());
+    return capitalize(type.replace(/([A-Z])/g, ' $1').trim());
 }
 /**
  * Capitalize the first letter of a string.

package/dist/utils/nodeWrapper.d.ts

@@ -2,13 +2,13 @@
  * Node Wrapper Utilities
  * Provides utilities for wrapping nodes with status overlays
  */
-import type { NodeExecutionInfo } from "../types/index.js";
+import type { NodeExecutionInfo } from '../types/index.js';
 /**
  * Configuration for node status overlay
  */
 export interface NodeStatusConfig {
-    position?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
-    size?: "sm" | "md" | "lg";
+    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    size?: 'sm' | 'md' | 'lg';
     showDetails?: boolean;
 }
 /**
@@ -21,8 +21,8 @@ export declare const DEFAULT_NODE_STATUS_CONFIG: NodeStatusConfig;
 export declare function createNodeWrapperConfig(nodeId: string, executionInfo?: NodeExecutionInfo, config?: NodeStatusConfig): {
     nodeId: string;
     executionInfo?: NodeExecutionInfo;
-    statusPosition: NodeStatusConfig["position"];
-    statusSize: NodeStatusConfig["size"];
+    statusPosition: NodeStatusConfig['position'];
+    statusSize: NodeStatusConfig['size'];
     showStatusDetails: boolean;
 };
 /**
@@ -32,8 +32,8 @@ export declare function shouldShowNodeStatus(executionInfo?: NodeExecutionInfo):
 /**
  * Get optimal status position based on node type
  */
-export declare function getOptimalStatusPosition(nodeType: string): NodeStatusConfig["position"];
+export declare function getOptimalStatusPosition(nodeType: string): NodeStatusConfig['position'];
 /**
  * Get optimal status size based on node type
  */
-export declare function getOptimalStatusSize(nodeType: string): NodeStatusConfig["size"];
+export declare function getOptimalStatusSize(nodeType: string): NodeStatusConfig['size'];

package/dist/utils/nodeWrapper.js

@@ -6,9 +6,9 @@
  * Default configuration for node status overlays
  */
 export const DEFAULT_NODE_STATUS_CONFIG = {
-    position: "top-right",
-    size: "md",
-    showDetails: true,
+    position: 'top-right',
+    size: 'md',
+    showDetails: true
 };
 /**
  * Create a node wrapper configuration
@@ -19,7 +19,7 @@ export function createNodeWrapperConfig(nodeId, executionInfo, config = {}) {
         executionInfo,
         statusPosition: config.position || DEFAULT_NODE_STATUS_CONFIG.position,
         statusSize: config.size || DEFAULT_NODE_STATUS_CONFIG.size,
-        showStatusDetails: config.showDetails ?? DEFAULT_NODE_STATUS_CONFIG.showDetails ?? true,
+        showStatusDetails: config.showDetails ?? DEFAULT_NODE_STATUS_CONFIG.showDetails ?? true
     };
 }
 /**
@@ -28,23 +28,21 @@ export function createNodeWrapperConfig(nodeId, executionInfo, config = {}) {
 export function shouldShowNodeStatus(executionInfo) {
     if (!executionInfo)
         return false;
-    return (executionInfo.status !== "idle" ||
-        executionInfo.executionCount > 0 ||
-        executionInfo.isExecuting);
+    return (executionInfo.status !== 'idle' || executionInfo.executionCount > 0 || executionInfo.isExecuting);
 }
 /**
  * Get optimal status position based on node type
  */
 export function getOptimalStatusPosition(nodeType) {
     switch (nodeType) {
-        case "tool":
-            return "top-left";
-        case "note":
-            return "bottom-right";
-        case "simple":
-        case "square":
+        case 'tool':
+            return 'top-left';
+        case 'note':
+            return 'bottom-right';
+        case 'simple':
+        case 'square':
         default:
-            return "top-right";
+            return 'top-right';
     }
 }
 /**
@@ -52,13 +50,13 @@ export function getOptimalStatusPosition(nodeType) {
  */
 export function getOptimalStatusSize(nodeType) {
     switch (nodeType) {
-        case "tool":
-            return "sm";
-        case "note":
-            return "sm";
-        case "simple":
-        case "square":
+        case 'tool':
+            return 'sm';
+        case 'note':
+            return 'sm';
+        case 'simple':
+        case 'square':
         default:
-            return "md";
+            return 'md';
     }
 }

package/dist/utils/performanceUtils.d.ts

@@ -2,7 +2,7 @@
  * Performance Utilities
  * Helper functions for optimizing performance in the FlowDrop app
  */
-import type { WorkflowNode, WorkflowEdge } from "../types/index.js";
+import type { WorkflowNode, WorkflowEdge } from '../types/index.js';
 /**
  * Fast shallow comparison for workflow nodes
  * Avoids expensive JSON.stringify operations

package/dist/utils/performanceUtils.js

@@ -16,8 +16,7 @@ export function areNodeArraysEqual(nodes1, nodes2) {
         if (node1?.id !== node2?.id)
             return false;
         // Check position (most common change during drag)
-        if (node1?.position?.x !== node2?.position?.x ||
-            node1?.position?.y !== node2?.position?.y) {
+        if (node1?.position?.x !== node2?.position?.x || node1?.position?.y !== node2?.position?.y) {
             return false;
         }
         // Check selected state

package/dist/utils/portUtils.d.ts

@@ -1,4 +1,4 @@
-import type { NodePort } from "../types/index.js";
+import type { NodePort } from '../types/index.js';
 /**
  * Sort ports by an ordered array of port IDs.
  * Ports not listed appear at the end in their original order.
@@ -18,7 +18,7 @@ export declare function getPortTop(index: number, count: number): number;
  * 2. `hideUnconnectedHandles` — hide if not present in the connected handles set
  * 3. Default — visible
  */
-export declare function isPortVisible(port: NodePort, direction: "input" | "output", hiddenPorts: {
+export declare function isPortVisible(port: NodePort, direction: 'input' | 'output', hiddenPorts: {
     inputs?: string[];
     outputs?: string[];
 }, hideUnconnectedHandles: boolean, connectedHandles: Set<string>, nodeId: string | undefined): boolean;

package/dist/utils/portUtils.js

@@ -32,7 +32,7 @@ export function getPortTop(index, count) {
  * 3. Default — visible
  */
 export function isPortVisible(port, direction, hiddenPorts, hideUnconnectedHandles, connectedHandles, nodeId) {
-    const hiddenList = direction === "input" ? hiddenPorts.inputs : hiddenPorts.outputs;
+    const hiddenList = direction === 'input' ? hiddenPorts.inputs : hiddenPorts.outputs;
     if (hiddenList?.includes(port.id))
         return false;
     if (hideUnconnectedHandles) {

package/dist/utils/sanitize.js

@@ -7,7 +7,7 @@
  *
  * @module utils/sanitize
  */
-import DOMPurify from "dompurify";
+import DOMPurify from 'dompurify';
 /**
  * Sanitize an HTML string to prevent XSS attacks.
  *

package/dist/utils/uischema.d.ts

@@ -4,8 +4,8 @@
  * Functions for resolving JSON Pointer scope strings to property keys,
  * and for generating default UISchema from a ConfigSchema.
  */
-import type { ConfigSchema } from "../types/index.js";
-import type { UISchemaElement, UISchemaVerticalLayout } from "../types/uischema.js";
+import type { ConfigSchema } from '../types/index.js';
+import type { UISchemaElement, UISchemaVerticalLayout } from '../types/uischema.js';
 /**
  * Resolve a JSON Pointer scope string to a property key.
  *