@flowgram.ai/free-layout-core 0.1.0-alpha.36 → 0.1.0-alpha.37

package/dist/esm/index.js

@@ -559,7 +559,7 @@ var WorkflowNodePortsData = class extends EntityData {
    * 获取输出点位置
    */
   get outputPoints() {
-    return this.inputPorts.map((port) => port.point);
+    return this.outputPorts.map((port) => port.point);
   }
   /**
    * 根据 key 获取 输入点位置
@@ -1570,6 +1570,12 @@ var WorkflowDocumentOptionsDefault = {
 };
 
 // src/workflow-lines-manager.ts
+var NODE_HIT_CELL_SIZE = 512;
+var LINE_HIT_CELL_SIZE = 512;
+var PORT_NODE_BOUNDS_PADDING = 96;
+var NODE_INDEX_MIN_SIZE = 128;
+var LINE_INDEX_MIN_SIZE = 128;
+var MAX_SPATIAL_CELLS_PER_ITEM = 64;
 var WorkflowLinesManager = class {
   constructor() {
     this.toDispose = new DisposableCollection();
@@ -1593,7 +1599,26 @@ var WorkflowLinesManager = class {
     this.isDrawing = false;
   }
   init(doc) {
+    if (this.document === doc) {
+      return;
+    }
     this.document = doc;
+    this.toDispose.pushAll([
+      this.entityManager.onEntityChange((entityType) => {
+        if (entityType === WorkflowNodeEntity.type) {
+          this.invalidateNodeHitCaches();
+        }
+        if (entityType === WorkflowLineEntity.type || entityType === WorkflowPortEntity.type) {
+          this.invalidateLineHitCache();
+          this.outsidePortNodesCache = void 0;
+        }
+      }),
+      this.entityManager.onEntityDataChange(({ entityDataType }) => {
+        if (entityDataType === FlowNodeTransformData3.type) {
+          this.invalidateSpatialHitCaches();
+        }
+      })
+    ]);
   }
   forceUpdate() {
     this.onForceUpdateEmitter.fire();
@@ -1601,6 +1626,7 @@ var WorkflowLinesManager = class {
   invalidateSortedNodesCache() {
     this.sortedNodesCache = void 0;
     this.sortedNodesCacheVersion = void 0;
+    this.invalidateNodeHitCaches();
   }
   get lineType() {
     return this._lineType;
@@ -1630,6 +1656,7 @@ var WorkflowLinesManager = class {
     }
     if (newType !== this._lineType) {
       this._lineType = newType;
+      this.lineSpatialCache = void 0;
       this.getAllLines().forEach((line) => {
         line.getData(WorkflowLineRenderData).update();
       });
@@ -1788,7 +1815,7 @@ var WorkflowLinesManager = class {
    */
   getCloseInLineFromMousePos(mousePos, minDistance = LINE_HOVER_DISTANCE) {
     let targetLine, targetLineDist;
-    const lines = this.getAllLines();
+    const lines = this.getLineHitCandidates(mousePos, minDistance);
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
       if (!this.isPointInBounds(mousePos, line.bounds, minDistance)) {
@@ -1804,6 +1831,10 @@ var WorkflowLinesManager = class {
   }
   dispose() {
     this.portLineMap.clear();
+    this.sortedNodeSpatialCache = void 0;
+    this.hoverNodeSpatialCache = void 0;
+    this.lineSpatialCache = void 0;
+    this.outsidePortNodesCache = void 0;
     this.toDispose.dispose();
   }
   get disposed() {
@@ -1942,8 +1973,9 @@ var WorkflowLinesManager = class {
   }
   getHoverNodeFromMousePos(pos) {
     const nodes = this.getHoverNodes();
-    for (let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
+    const candidates = this.getHoverNodeHitCandidates(pos, nodes);
+    for (let i = 0; i < candidates.length; i++) {
+      const node = candidates[i];
       const { bounds } = node.getData(FlowNodeTransformData3);
       if (this.isPointInBounds(pos, bounds)) {
         return node;
@@ -1973,8 +2005,22 @@ var WorkflowLinesManager = class {
       (a, b) => this.getNodeIndex(a) - this.getNodeIndex(b)
     );
     this.sortedNodesCacheVersion = nodeVersion;
+    this.sortedNodeSpatialCache = void 0;
+    this.outsidePortNodesCache = void 0;
     return this.sortedNodesCache;
   }
+  invalidateNodeHitCaches() {
+    this.sortedNodeSpatialCache = void 0;
+    this.hoverNodeSpatialCache = void 0;
+    this.outsidePortNodesCache = void 0;
+  }
+  invalidateLineHitCache() {
+    this.lineSpatialCache = void 0;
+  }
+  invalidateSpatialHitCaches() {
+    this.invalidateNodeHitCaches();
+    this.invalidateLineHitCache();
+  }
   getHoveredPortFromSortedNodes(pos, sortedNodes, portType) {
     return this.getHoveredPortsFromSortedNodes(pos, sortedNodes, portType).port;
   }
@@ -1983,21 +2029,54 @@ var WorkflowLinesManager = class {
     let outputPort;
     let anyPort;
     const { collectBoth = false } = options;
-    for (let i = sortedNodes.length - 1; i >= 0; i--) {
-      const node = sortedNodes[i];
-      if (!portType && !anyPort) {
-        anyPort = this.findHoveredPort(node.ports.allPorts, pos);
-      }
-      if ((!portType || portType === "output") && !outputPort) {
-        outputPort = this.findHoveredPort(node.ports.outputPorts, pos);
-      }
-      if ((!portType || portType === "input") && !inputPort) {
-        inputPort = this.findHoveredPort(node.ports.inputPorts, pos);
+    const needInput = !portType || portType === "input";
+    const needOutput = !portType || portType === "output";
+    const needAny = !portType && !collectBoth;
+    const candidates = this.getSortedNodeHitCandidates(pos, sortedNodes, PORT_NODE_BOUNDS_PADDING);
+    const checkedNodes = candidates.length === sortedNodes.length ? void 0 : new Set(candidates);
+    for (let i = candidates.length - 1; i >= 0; i--) {
+      const node = candidates[i];
+      if (!this.isPointNearNodePorts(pos, node)) {
+        continue;
       }
+      const result = this.collectHoveredPorts(node.ports.allPorts, pos, {
+        needInput,
+        needOutput,
+        needAny,
+        inputPort,
+        outputPort,
+        anyPort
+      });
+      inputPort = result.inputPort;
+      outputPort = result.outputPort;
+      anyPort = result.anyPort;
       if (portType === "input" && inputPort || portType === "output" && outputPort || !portType && (collectBoth ? inputPort && outputPort : anyPort)) {
         break;
       }
     }
+    if (checkedNodes && !(portType === "input" && inputPort || portType === "output" && outputPort || !portType && (collectBoth ? inputPort && outputPort : anyPort))) {
+      const outsidePortNodes = this.getOutsidePortNodes(sortedNodes);
+      for (let i = outsidePortNodes.length - 1; i >= 0; i--) {
+        const node = outsidePortNodes[i];
+        if (checkedNodes.has(node)) {
+          continue;
+        }
+        const result = this.collectHoveredPorts(node.ports.allPorts, pos, {
+          needInput,
+          needOutput,
+          needAny,
+          inputPort,
+          outputPort,
+          anyPort
+        });
+        inputPort = result.inputPort;
+        outputPort = result.outputPort;
+        anyPort = result.anyPort;
+        if (portType === "input" && inputPort || portType === "output" && outputPort || !portType && (collectBoth ? inputPort && outputPort : anyPort)) {
+          break;
+        }
+      }
+    }
     const needCoverCheck = inputPort || outputPort || anyPort;
     const topCoverNode = needCoverCheck ? options.topCoverNode || this.getNodeHitInfoFromSortedNodes(pos, sortedNodes).topCoverNode : void 0;
     inputPort = this.filterCoveredPort(inputPort, topCoverNode);
@@ -2009,13 +2088,30 @@ var WorkflowLinesManager = class {
       port: portType === "input" ? inputPort : portType === "output" ? outputPort : anyPort
     };
   }
-  findHoveredPort(ports, pos) {
+  collectHoveredPorts(ports, pos, options) {
+    let { inputPort, outputPort, anyPort } = options;
     for (let i = 0; i < ports.length; i++) {
       const port = ports[i];
+      if ((!options.needAny || anyPort) && (!options.needInput || inputPort) && (!options.needOutput || outputPort)) {
+        break;
+      }
       if (port.isHovered(pos.x, pos.y)) {
-        return port;
+        if (!anyPort && options.needAny) {
+          anyPort = port;
+        }
+        if (!inputPort && options.needInput && port.portType === "input") {
+          inputPort = port;
+        }
+        if (!outputPort && options.needOutput && port.portType === "output") {
+          outputPort = port;
+        }
       }
     }
+    return {
+      inputPort,
+      outputPort,
+      anyPort
+    };
   }
   filterCoveredPort(port, topCoverNode) {
     if (port && topCoverNode && topCoverNode !== port.node) {
@@ -2030,9 +2126,10 @@ var WorkflowLinesManager = class {
     const zoom = this.entityManager.getEntity(PlaygroundConfigEntity2)?.config?.zoom || 1;
     const padding = 4 / zoom;
     const selectedIDs = selection?.length ? new Set(selection.map((node) => node.id)) : void 0;
+    const candidates = this.getSortedNodeHitCandidates(pos, sortedNodes, padding);
     let topCoverNode;
-    for (let i = sortedNodes.length - 1; i >= 0; i--) {
-      const node = sortedNodes[i];
+    for (let i = candidates.length - 1; i >= 0; i--) {
+      const node = candidates[i];
       const { bounds } = node.getData(FlowNodeTransformData3);
       if (!this.isPointInBounds(pos, bounds, padding)) {
         continue;
@@ -2058,6 +2155,167 @@ var WorkflowLinesManager = class {
       topNode: topCoverNode
     };
   }
+  getHoverNodeHitCandidates(pos, nodes) {
+    if (nodes.length < NODE_INDEX_MIN_SIZE) {
+      return nodes;
+    }
+    const nodeVersion = this.entityManager.getEntityVersion(WorkflowNodeEntity);
+    const transformVersion = this.entityManager.getEntityDataVersion(FlowNodeTransformData3);
+    const activatedID = this.selectService.activatedNode?.id;
+    if (!this.hoverNodeSpatialCache || this.hoverNodeSpatialCache.nodeVersion !== nodeVersion || this.hoverNodeSpatialCache.transformVersion !== transformVersion || this.hoverNodeSpatialCache.activatedID !== activatedID || this.hoverNodeSpatialCache.nodes !== nodes) {
+      this.hoverNodeSpatialCache = {
+        nodeVersion,
+        transformVersion,
+        activatedID,
+        nodes,
+        index: this.createSpatialIndex(
+          nodes,
+          (node) => node.getData(FlowNodeTransformData3).bounds,
+          NODE_HIT_CELL_SIZE
+        )
+      };
+    }
+    return this.querySpatialIndex(this.hoverNodeSpatialCache.index, pos);
+  }
+  getSortedNodeHitCandidates(pos, sortedNodes, padding = 0) {
+    if (sortedNodes.length < NODE_INDEX_MIN_SIZE) {
+      return sortedNodes;
+    }
+    const nodeVersion = this.entityManager.getEntityVersion(WorkflowNodeEntity);
+    const transformVersion = this.entityManager.getEntityDataVersion(FlowNodeTransformData3);
+    if (!this.sortedNodeSpatialCache || this.sortedNodeSpatialCache.nodeVersion !== nodeVersion || this.sortedNodeSpatialCache.transformVersion !== transformVersion || this.sortedNodeSpatialCache.nodes !== sortedNodes) {
+      this.sortedNodeSpatialCache = {
+        nodeVersion,
+        transformVersion,
+        nodes: sortedNodes,
+        index: this.createSpatialIndex(
+          sortedNodes,
+          (node) => node.getData(FlowNodeTransformData3).bounds,
+          NODE_HIT_CELL_SIZE
+        )
+      };
+    }
+    return this.querySpatialIndex(this.sortedNodeSpatialCache.index, pos, padding);
+  }
+  getLineHitCandidates(pos, padding) {
+    const lines = this.getAllLines();
+    if (lines.length < LINE_INDEX_MIN_SIZE) {
+      return lines;
+    }
+    const lineVersion = this.entityManager.getEntityVersion(WorkflowLineEntity);
+    const portVersion = this.entityManager.getEntityVersion(WorkflowPortEntity);
+    const transformVersion = this.entityManager.getEntityDataVersion(FlowNodeTransformData3);
+    if (!this.lineSpatialCache || this.lineSpatialCache.lineVersion !== lineVersion || this.lineSpatialCache.portVersion !== portVersion || this.lineSpatialCache.transformVersion !== transformVersion) {
+      this.lineSpatialCache = {
+        lineVersion,
+        portVersion,
+        transformVersion,
+        index: this.createSpatialIndex(lines, (line) => line.bounds, LINE_HIT_CELL_SIZE)
+      };
+    }
+    return this.querySpatialIndex(this.lineSpatialCache.index, pos, padding);
+  }
+  createSpatialIndex(items, getBounds, cellSize) {
+    const index = {
+      cellSize,
+      cells: /* @__PURE__ */ new Map(),
+      overflowItems: [],
+      order: /* @__PURE__ */ new Map()
+    };
+    items.forEach((item, itemIndex) => {
+      index.order.set(item, itemIndex);
+      const bounds = getBounds(item);
+      if (!this.canIndexBounds(bounds)) {
+        index.overflowItems.push(item);
+        return;
+      }
+      const minCellX = this.getSpatialCell(bounds.x, cellSize);
+      const maxCellX = this.getSpatialCell(bounds.right, cellSize);
+      const minCellY = this.getSpatialCell(bounds.y, cellSize);
+      const maxCellY = this.getSpatialCell(bounds.bottom, cellSize);
+      const cellCount = (maxCellX - minCellX + 1) * (maxCellY - minCellY + 1);
+      if (cellCount > MAX_SPATIAL_CELLS_PER_ITEM) {
+        index.overflowItems.push(item);
+        return;
+      }
+      for (let x = minCellX; x <= maxCellX; x++) {
+        for (let y = minCellY; y <= maxCellY; y++) {
+          const key = this.getSpatialCellKey(x, y);
+          let cellItems = index.cells.get(key);
+          if (!cellItems) {
+            cellItems = [];
+            index.cells.set(key, cellItems);
+          }
+          cellItems.push(item);
+        }
+      }
+    });
+    return index;
+  }
+  querySpatialIndex(index, pos, padding = 0) {
+    const minCellX = this.getSpatialCell(pos.x - padding, index.cellSize);
+    const maxCellX = this.getSpatialCell(pos.x + padding, index.cellSize);
+    const minCellY = this.getSpatialCell(pos.y - padding, index.cellSize);
+    const maxCellY = this.getSpatialCell(pos.y + padding, index.cellSize);
+    const candidates = [];
+    const candidateSet = /* @__PURE__ */ new Set();
+    const pushCandidate = (item) => {
+      if (candidateSet.has(item)) {
+        return;
+      }
+      candidateSet.add(item);
+      candidates.push(item);
+    };
+    for (let x = minCellX; x <= maxCellX; x++) {
+      for (let y = minCellY; y <= maxCellY; y++) {
+        const cellItems = index.cells.get(this.getSpatialCellKey(x, y));
+        if (cellItems) {
+          cellItems.forEach(pushCandidate);
+        }
+      }
+    }
+    index.overflowItems.forEach(pushCandidate);
+    return candidates.sort((a, b) => (index.order.get(a) ?? 0) - (index.order.get(b) ?? 0));
+  }
+  getSpatialCell(value, cellSize) {
+    return Math.floor(value / cellSize);
+  }
+  getSpatialCellKey(x, y) {
+    return `${x}:${y}`;
+  }
+  canIndexBounds(bounds) {
+    return Number.isFinite(bounds.x) && Number.isFinite(bounds.y) && Number.isFinite(bounds.width) && Number.isFinite(bounds.height) && bounds.width > 0 && bounds.height > 0;
+  }
+  isPointNearNodePorts(pos, node) {
+    const { bounds } = node.getData(FlowNodeTransformData3);
+    return this.isPointInBounds(pos, bounds, PORT_NODE_BOUNDS_PADDING);
+  }
+  hasPortOutsideNodeBounds(node) {
+    const { bounds } = node.getData(FlowNodeTransformData3);
+    return node.ports.allPorts.some((port) => {
+      if (port.targetElement) {
+        return true;
+      }
+      return !this.isPointInBounds(port.point, bounds, PORT_NODE_BOUNDS_PADDING);
+    });
+  }
+  getOutsidePortNodes(sortedNodes) {
+    const nodeVersion = this.entityManager.getEntityVersion(WorkflowNodeEntity);
+    const portVersion = this.entityManager.getEntityVersion(WorkflowPortEntity);
+    const transformVersion = this.entityManager.getEntityDataVersion(FlowNodeTransformData3);
+    if (this.outsidePortNodesCache && this.outsidePortNodesCache.nodeVersion === nodeVersion && this.outsidePortNodesCache.portVersion === portVersion && this.outsidePortNodesCache.transformVersion === transformVersion && this.outsidePortNodesCache.sortedNodes === sortedNodes) {
+      return this.outsidePortNodesCache.outsideNodes;
+    }
+    const outsideNodes = sortedNodes.filter((node) => this.hasPortOutsideNodeBounds(node));
+    this.outsidePortNodesCache = {
+      nodeVersion,
+      portVersion,
+      transformVersion,
+      sortedNodes,
+      outsideNodes
+    };
+    return outsideNodes;
+  }
   getHoverNodes() {
     const nodeVersion = this.entityManager.getEntityVersion(WorkflowNodeEntity);
     const activatedID = this.selectService.activatedNode?.id;
@@ -2077,6 +2335,7 @@ var WorkflowLinesManager = class {
     this.hoverNodesCache = nodes;
     this.hoverNodesCacheVersion = nodeVersion;
     this.hoverNodesCacheActivatedID = activatedID;
+    this.hoverNodeSpatialCache = void 0;
     return this.hoverNodesCache;
   }
   isPointInBounds(pos, bounds, padding = 0) {