@flowgram.ai/free-node-panel-plugin 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/index.js

@@ -36,28 +36,140 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   WorkflowNodePanelService: () => WorkflowNodePanelService,
+  WorkflowNodePanelUtils: () => WorkflowNodePanelUtils,
   createFreeNodePanelPlugin: () => createFreeNodePanelPlugin
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/create-plugin.ts
 var import_core4 = require("@flowgram.ai/core");
 
 // src/service.ts
 var import_inversify = require("inversify");
-var import_utils = require("@flowgram.ai/utils");
+var import_utils4 = require("@flowgram.ai/utils");
+var import_free_layout_core3 = require("@flowgram.ai/free-layout-core");
+var import_free_layout_core4 = require("@flowgram.ai/free-layout-core");
+var import_free_history_plugin2 = require("@flowgram.ai/free-history-plugin");
+var import_core2 = require("@flowgram.ai/core");
+
+// src/utils/wait-node-render.ts
 var import_free_layout_core = require("@flowgram.ai/free-layout-core");
-var import_free_layout_core2 = require("@flowgram.ai/free-layout-core");
+var waitNodeRender = async () => {
+  await (0, import_free_layout_core.delay)(20);
+};
+
+// src/utils/update-sub-nodes-position.ts
 var import_free_history_plugin = require("@flowgram.ai/free-history-plugin");
+var import_core = require("@flowgram.ai/core");
+
+// src/utils/get-port-box.ts
+var import_utils = require("@flowgram.ai/utils");
 var import_document = require("@flowgram.ai/document");
+
+// src/utils/is-container.ts
+var isContainer = (node) => node?.getNodeMeta().isContainer ?? false;
+
+// src/utils/get-port-box.ts
+var getPortBox = (port, offset = { x: 0, y: 0 }) => {
+  const node = port.node;
+  if (isContainer(node)) {
+    const { point } = port;
+    if (port.portType === "input") {
+      return new import_utils.Rectangle(point.x + offset.x, point.y - 50 + offset.y, 300, 100);
+    }
+    return new import_utils.Rectangle(point.x - 300, point.y - 50, 300, 100);
+  }
+  const box = node.getData(import_document.FlowNodeTransformData).bounds;
+  return box;
+};
+
+// src/utils/update-sub-nodes-position.ts
+var updateSubSequentNodesPosition = (params) => {
+  const {
+    node,
+    subsequentNodes,
+    fromPort,
+    toPort,
+    containerNode,
+    offset,
+    historyService,
+    dragService
+  } = params;
+  if (!offset || !toPort) {
+    return;
+  }
+  const subsequentNodesPositions = subsequentNodes.map((node2) => {
+    const nodeTrans2 = node2.getData(import_core.TransformData);
+    return {
+      x: nodeTrans2.position.x,
+      y: nodeTrans2.position.y
+    };
+  });
+  historyService.pushOperation({
+    type: import_free_history_plugin.FreeOperationType.dragNodes,
+    value: {
+      ids: subsequentNodes.map((node2) => node2.id),
+      value: subsequentNodesPositions.map((position) => ({
+        x: position.x + offset.x,
+        y: position.y + offset.y
+      })),
+      oldValue: subsequentNodesPositions
+    }
+  });
+  const fromBox = getPortBox(fromPort);
+  const toBox = getPortBox(toPort, offset);
+  const nodeTrans = node.getData(import_core.TransformData);
+  let nodePos = {
+    x: (fromBox.center.x + toBox.center.x) / 2,
+    y: (fromBox.y + toBox.y) / 2
+  };
+  if (containerNode) {
+    nodePos = dragService.adjustSubNodePosition(
+      node.flowNodeType,
+      containerNode,
+      nodePos
+    );
+  }
+  historyService.pushOperation({
+    type: import_free_history_plugin.FreeOperationType.dragNodes,
+    value: {
+      ids: [node.id],
+      value: [nodePos],
+      oldValue: [
+        {
+          x: nodeTrans.position.x,
+          y: nodeTrans.position.y
+        }
+      ]
+    }
+  });
+};
+
+// src/utils/sub-position-offset.ts
+var import_utils3 = require("@flowgram.ai/utils");
 var import_document2 = require("@flowgram.ai/document");
-var import_core = require("@flowgram.ai/core");
-var import_core2 = require("@flowgram.ai/core");
 
-// src/utils.ts
+// src/utils/rect-distance.ts
+var import_utils2 = require("@flowgram.ai/utils");
+var rectDistance = (rectA, rectB) => {
+  const distanceX = Math.abs(Math.min(rectA.right, rectB.right) - Math.max(rectA.left, rectB.left));
+  const distanceY = Math.abs(Math.min(rectA.bottom, rectB.bottom) - Math.max(rectA.top, rectB.top));
+  if (import_utils2.Rectangle.intersects(rectA, rectB)) {
+    return {
+      x: -distanceX,
+      y: -distanceY
+    };
+  }
+  return {
+    x: distanceX,
+    y: distanceY
+  };
+};
+
+// src/utils/greater-or-less.ts
 var isGreaterThan = (a, b) => {
   if (a === void 0 || b === void 0) {
     return false;
@@ -73,10 +185,222 @@ var isLessThan = (a, b) => {
   return b - a > EPSILON;
 };
 
+// src/utils/sub-position-offset.ts
+var subPositionOffset = (params) => {
+  const { node, fromPort, toPort, padding } = params;
+  const fromBox = getPortBox(fromPort);
+  const toBox = getPortBox(toPort);
+  const nodeTrans = node.getData(import_document2.FlowNodeTransformData);
+  const nodeSize = node.getNodeMeta()?.size ?? {
+    width: nodeTrans.bounds.width,
+    height: nodeTrans.bounds.height
+  };
+  const minDistance = {
+    x: nodeSize.width + padding.x,
+    y: nodeSize.height + padding.y
+  };
+  const boxDistance = rectDistance(fromBox, toBox);
+  const neededOffset = {
+    x: isGreaterThan(boxDistance.x, minDistance.x) ? 0 : minDistance.x - boxDistance.x,
+    y: isGreaterThan(boxDistance.y, minDistance.y) ? 0 : minDistance.y - boxDistance.y
+  };
+  if (neededOffset.x === 0 || neededOffset.y === 0) {
+    return;
+  }
+  const intersection = {
+    // 这里没有写反，Rectangle内置的算法是反的
+    vertical: import_utils3.Rectangle.intersects(fromBox, toBox, "horizontal"),
+    horizontal: import_utils3.Rectangle.intersects(fromBox, toBox, "vertical")
+  };
+  let offsetX = 0;
+  let offsetY = 0;
+  if (!intersection.horizontal) {
+    if (isGreaterThan(toBox.center.y, fromBox.center.y)) {
+      offsetY = neededOffset.y;
+    } else if (isLessThan(toBox.center.y, fromBox.center.y)) {
+      offsetY = -neededOffset.y;
+    }
+  }
+  if (!intersection.vertical) {
+    if (isGreaterThan(toBox.center.x, fromBox.center.x)) {
+      offsetX = neededOffset.x;
+    } else if (isLessThan(toBox.center.x, fromBox.center.x)) {
+      offsetX = -neededOffset.x;
+    }
+  }
+  return {
+    x: offsetX,
+    y: offsetY
+  };
+};
+
+// src/utils/get-sub-nodes.ts
+var getSubsequentNodes = (params) => {
+  const { node, linesManager } = params;
+  if (isContainer(node)) {
+    return [];
+  }
+  const brothers = node.parent?.blocks ?? [];
+  const linkedBrothers = /* @__PURE__ */ new Set();
+  const linesMap = /* @__PURE__ */ new Map();
+  linesManager.getAllAvailableLines().forEach((line) => {
+    if (!linesMap.has(line.from.id)) {
+      linesMap.set(line.from.id, []);
+    }
+    if (!line.to?.id || isContainer(line.to)) {
+      return;
+    }
+    linesMap.get(line.from.id)?.push(line.to.id);
+  });
+  const bfs = (nodeId) => {
+    if (linkedBrothers.has(nodeId)) {
+      return;
+    }
+    linkedBrothers.add(nodeId);
+    const nextNodes = linesMap.get(nodeId) ?? [];
+    nextNodes.forEach(bfs);
+  };
+  bfs(node.id);
+  const subsequentNodes = brothers.filter((node2) => linkedBrothers.has(node2.id));
+  return subsequentNodes;
+};
+
+// src/utils/sub-nodes-auto-offset.ts
+var subNodesAutoOffset = (params) => {
+  const {
+    node,
+    fromPort,
+    toPort,
+    linesManager,
+    historyService,
+    dragService,
+    containerNode,
+    padding = {
+      x: 100,
+      y: 100
+    }
+  } = params;
+  const subOffset = subPositionOffset({
+    node,
+    fromPort,
+    toPort,
+    padding
+  });
+  const subsequentNodes = getSubsequentNodes({
+    node: toPort.node,
+    linesManager
+  });
+  updateSubSequentNodesPosition({
+    node,
+    subsequentNodes,
+    fromPort,
+    toPort,
+    containerNode,
+    offset: subOffset,
+    historyService,
+    dragService
+  });
+};
+
+// src/utils/get-container-node.ts
+var getContainerNode = (params) => {
+  const { fromPort, containerNode } = params;
+  if (containerNode) {
+    return containerNode;
+  }
+  const fromNode = fromPort?.node;
+  const fromContainer = fromNode?.parent;
+  if (isContainer(fromNode)) {
+    return fromNode;
+  }
+  return fromContainer;
+};
+
+// src/utils/build-line.ts
+var import_free_layout_core2 = require("@flowgram.ai/free-layout-core");
+var buildLine = (params) => {
+  const { fromPort, node, toPort, linesManager } = params;
+  const portsData = node.getData(import_free_layout_core2.WorkflowNodePortsData);
+  if (!portsData) {
+    return;
+  }
+  const shouldBuildFromLine = portsData.inputPorts?.length > 0;
+  if (fromPort && shouldBuildFromLine) {
+    const isVertical = fromPort.location === "bottom";
+    const toTargetPort = portsData.inputPorts.find((port) => isVertical ? port.location === "top" : true) || portsData.inputPorts[0];
+    linesManager.createLine({
+      from: fromPort.node.id,
+      fromPort: fromPort.portID,
+      to: node.id,
+      toPort: toTargetPort.portID
+    });
+  }
+  const shouldBuildToLine = portsData.outputPorts?.length > 0;
+  if (toPort && shouldBuildToLine) {
+    const fromTargetPort = portsData.outputPorts[0];
+    linesManager.createLine({
+      from: node.id,
+      fromPort: fromTargetPort.portID,
+      to: toPort.node.id,
+      toPort: toPort.portID
+    });
+  }
+};
+
+// src/utils/adjust-node-position.ts
+var adjustNodePosition = (params) => {
+  const { nodeType, position, fromPort, toPort, containerNode, document, dragService } = params;
+  const register = document.getNodeRegistry(nodeType);
+  const size = register?.meta?.size;
+  let adjustedPosition = position;
+  if (!size) {
+    adjustedPosition = position;
+  } else if (fromPort && toPort) {
+    adjustedPosition = {
+      x: position.x,
+      y: position.y - size.height / 2
+    };
+  } else if (fromPort && !toPort) {
+    if (fromPort.location === "bottom") {
+      adjustedPosition = {
+        x: position.x,
+        y: position.y
+      };
+    } else {
+      adjustedPosition = {
+        x: position.x + size.width / 2,
+        y: position.y - size.height / 2
+      };
+    }
+  } else if (!fromPort && toPort) {
+    adjustedPosition = {
+      x: position.x - size.width / 2,
+      y: position.y - size.height / 2
+    };
+  } else {
+    adjustedPosition = position;
+  }
+  return dragService.adjustSubNodePosition(nodeType, containerNode, adjustedPosition);
+};
+
+// src/utils/index.ts
+var WorkflowNodePanelUtils = {
+  adjustNodePosition,
+  buildLine,
+  getPortBox,
+  getSubsequentNodes,
+  getContainerNode,
+  rectDistance,
+  subNodesAutoOffset,
+  subPositionOffset,
+  updateSubSequentNodesPosition,
+  waitNodeRender
+};
+
 // src/service.ts
 var WorkflowNodePanelService = class {
   constructor() {
-    this.toDispose = new import_utils.DisposableCollection();
+    this.toDispose = new import_utils4.DisposableCollection();
     this.callNodePanel = async () => void 0;
   }
   /** 销毁 */
@@ -105,7 +429,7 @@ var WorkflowNodePanelService = class {
         position: panelPosition,
         enableMultiAdd,
         panelProps,
-        containerNode: this.getContainerNode({
+        containerNode: WorkflowNodePanelUtils.getContainerNode({
           fromPort,
           containerNode
         }),
@@ -124,6 +448,23 @@ var WorkflowNodePanelService = class {
       });
     });
   }
+  /**
+   * 唤起单选面板
+   */
+  async singleSelectNodePanel(params) {
+    return new Promise((resolve) => {
+      this.callNodePanel({
+        ...params,
+        enableMultiAdd: false,
+        onSelect: async (panelParams) => {
+          resolve(panelParams);
+        },
+        onClose: () => {
+          resolve(void 0);
+        }
+      });
+    });
+  }
   /** 添加节点 */
   async addNode(callParams, panelParams) {
     const {
@@ -144,7 +485,7 @@ var WorkflowNodePanelService = class {
       return;
     }
     const { nodeType, selectEvent, nodeJSON } = panelParams;
-    const containerNode = this.getContainerNode({
+    const containerNode = WorkflowNodePanelUtils.getContainerNode({
       fromPort,
       containerNode: callParams.containerNode
     });
@@ -155,14 +496,16 @@ var WorkflowNodePanelService = class {
       }
     }
     const selectPosition = this.playgroundConfig.getPosFromMouseEvent(selectEvent);
-    const nodePosition = callParams.customPosition ? callParams.customPosition({ nodeType, selectPosition }) : this.adjustNodePosition({
+    const nodePosition = callParams.customPosition ? callParams.customPosition({ nodeType, selectPosition }) : WorkflowNodePanelUtils.adjustNodePosition({
       nodeType,
       position: enableSelectPosition ? selectPosition : panelPosition,
       fromPort,
       toPort,
-      containerNode
+      containerNode,
+      document: this.document,
+      dragService: this.dragService
     });
-    const node = await this.document.createWorkflowNodeByType(
+    const node = this.document.createWorkflowNodeByType(
       nodeType,
       nodePosition,
       nodeJSON ?? {},
@@ -172,31 +515,27 @@ var WorkflowNodePanelService = class {
       return;
     }
     if (enableAutoOffset && fromPort && toPort) {
-      const subOffset = this.subPositionOffset({
-        node,
-        fromPort,
-        toPort,
-        padding: autoOffsetPadding
-      });
-      const subsequentNodes = this.getSubsequentNodes(toPort.node);
-      this.updateSubSequentNodesPosition({
+      WorkflowNodePanelUtils.subNodesAutoOffset({
         node,
-        subsequentNodes,
         fromPort,
         toPort,
+        padding: autoOffsetPadding,
         containerNode,
-        offset: subOffset
+        historyService: this.historyService,
+        dragService: this.dragService,
+        linesManager: this.linesManager
       });
     }
     if (!enableBuildLine && !enableDragNode) {
       return node;
     }
-    await (0, import_utils.delay)(20);
+    await WorkflowNodePanelUtils.waitNodeRender();
     if (enableBuildLine) {
-      this.buildLine({
+      WorkflowNodePanelUtils.buildLine({
         fromPort,
         node,
-        toPort
+        toPort,
+        linesManager: this.linesManager
       });
     }
     if (enableDragNode) {
@@ -205,254 +544,24 @@ var WorkflowNodePanelService = class {
     }
     return node;
   }
-  /** 建立连线 */
-  buildLine(params) {
-    const { fromPort, node, toPort } = params;
-    const portsData = node.getData(import_free_layout_core.WorkflowNodePortsData);
-    if (!portsData) {
-      return;
-    }
-    const shouldBuildFromLine = portsData.inputPorts?.length > 0;
-    if (fromPort && shouldBuildFromLine) {
-      const toTargetPort = portsData.inputPorts[0];
-      const isSingleInput = portsData.inputPorts.length === 1;
-      this.linesManager.createLine({
-        from: fromPort.node.id,
-        fromPort: fromPort.portID,
-        to: node.id,
-        toPort: isSingleInput ? void 0 : toTargetPort.id
-      });
-    }
-    const shouldBuildToLine = portsData.outputPorts?.length > 0;
-    if (toPort && shouldBuildToLine) {
-      const fromTargetPort = portsData.outputPorts[0];
-      this.linesManager.createLine({
-        from: node.id,
-        fromPort: fromTargetPort.portID,
-        to: toPort.node.id,
-        toPort: toPort.portID
-      });
-    }
-  }
-  /** 调整节点坐标 */
-  adjustNodePosition(params) {
-    const { nodeType, position, fromPort, toPort, containerNode } = params;
-    const register = this.document.getNodeRegistry(nodeType);
-    const size = register?.meta?.size;
-    let adjustedPosition = position;
-    if (!size) {
-      adjustedPosition = position;
-    } else if (fromPort && toPort) {
-      adjustedPosition = {
-        x: position.x,
-        y: position.y - size.height / 2
-      };
-    } else if (fromPort && !toPort) {
-      adjustedPosition = {
-        x: position.x + size.width / 2,
-        y: position.y - size.height / 2
-      };
-    } else if (!fromPort && toPort) {
-      adjustedPosition = {
-        x: position.x - size.width / 2,
-        y: position.y - size.height / 2
-      };
-    } else {
-      adjustedPosition = position;
-    }
-    return this.dragService.adjustSubNodePosition(nodeType, containerNode, adjustedPosition);
-  }
-  getContainerNode(params) {
-    const { fromPort, containerNode } = params;
-    if (containerNode) {
-      return containerNode;
-    }
-    const fromNode = fromPort?.node;
-    const fromContainer = fromNode?.parent;
-    if (fromNode?.flowNodeType === import_document2.FlowNodeBaseType.SUB_CANVAS) {
-      return fromNode;
-    }
-    return fromContainer;
-  }
-  /** 获取端口矩形 */
-  getPortBox(port, offset = { x: 0, y: 0 }) {
-    const node = port.node;
-    if (node.flowNodeType === import_document2.FlowNodeBaseType.SUB_CANVAS) {
-      const { point } = port;
-      if (port.portType === "input") {
-        return new import_utils.Rectangle(point.x + offset.x, point.y - 50 + offset.y, 300, 100);
-      }
-      return new import_utils.Rectangle(point.x - 300, point.y - 50, 300, 100);
-    }
-    const box = node.getData(import_document.FlowNodeTransformData).bounds;
-    return box;
-  }
-  /** 后续节点位置偏移 */
-  subPositionOffset(params) {
-    const { node, fromPort, toPort, padding } = params;
-    const fromBox = this.getPortBox(fromPort);
-    const toBox = this.getPortBox(toPort);
-    const nodeTrans = node.getData(import_document.FlowNodeTransformData);
-    const nodeSize = node.getNodeMeta()?.size ?? {
-      width: nodeTrans.bounds.width,
-      height: nodeTrans.bounds.height
-    };
-    const minDistance = {
-      x: nodeSize.width + padding.x,
-      y: nodeSize.height + padding.y
-    };
-    const boxDistance = this.rectDistance(fromBox, toBox);
-    const neededOffset = {
-      x: isGreaterThan(boxDistance.x, minDistance.x) ? 0 : minDistance.x - boxDistance.x,
-      y: isGreaterThan(boxDistance.y, minDistance.y) ? 0 : minDistance.y - boxDistance.y
-    };
-    if (neededOffset.x === 0 || neededOffset.y === 0) {
-      return;
-    }
-    const intersection = {
-      // 这里没有写反，Rectangle内置的算法是反的
-      vertical: import_utils.Rectangle.intersects(fromBox, toBox, "horizontal"),
-      horizontal: import_utils.Rectangle.intersects(fromBox, toBox, "vertical")
-    };
-    let offsetX = 0;
-    let offsetY = 0;
-    if (!intersection.horizontal) {
-      if (isGreaterThan(toBox.center.y, fromBox.center.y)) {
-        offsetY = neededOffset.y;
-      } else if (isLessThan(toBox.center.y, fromBox.center.y)) {
-        offsetY = -neededOffset.y;
-      }
-    }
-    if (!intersection.vertical) {
-      if (isGreaterThan(toBox.center.x, fromBox.center.x)) {
-        offsetX = neededOffset.x;
-      } else if (isLessThan(toBox.center.x, fromBox.center.x)) {
-        offsetX = -neededOffset.x;
-      }
-    }
-    return {
-      x: offsetX,
-      y: offsetY
-    };
-  }
-  /** 矩形间距 */
-  rectDistance(rectA, rectB) {
-    const distanceX = Math.abs(
-      Math.min(rectA.right, rectB.right) - Math.max(rectA.left, rectB.left)
-    );
-    const distanceY = Math.abs(
-      Math.min(rectA.bottom, rectB.bottom) - Math.max(rectA.top, rectB.top)
-    );
-    if (import_utils.Rectangle.intersects(rectA, rectB)) {
-      return {
-        x: -distanceX,
-        y: -distanceY
-      };
-    }
-    return {
-      x: distanceX,
-      y: distanceY
-    };
-  }
-  /** 获取后续节点 */
-  getSubsequentNodes(node) {
-    if (node.flowNodeType === import_document2.FlowNodeBaseType.SUB_CANVAS) {
-      return [];
-    }
-    const brothers = node.parent?.collapsedChildren ?? [];
-    const linkedBrothers = /* @__PURE__ */ new Set();
-    const linesMap = /* @__PURE__ */ new Map();
-    this.linesManager.getAllLines().forEach((line) => {
-      if (!linesMap.has(line.from.id)) {
-        linesMap.set(line.from.id, []);
-      }
-      if (!line.to?.id || line.to.flowNodeType === import_document2.FlowNodeBaseType.SUB_CANVAS) {
-        return;
-      }
-      linesMap.get(line.from.id)?.push(line.to.id);
-    });
-    const bfs = (nodeId) => {
-      if (linkedBrothers.has(nodeId)) {
-        return;
-      }
-      linkedBrothers.add(nodeId);
-      const nextNodes = linesMap.get(nodeId) ?? [];
-      nextNodes.forEach(bfs);
-    };
-    bfs(node.id);
-    const subsequentNodes = brothers.filter((node2) => linkedBrothers.has(node2.id));
-    return subsequentNodes;
-  }
-  /** 更新后续节点位置 */
-  updateSubSequentNodesPosition(params) {
-    const { node, subsequentNodes, fromPort, toPort, containerNode, offset } = params;
-    if (!offset || !toPort) {
-      return;
-    }
-    const subsequentNodesPositions = subsequentNodes.map((node2) => {
-      const nodeTrans2 = node2.getData(import_core2.TransformData);
-      return {
-        x: nodeTrans2.position.x,
-        y: nodeTrans2.position.y
-      };
-    });
-    this.historyService.pushOperation({
-      type: import_free_history_plugin.FreeOperationType.dragNodes,
-      value: {
-        ids: subsequentNodes.map((node2) => node2.id),
-        value: subsequentNodesPositions.map((position) => ({
-          x: position.x + offset.x,
-          y: position.y + offset.y
-        })),
-        oldValue: subsequentNodesPositions
-      }
-    });
-    const fromBox = this.getPortBox(fromPort);
-    const toBox = this.getPortBox(toPort, offset);
-    const nodeTrans = node.getData(import_core2.TransformData);
-    let nodePos = {
-      x: (fromBox.center.x + toBox.center.x) / 2,
-      y: (fromBox.y + toBox.y) / 2
-    };
-    if (containerNode) {
-      nodePos = this.dragService.adjustSubNodePosition(
-        node.flowNodeType,
-        containerNode,
-        nodePos
-      );
-    }
-    this.historyService.pushOperation({
-      type: import_free_history_plugin.FreeOperationType.dragNodes,
-      value: {
-        ids: [node.id],
-        value: [nodePos],
-        oldValue: [
-          {
-            x: nodeTrans.position.x,
-            y: nodeTrans.position.y
-          }
-        ]
-      }
-    });
-  }
 };
 __decorateClass([
-  (0, import_inversify.inject)(import_free_layout_core.WorkflowDocument)
+  (0, import_inversify.inject)(import_free_layout_core3.WorkflowDocument)
 ], WorkflowNodePanelService.prototype, "document", 2);
 __decorateClass([
-  (0, import_inversify.inject)(import_free_layout_core.WorkflowDragService)
+  (0, import_inversify.inject)(import_free_layout_core3.WorkflowDragService)
 ], WorkflowNodePanelService.prototype, "dragService", 2);
 __decorateClass([
-  (0, import_inversify.inject)(import_free_layout_core2.WorkflowSelectService)
+  (0, import_inversify.inject)(import_free_layout_core4.WorkflowSelectService)
 ], WorkflowNodePanelService.prototype, "selectService", 2);
 __decorateClass([
-  (0, import_inversify.inject)(import_free_layout_core.WorkflowLinesManager)
+  (0, import_inversify.inject)(import_free_layout_core3.WorkflowLinesManager)
 ], WorkflowNodePanelService.prototype, "linesManager", 2);
 __decorateClass([
-  (0, import_inversify.inject)(import_core.PlaygroundConfigEntity)
+  (0, import_inversify.inject)(import_core2.PlaygroundConfigEntity)
 ], WorkflowNodePanelService.prototype, "playgroundConfig", 2);
 __decorateClass([
-  (0, import_inversify.inject)(import_free_history_plugin.HistoryService)
+  (0, import_inversify.inject)(import_free_history_plugin2.HistoryService)
 ], WorkflowNodePanelService.prototype, "historyService", 2);
 WorkflowNodePanelService = __decorateClass([
   (0, import_inversify.injectable)()
@@ -461,13 +570,13 @@ WorkflowNodePanelService = __decorateClass([
 // src/layer.tsx
 var import_react = __toESM(require("react"));
 var import_inversify2 = require("inversify");
+var import_utils6 = require("@flowgram.ai/utils");
+var import_free_layout_core5 = require("@flowgram.ai/free-layout-core");
 var import_core3 = require("@flowgram.ai/core");
-var import_free_layout_core3 = require("@flowgram.ai/free-layout-core");
-var import_utils3 = require("@flowgram.ai/utils");
 var WorkflowNodePanelLayer = class extends import_core3.Layer {
   constructor() {
     super();
-    this.node = import_utils3.domUtils.createDivWithClass("gedit-playground-layer gedit-node-panel-layer");
+    this.node = import_utils6.domUtils.createDivWithClass("gedit-playground-layer gedit-node-panel-layer");
     this.node.style.zIndex = "9999";
     this.renderList = /* @__PURE__ */ new Map();
   }
@@ -485,8 +594,8 @@ var WorkflowNodePanelLayer = class extends import_core3.Layer {
     }));
   }
   async call(params) {
-    const taskId = (0, import_free_layout_core3.nanoid)();
-    const { enableMultiAdd, onSelect, onClose } = params;
+    const taskId = (0, import_free_layout_core5.nanoid)();
+    const { onSelect, onClose, enableMultiAdd = false, panelProps = {} } = params;
     return new Promise((resolve) => {
       const unmount = () => {
         this.renderList.delete(taskId);
@@ -505,6 +614,7 @@ var WorkflowNodePanelLayer = class extends import_core3.Layer {
       };
       const renderProps = {
         ...params,
+        panelProps,
         onSelect: handleSelect,
         onClose: handleClose
       };
@@ -536,6 +646,7 @@ var createFreeNodePanelPlugin = (0, import_core4.definePluginCreator)({
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   WorkflowNodePanelService,
+  WorkflowNodePanelUtils,
   createFreeNodePanelPlugin
 });
 //# sourceMappingURL=index.js.map