@difizen/ai-flow/es/stores/flowStore.js

Scalable, out-of-the-box, agent-oriented flow

function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
import { ControlMode, NodePanelTypeEnum } from "../interfaces/flow";
import { cleanEdges, getNodeId } from "../utils/reactflowUtils";
import { addEdge, applyEdgeChanges, applyNodeChanges } from '@xyflow/react';
import { produce } from 'immer';
import { cloneDeep } from 'lodash';
import { create } from 'zustand';
import { useFlowsManagerStore } from "./flowsManagerStore";
export var useFlowStore = create(function (set, get) {
  return {
    nodes: [],
    edges: [],
    nodePanel: NodePanelTypeEnum.Panel,
    setNodePanel: function setNodePanel(panel) {
      set({
        nodePanel: panel
      });
    },
    controlMode: localStorage.getItem('ai-workflow-operation-mode') === ControlMode.Pointer ? ControlMode.Pointer : ControlMode.Hand,
    setControlMode: function setControlMode(mode) {
      set({
        controlMode: mode
      });
      localStorage.setItem('ai-workflow-operation-mode', mode);
    },
    findUpstreamNodes: function findUpstreamNodes(targetNode) {
      var adjList = {};
      get().nodes.forEach(function (node) {
        adjList[node.id] = [];
      });
      get().edges.forEach(function (edge) {
        adjList[edge.target].push(edge.source);
      });
      var visited = new Set();
      var result = new Set();
      var dfs = function dfs(node) {
        if (visited.has(node)) {
          return;
        }
        visited.add(node);
        if (adjList[node]) {
          adjList[node].forEach(function (upstreamNode) {
            result.add(upstreamNode);
            dfs(upstreamNode);
          });
        }
      };
      dfs(targetNode);
      return get().nodes.filter(function (node) {
        return Array.from(result).includes(node.id);
      });
    },
    nodeLinkMap: {},
    calculateNodeLinkMap: function calculateNodeLinkMap() {
      set({
        nodeLinkMap: get().nodes.reduce(function (pre, node) {
          return _objectSpread(_objectSpread({}, pre), {}, _defineProperty({}, node.id, get().findUpstreamNodes(node.id)));
        }, {})
      });
    },
    initFlow: function initFlow(graph) {
      set({
        nodes: graph.nodes,
        edges: graph.edges
      });
      return {
        nodes: graph.nodes,
        edges: graph.edges
      };
    },
    reactFlowInstance: null,
    setReactFlowInstance: function setReactFlowInstance(newState) {
      set({
        reactFlowInstance: newState
      });
    },
    getFlow: function getFlow() {
      var _get$reactFlowInstanc, _get$reactFlowInstanc2;
      return {
        nodes: get().nodes,
        edges: get().edges,
        viewport: (_get$reactFlowInstanc = (_get$reactFlowInstanc2 = get().reactFlowInstance) === null || _get$reactFlowInstanc2 === void 0 ? void 0 : _get$reactFlowInstanc2.getViewport()) !== null && _get$reactFlowInstanc !== void 0 ? _get$reactFlowInstanc : {
          x: 0,
          y: 0,
          zoom: 1
        }
      };
    },
    onNodesChange: function onNodesChange(changes) {
      var newChanges = changes.filter(function (change) {
        return change.type !== 'position';
      });
      if (newChanges) {
        set({
          nodes: applyNodeChanges(newChanges, get().nodes)
        });
      }
    },
    setNodeFolded: function setNodeFolded(id, folded) {
      get().setNode(id, function (old) {
        return _objectSpread(_objectSpread({}, old), {}, {
          data: _objectSpread(_objectSpread({}, old.data), {}, {
            folded: folded
          })
        });
      });
    },
    onEdgesChange: function onEdgesChange(changes) {
      set({
        edges: applyEdgeChanges(changes, get().edges)
      });
    },
    setEdge: function setEdge(id, change) {
      var newChange = typeof change === 'function' ? change(get().edges.find(function (edge) {
        return edge.id === id;
      })) : change;
      get().setEdges(function (oldEdges) {
        return oldEdges.map(function (edge) {
          if (edge.id === id) {
            // if ((node.data as NodeDataType).node?.frozen) {
            //   (newChange.data as NodeDataType).node!.frozen = false;
            // }
            return newChange;
          }
          return edge;
        });
      });
    },
    setNode: function setNode(id, change) {
      var newChange = typeof change === 'function' ? change(get().nodes.find(function (node) {
        return node.id === id;
      })) : change;
      get().setNodes(function (oldNodes) {
        return oldNodes.map(function (node) {
          if (node.id === id) {
            return newChange;
          }
          return node;
        });
      });
    },
    setNodes: function setNodes(change) {
      var newChange = typeof change === 'function' ? change(get().nodes) : change;
      var newEdges = cleanEdges(newChange, get().edges);
      set({
        edges: newEdges,
        nodes: newChange
      });
      var _useFlowsManagerStore = useFlowsManagerStore.getState(),
        autoSaveFlow = _useFlowsManagerStore.autoSaveFlow;
      autoSaveFlow === null || autoSaveFlow === void 0 || autoSaveFlow();
    },
    setEdges: function setEdges(change) {
      var newChange = typeof change === 'function' ? change(get().edges) : change;
      set({
        edges: newChange
      });
      // calculate link map
      get().calculateNodeLinkMap();
      // autosave the flow
      var _useFlowsManagerStore2 = useFlowsManagerStore.getState(),
        autoSaveFlow = _useFlowsManagerStore2.autoSaveFlow;
      autoSaveFlow === null || autoSaveFlow === void 0 || autoSaveFlow();
    },
    getNode: function getNode(id) {
      return get().nodes.find(function (node) {
        return node.id === id;
      });
    },
    onConnect: function onConnect(connection) {
      var newEdges = [];
      get().setEdges(function (oldEdges) {
        newEdges = addEdge(_objectSpread(_objectSpread({}, connection), {}, {
          data: {
            targetHandle: connection.targetHandle,
            sourceHandle: connection.sourceHandle
          },
          type: 'custom'
        }), oldEdges);
        return newEdges;
      });
    },
    deleteNode: function deleteNode(nodeId) {
      get().setNodes(get().nodes.filter(function (node) {
        return typeof nodeId === 'string' ? node.id !== nodeId : !nodeId.includes(node.id);
      }));
      get().setEdges(get().edges.filter(function (edge) {
        return typeof nodeId === 'string' ? edge.source !== nodeId && edge.target !== nodeId : !nodeId.includes(edge.source) && !nodeId.includes(edge.target);
      }));
    },
    deleteEdge: function deleteEdge(edgeId) {
      get().setEdges(get().edges.filter(function (edge) {
        return typeof edgeId === 'string' ? edge.id !== edgeId : !edgeId.includes(edge.id);
      }));
    },
    paste: function paste(selection, position) {
      // TODO:页面唯一节点检测
      // if (selection.nodes.some((node) => node.data.type === 'start')) {
      //   useAlertStore.getState().setErrorData({
      //     title: 'Error pasting components',
      //     list: ['You can only have one Start Node in the flow'],
      //   });
      //   return;
      // }

      var minimumX = Infinity;
      var minimumY = Infinity;
      // let idsMap = {};
      var newNodes = get().nodes;
      // let newEdges = get().edges;
      selection.nodes.forEach(function (node) {
        if (node.position.y < minimumY) {
          minimumY = node.position.y;
        }
        if (node.position.x < minimumX) {
          minimumX = node.position.x;
        }
      });
      var insidePosition = position.paneX ? {
        x: position.paneX + position.x,
        y: position.paneY + position.y
      } : get().reactFlowInstance.screenToFlowPosition({
        x: position.x,
        y: position.y
      });
      selection.nodes.forEach(function (node) {
        var newId = getNodeId(node.data['type']);
        var newNode = {
          id: newId,
          type: node.data['type'],
          position: {
            x: insidePosition.x + node.position.x - minimumX,
            y: insidePosition.y + node.position.y - minimumY
          },
          data: _objectSpread(_objectSpread({}, cloneDeep(node.data)), {}, {
            id: newId
          })
        };

        // updateGroupRecursion(
        //   newNode,
        //   selection.edges,
        //   useGlobalVariablesStore.getState().unavaliableFields,
        //   useGlobalVariablesStore.getState().globalVariablesEntries,
        // );

        // Add the new node to the list of nodes in state
        newNodes = newNodes
        // eslint-disable-next-line @typescript-eslint/no-shadow
        .map(function (node) {
          return _objectSpread(_objectSpread({}, node), {}, {
            selected: false
          });
        }).concat(_objectSpread(_objectSpread({}, newNode), {}, {
          selected: false
        }));
      });
      get().setNodes(newNodes);

      // selection.edges.forEach((edge: Edge) => {
      //   let source = edge.source;
      //   let target = edge.target;
      //   const sourceHandleObject: sourceHandleType = scapeJSONParse(
      //     edge.sourceHandle!
      //   );
      //   let sourceHandle = scapedJSONStringfy({
      //     ...sourceHandleObject,
      //     id: source,
      //   });
      //   sourceHandleObject.id = source;

      //   edge.data.sourceHandle = sourceHandleObject;
      //   const targetHandleObject: targetHandleType = scapeJSONParse(
      //     edge.targetHandle!
      //   );
      //   let targetHandle = scapedJSONStringfy({
      //     ...targetHandleObject,
      //     id: target,
      //   });
      //   targetHandleObject.id = target;
      //   edge.data.targetHandle = targetHandleObject;
      //   let id = getHandleId(source, sourceHandle, target, targetHandle);
      //   newEdges = addEdge(
      //     {
      //       source,
      //       target,
      //       sourceHandle,
      //       targetHandle,
      //       id,
      //       data: cloneDeep(edge.data),
      //       selected: false,
      //     },
      //     newEdges.map((edge) => ({ ...edge, selected: false }))
      //   );
      // });
      // get().setEdges(newEdges);
    },
    lastCopiedSelection: null,
    setLastCopiedSelection: function setLastCopiedSelection(newSelection) {
      var isCrop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      if (isCrop && newSelection) {
        var nodesIdsSelected = newSelection.nodes.map(function (node) {
          return node.id;
        });
        var edgesIdsSelected = newSelection.edges.map(function (edge) {
          return edge.id;
        });
        nodesIdsSelected.forEach(function (id) {
          get().deleteNode(id);
        });
        edgesIdsSelected.forEach(function (id) {
          get().deleteEdge(id);
        });
        var newNodes = get().nodes.filter(function (node) {
          return !nodesIdsSelected.includes(node.id);
        });
        var newEdges = get().edges.filter(function (edge) {
          return !edgesIdsSelected.includes(edge.id);
        });
        set({
          nodes: newNodes,
          edges: newEdges
        });
      }
      set({
        lastCopiedSelection: newSelection
      });
    },
    handleNodeEdited: function handleNodeEdited(nodeId, cancelEdited) {
      var newNodes = produce(get().nodes, function (draft) {
        draft.forEach(function (node) {
          if (node.id === nodeId) node.data.edited = !cancelEdited;else node.data.edited = false;
        });
      });
      get().setNodes(newNodes);
    }
  };
});