@agentscope-ai/flow 0.0.1

package/dist/hooks/use-flow-key-press.js

@@ -0,0 +1,32 @@
+import { isEventInInput, transformToMacKey } from "../utils";
+import { useReactFlow } from '@xyflow/react';
+import { useKeyPress } from 'ahooks';
+import { useNodesReadOnly } from "./use-work-flow";
+export default function useFlowKeyPress() {
+  var reactFlow = useReactFlow();
+  var _useNodesReadOnly = useNodesReadOnly(),
+    nodesReadOnly = _useNodesReadOnly.nodesReadOnly;
+  useKeyPress(["".concat(transformToMacKey('ctrl'), ".d"), 'delete'], function (event) {
+    event.preventDefault();
+    if (isEventInInput(event) || nodesReadOnly) return;
+    var needDeleteNodes = [];
+    var needDeleteEdges = [];
+    var nodes = reactFlow.getNodes();
+    var edges = reactFlow.getEdges();
+    nodes.forEach(function (item) {
+      if (item.selected) needDeleteNodes.push({
+        id: item.id
+      });
+    });
+    edges.forEach(function (item) {
+      if (item.selected) needDeleteEdges.push({
+        id: item.id
+      });
+    });
+    if (!needDeleteNodes.length && !needDeleteEdges) return;
+    reactFlow.deleteElements({
+      nodes: needDeleteNodes,
+      edges: needDeleteEdges
+    });
+  });
+}

package/dist/hooks/use-flow-save.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="lodash" />
+export declare const useFlowSave: () => {
+    handleSaveFlowDraft: import("lodash-es").DebouncedFunc<() => void>;
+    onFlowChange: () => void;
+};

package/dist/hooks/use-flow-save.js

@@ -0,0 +1,47 @@
+import { useStore } from "../flow/context";
+import { useStoreApi } from '@xyflow/react';
+import { debounce } from 'lodash-es';
+import { useCallback } from 'react';
+import { useHistory } from "./use-history";
+export var useFlowSave = function useFlowSave() {
+  var store = useStoreApi();
+  var onFlowDataChange = useStore(function (state) {
+    return state.onChange;
+  });
+  var onFlowDataDebounceChange = useStore(function (state) {
+    return state.onDebounceChange;
+  });
+  var debounceChangeTimeout = useStore(function (state) {
+    return state.debounceChangeTimeout;
+  });
+  var _useHistory = useHistory(),
+    addHistoryStep = _useHistory.addHistoryStep;
+  var handleSaveFlowDraft = useCallback(debounce(function () {
+    var _store$getState = store.getState(),
+      nodes = _store$getState.nodes,
+      edges = _store$getState.edges;
+    addHistoryStep({
+      nodes: nodes,
+      edges: edges
+    });
+    if (!onFlowDataDebounceChange) return;
+    onFlowDataDebounceChange({
+      nodes: nodes,
+      edges: edges
+    });
+  }, debounceChangeTimeout), [store, addHistoryStep, onFlowDataDebounceChange]);
+  var onFlowChange = useCallback(function () {
+    var _store$getState2 = store.getState(),
+      nodes = _store$getState2.nodes,
+      edges = _store$getState2.edges;
+    onFlowDataChange({
+      nodes: nodes,
+      edges: edges
+    });
+    handleSaveFlowDraft();
+  }, [handleSaveFlowDraft, store, onFlowDataChange]);
+  return {
+    handleSaveFlowDraft: handleSaveFlowDraft,
+    onFlowChange: onFlowChange
+  };
+};

package/dist/hooks/use-flow-view-port.d.ts

@@ -0,0 +1,7 @@
+export declare const MIN_ZOOM = 0.1;
+export declare const MAX_ZOOM = 2;
+export declare const useFlowViewPort: () => {
+    handleScale: (options: 1 | -1) => void;
+    scaleRate: number;
+    handleSetScale: (scale: number) => void;
+};

package/dist/hooks/use-flow-view-port.js

@@ -0,0 +1,46 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useStore } from "../flow/context";
+import { useReactFlow, useViewport } from '@xyflow/react';
+import { useCallback, useMemo } from 'react';
+export var MIN_ZOOM = 0.1;
+export var MAX_ZOOM = 2;
+export var useFlowViewPort = function useFlowViewPort() {
+  var reactFlow = useReactFlow();
+  var handleSetScale = useCallback(function (scale) {
+    var _reactFlow$getViewpor = reactFlow.getViewport(),
+      x = _reactFlow$getViewpor.x,
+      y = _reactFlow$getViewpor.y;
+    reactFlow.setViewport({
+      zoom: scale,
+      x: x,
+      y: y
+    });
+  }, [reactFlow]);
+  var minMaxZoom = useStore(function (state) {
+    return state.minMaxZoom;
+  });
+  var handleScale = useCallback(function (options) {
+    var _reactFlow$getViewpor2 = reactFlow.getViewport(),
+      zoom = _reactFlow$getViewpor2.zoom;
+    var newZoom = parseFloat(zoom.toFixed(1)) + options * 0.2;
+    var _minMaxZoom = _slicedToArray(minMaxZoom, 2),
+      minZoom = _minMaxZoom[0],
+      maxZoom = _minMaxZoom[1];
+    handleSetScale(Math.max(minZoom, Math.min(newZoom, maxZoom)));
+  }, [reactFlow, handleSetScale]);
+  var _useViewport = useViewport(),
+    zoom = _useViewport.zoom;
+  var scaleRate = useMemo(function () {
+    return parseInt("".concat(zoom * 100));
+  }, [zoom]);
+  return {
+    handleScale: handleScale,
+    scaleRate: scaleRate,
+    handleSetScale: handleSetScale
+  };
+};

package/dist/hooks/use-history.d.ts

@@ -0,0 +1,21 @@
+import { Edge } from '@xyflow/react';
+import { IWorkFlowNode } from '../types/work-flow';
+interface IHistoryStep {
+    edges: Edge[];
+    nodes: IWorkFlowNode[];
+}
+export declare const useHistory: () => {
+    canUndo: boolean;
+    canRedo: boolean;
+    addHistoryStep: (step: IHistoryStep) => void;
+    undo: () => {
+        edges: Edge[];
+        nodes: IWorkFlowNode[];
+    } | null;
+    redo: () => {
+        edges: Edge[];
+        nodes: IWorkFlowNode[];
+    } | null;
+    initHistoryStep: (step: IHistoryStep) => void;
+};
+export {};

package/dist/hooks/use-history.js

@@ -0,0 +1,80 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { useStore } from "../flow/context";
+import { useStoreApi } from '@xyflow/react';
+import { useCallback } from 'react';
+export var useHistory = function useHistory() {
+  var historySteps = useStore(function (state) {
+    return state.historySteps;
+  });
+  var setHistorySteps = useStore(function (state) {
+    return state.setHistorySteps;
+  });
+  var futureSteps = useStore(function (state) {
+    return state.futureSteps;
+  });
+  var setFutureSteps = useStore(function (state) {
+    return state.setFutureSteps;
+  });
+  var onDebounceChange = useStore(function (state) {
+    return state.onDebounceChange;
+  });
+  var store = useStoreApi();
+  var canUndo = historySteps.length > 1;
+  var canRedo = futureSteps.length > 0;
+  var initHistoryStep = useCallback(function (step) {
+    setHistorySteps([step]);
+    setFutureSteps([]);
+  }, [setHistorySteps, setFutureSteps]);
+  var addHistoryStep = useCallback(function (step) {
+    setHistorySteps([].concat(_toConsumableArray(historySteps), [step]));
+    setFutureSteps([]);
+  }, [historySteps, setHistorySteps, setFutureSteps]);
+  var undo = useCallback(function () {
+    if (!canUndo) return null;
+    var removedStep = historySteps[historySteps.length - 1];
+    var newHistorySteps = historySteps.slice(0, -1);
+    var currentStep = newHistorySteps[newHistorySteps.length - 1];
+    setHistorySteps(newHistorySteps);
+    setFutureSteps([removedStep].concat(_toConsumableArray(futureSteps)));
+    var _store$getState = store.getState(),
+      setNodes = _store$getState.setNodes,
+      setEdges = _store$getState.setEdges;
+    setNodes(currentStep.nodes);
+    setEdges(currentStep.edges);
+    onDebounceChange === null || onDebounceChange === void 0 || onDebounceChange({
+      nodes: currentStep.nodes,
+      edges: currentStep.edges
+    });
+    return currentStep;
+  }, [historySteps, futureSteps, setHistorySteps, setFutureSteps, canUndo]);
+  var redo = useCallback(function () {
+    if (!canRedo) return null;
+    var nextStep = futureSteps[0];
+    var newFutureSteps = futureSteps.slice(1);
+    setFutureSteps(newFutureSteps);
+    setHistorySteps([].concat(_toConsumableArray(historySteps), [nextStep]));
+    var _store$getState2 = store.getState(),
+      setNodes = _store$getState2.setNodes,
+      setEdges = _store$getState2.setEdges;
+    setNodes(nextStep.nodes);
+    setEdges(nextStep.edges);
+    onDebounceChange === null || onDebounceChange === void 0 || onDebounceChange({
+      nodes: nextStep.nodes,
+      edges: nextStep.edges
+    });
+    return nextStep;
+  }, [historySteps, futureSteps, setHistorySteps, setFutureSteps, canRedo]);
+  return {
+    canUndo: canUndo,
+    canRedo: canRedo,
+    addHistoryStep: addHistoryStep,
+    undo: undo,
+    redo: redo,
+    initHistoryStep: initHistoryStep
+  };
+};

package/dist/hooks/use-nodes-interaction.d.ts

@@ -0,0 +1,34 @@
+import { IPointItem, IWorkFlowNode } from "../types/work-flow";
+import type { Connection, NodeMouseHandler, OnNodeDrag, OnNodesChange } from '@xyflow/react';
+export declare const useNodesInteraction: () => {
+    onConnect: (connection: Connection) => void;
+    onAddNewNode: ({ type, parentId, parentNodeType, }: {
+        type: string;
+        parentId?: string | undefined;
+        parentNodeType?: string | undefined;
+    }, position: {
+        x: number;
+        y: number;
+    }) => Promise<void>;
+    onNodeDrag: OnNodeDrag;
+    onAddNewNodeWithSource: ({ type, parentId }: {
+        type: string;
+        parentId?: string | undefined;
+    }, source: IPointItem, target?: IPointItem) => Promise<void>;
+    onNodesChange: OnNodesChange;
+    onNodeClick: NodeMouseHandler<IWorkFlowNode>;
+    handleNodeClick: (node: IWorkFlowNode) => void;
+    handleSelectNode: (nodeId: string) => void;
+    onNodeResize: (resizeBound: {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    }, nodeId: string) => void;
+    onNodeDelete: (nodeId: string) => void;
+    onNodeCopy: (nodeId: string) => void;
+    handleNodeClickByNodeId: (nodeId: string) => void;
+    updateParentNodeSize: (nodeId: string) => void;
+    onDrop: (event: React.DragEvent<HTMLDivElement>, parentId?: string) => void;
+    onDragOver: (event: React.DragEvent<HTMLDivElement>) => void;
+};