flow-lib-creomnia 1.0.7 → 1.0.8-dev.2

package/lib/modules/node/enums/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeMenuItemType = exports.NodeTypeEnum = void 0;
+var NodeTypeEnum;
+(function (NodeTypeEnum) {
+    NodeTypeEnum["BaseNode"] = "baseNode";
+    NodeTypeEnum["StartNode"] = "startNode";
+    NodeTypeEnum["EndNode"] = "endNode";
+    NodeTypeEnum["HubNode"] = "hubNode";
+    NodeTypeEnum["ChoiceNode"] = "choiceNode";
+    NodeTypeEnum["ParallelNode"] = "parallelNode";
+})(NodeTypeEnum || (exports.NodeTypeEnum = NodeTypeEnum = {}));
+var NodeMenuItemType;
+(function (NodeMenuItemType) {
+    NodeMenuItemType["EXTENSION"] = "extension";
+    NodeMenuItemType["AI_AGENT"] = "ai-agent";
+})(NodeMenuItemType || (exports.NodeMenuItemType = NodeMenuItemType = {}));

package/lib/modules/node/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { NodeTypeEnum } from './enums';
+import { BaseDrawableNodeType } from './types';
+type ModuleType = {
+    nodes: {
+        [key in NodeTypeEnum]: React.FC<BaseDrawableNodeType>;
+    };
+};
+export declare const nodeModule: ModuleType;
+export {};

package/lib/modules/node/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeModule = void 0;
+const BaseNode_1 = __importDefault(require("./components/BaseNode"));
+const ChoiseNode_1 = __importDefault(require("./components/ChoiseNode"));
+const EndNode_1 = __importDefault(require("./components/EndNode"));
+const HubNode_1 = __importDefault(require("./components/HubNode"));
+const ParallelNode_1 = __importDefault(require("./components/ParallelNode"));
+const StartNode_1 = __importDefault(require("./components/StartNode"));
+exports.nodeModule = {
+    nodes: {
+        startNode: StartNode_1.default,
+        baseNode: BaseNode_1.default,
+        endNode: EndNode_1.default,
+        hubNode: HubNode_1.default,
+        choiceNode: ChoiseNode_1.default,
+        parallelNode: ParallelNode_1.default
+    },
+};

package/lib/modules/node/services/expandCoefficientServices.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { NodeType } from '../types';
+declare class ExpandCoefficientServices {
+    calculateNodeExpandCoefficient: (nodes: NodeType[]) => {
+        expandCoefficient: number;
+        id: string;
+        name?: string | undefined;
+        nodeType?: string | undefined;
+        description?: string | undefined;
+        icon?: JSX.Element | undefined;
+        type: import("../enums").NodeTypeEnum;
+        childrenIds?: string[] | undefined;
+        parentIds?: string[] | undefined;
+        settings?: import("../types").SettingsType | undefined;
+        startSectionNodeId?: string | undefined;
+        endSectionNodeId?: string | undefined;
+        blockedChildrenIds?: string[] | undefined;
+        leftChildrenId?: string | undefined;
+        rightChildrenId?: string | undefined;
+        childFlowId?: string | undefined;
+    }[];
+}
+export declare const expandCoefficientServices: ExpandCoefficientServices;
+export {};

package/lib/modules/node/services/expandCoefficientServices.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandCoefficientServices = void 0;
+const config_1 = require("../../../config");
+class ExpandCoefficientServices {
+    calculateNodeExpandCoefficient = (nodes) => {
+        const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+        const calculateNodeExpandCoefficientRecursion = ({ startNode, expandCoefficient, indexOfEncapsulation, }) => {
+            if (!startNode.childrenIds?.length ||
+                (startNode.startSectionNodeId && indexOfEncapsulation <= 0)) {
+                return expandCoefficient;
+            }
+            if (startNode.startSectionNodeId && indexOfEncapsulation > 0) {
+                const childrenNodes = (startNode.childrenIds || [])
+                    .map((id) => nodeMap.get(id))
+                    .filter((node) => !!node);
+                const nextExpandCoefficient = calculateNodeExpandCoefficientRecursion({
+                    startNode: childrenNodes[0],
+                    expandCoefficient: 0,
+                    indexOfEncapsulation: indexOfEncapsulation - 1,
+                });
+                return Math.max(expandCoefficient, nextExpandCoefficient);
+            }
+            const childrenNodes = (startNode.childrenIds || [])
+                .map((id) => nodeMap.get(id))
+                .filter((node) => !!node);
+            const childrenNodesExpandCoefficient = childrenNodes.map((node) => {
+                const isExpandable = config_1.Config.NODES_WITH_DOUBLE_CONNECTION.includes(startNode.type);
+                const calculatedExpandCoefficient = isExpandable
+                    ? expandCoefficient + 1
+                    : expandCoefficient;
+                return calculateNodeExpandCoefficientRecursion({
+                    startNode: node,
+                    expandCoefficient: calculatedExpandCoefficient,
+                    indexOfEncapsulation: (startNode.childrenIds?.length || 0) > 1
+                        ? indexOfEncapsulation + 1
+                        : indexOfEncapsulation,
+                });
+            });
+            return Math.max(...childrenNodesExpandCoefficient);
+        };
+        return nodes.map((node) => ({
+            ...node,
+            expandCoefficient: calculateNodeExpandCoefficientRecursion({
+                startNode: node,
+                expandCoefficient: 0,
+                indexOfEncapsulation: 0,
+            }),
+        }));
+    };
+}
+exports.expandCoefficientServices = new ExpandCoefficientServices();

package/lib/modules/node/services/nodeServices.d.ts

@@ -0,0 +1,11 @@
+import { BaseDrawableNodeType, NodeType } from '../types';
+import { NodeCalculationServices } from './pointCalculationServices';
+declare class NodeServices extends NodeCalculationServices {
+    combineNodes: (currentNodes: NodeType[], nodes: NodeType[]) => BaseDrawableNodeType[];
+    createListOfStartNodesAndEndNodes: (nodes: NodeType[]) => {
+        startNodeList: NodeType[];
+        nodeListWithEndNode: NodeType[];
+    };
+}
+export declare const nodeServices: NodeServices;
+export {};

package/lib/modules/node/services/nodeServices.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeServices = void 0;
+const enums_1 = require("../enums");
+const pointCalculationServices_1 = require("./pointCalculationServices");
+class NodeServices extends pointCalculationServices_1.NodeCalculationServices {
+    combineNodes = (currentNodes, nodes) => {
+        const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+        const hubNodes = nodes.reduce((hubNodes, node) => {
+            if (node.startSectionNodeId) {
+                return {
+                    ...hubNodes,
+                    [node.id]: {
+                        awaitedIds: [],
+                        expectedLength: node.parentIds?.length || 0,
+                    },
+                };
+            }
+            return hubNodes;
+        }, {});
+        const combineNodesRecursion = ({ currentNodes, combinedNodes, hubNodes, iteration, }) => {
+            if (currentNodes.length === 0) {
+                return combinedNodes;
+            }
+            const nextNodes = currentNodes.reduce((nextNode, currentNode) => {
+                const childrenIds = currentNode.childrenIds || [];
+                const childNodes = childrenIds
+                    .map((childId) => {
+                    return nodeMap.get(childId) || [];
+                })
+                    .flat();
+                const blockedChildrenIds = currentNode.blockedChildrenIds || [];
+                const nextNodes = childNodes.filter((childNode) => {
+                    return !blockedChildrenIds.includes(childNode.id);
+                });
+                return [...nextNode, ...nextNodes];
+            }, []);
+            const { childrenNodes, updatedHubNodes } = nextNodes.reduce(({ childrenNodes, updatedHubNodes, }, nextNode) => {
+                const hubNodeChildIds = Object.keys(updatedHubNodes).filter((hubNodeId) => nextNode.childrenIds?.includes(hubNodeId));
+                if (hubNodeChildIds.length > 0) {
+                    const hubNodeList = hubNodeChildIds.map((hubNodeId) => {
+                        return {
+                            [hubNodeId]: {
+                                awaitedIds: [
+                                    ...updatedHubNodes[hubNodeId].awaitedIds,
+                                    nextNode.id,
+                                ],
+                                expectedLength: updatedHubNodes[hubNodeId].expectedLength,
+                            },
+                        };
+                    });
+                    const newUpdatedHubNodes = hubNodeList.reduce((newUpdatedHubNodes, hubNodeListItem) => {
+                        return {
+                            ...newUpdatedHubNodes,
+                            ...hubNodeListItem,
+                        };
+                    }, updatedHubNodes);
+                    const currentHubNodeRecord = Object.entries(newUpdatedHubNodes).find((hubNodeRecord) => hubNodeRecord[1].awaitedIds.includes(nextNode.id));
+                    const [currentHubNodeId, currentHubNodeData] = currentHubNodeRecord;
+                    const isFull = currentHubNodeData?.awaitedIds.length ===
+                        currentHubNodeData?.expectedLength;
+                    return {
+                        childrenNodes: isFull
+                            ? [...childrenNodes, nextNode]
+                            : [
+                                ...childrenNodes,
+                                { ...nextNode, blockedChildrenIds: [currentHubNodeId] },
+                            ],
+                        updatedHubNodes: {
+                            ...updatedHubNodes,
+                            [currentHubNodeId]: currentHubNodeData,
+                        },
+                    };
+                }
+                return {
+                    childrenNodes: [...childrenNodes, nextNode],
+                    updatedHubNodes,
+                };
+            }, {
+                childrenNodes: [],
+                updatedHubNodes: hubNodes,
+            });
+            const combinedNodesMap = new Map(combinedNodes.map((n) => [n.id, n]));
+            const drawableNodes = currentNodes.map((node) => {
+                const startSectionNodeId = node.startSectionNodeId;
+                const parent = startSectionNodeId
+                    ? combinedNodesMap.get(startSectionNodeId)
+                    : combinedNodes.find((parentNode) => parentNode.nodeData?.childrenIds?.includes(node.id));
+                // TODO it works when node has 2 children but should be refactored
+                const isSecondBranch = parent?.nodeData?.rightChildrenId === node.id;
+                const renderPoint = this.calculatePoint({
+                    layer: iteration,
+                    currentNodeNumber: isSecondBranch ? 1 : 0,
+                    parentPositionX: parent?.renderPoint?.x,
+                    expandCoefficient: node.expandCoefficient || 0,
+                    childrenInRow: parent?.nodeData?.childrenIds?.length || 0,
+                    isHubNode: !!startSectionNodeId,
+                });
+                return {
+                    id: node.id,
+                    renderPoint,
+                    nodeData: node,
+                    type: node.type,
+                };
+            });
+            return combineNodesRecursion({
+                currentNodes: childrenNodes,
+                combinedNodes: [...combinedNodes, ...drawableNodes],
+                hubNodes: updatedHubNodes,
+                iteration: iteration + 1,
+            });
+        };
+        return combineNodesRecursion({
+            currentNodes,
+            combinedNodes: [],
+            hubNodes,
+            iteration: 0,
+        });
+    };
+    createListOfStartNodesAndEndNodes = (nodes) => {
+        const possibleFirstNode = nodes.find((node) => !node.parentIds?.length || node.parentIds?.length === 0);
+        const lastNodes = nodes.filter((node) => node.childrenIds?.length === 0);
+        const lastNodesIds = lastNodes.length
+            ? lastNodes.map((node) => node.id)
+            : ['startNode'];
+        const startNodeList = [
+            {
+                id: 'startNode',
+                childrenIds: possibleFirstNode ? [possibleFirstNode.id] : ['endNode'],
+                parentIds: [],
+                type: enums_1.NodeTypeEnum.StartNode,
+                expandCoefficient: 0,
+            },
+        ];
+        const nodeListWithEndNode = [
+            ...nodes.map((node) => node.childrenIds?.length ? node : { ...node, childrenIds: ['endNode'] }),
+            {
+                id: 'endNode',
+                childrenIds: [],
+                parentIds: lastNodesIds,
+                type: enums_1.NodeTypeEnum.EndNode,
+            },
+        ];
+        return { startNodeList, nodeListWithEndNode };
+    };
+}
+exports.nodeServices = new NodeServices();

package/lib/modules/node/services/pointCalculationServices.d.ts

@@ -0,0 +1,11 @@
+import { PointType } from '../../common/types';
+export declare class NodeCalculationServices {
+    protected calculatePoint: ({ layer, currentNodeNumber, parentPositionX, expandCoefficient, childrenInRow, isHubNode, }: {
+        layer: number;
+        currentNodeNumber: number;
+        parentPositionX?: number | undefined;
+        expandCoefficient: number;
+        childrenInRow: number;
+        isHubNode: boolean;
+    }) => PointType;
+}

package/lib/modules/node/services/pointCalculationServices.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCalculationServices = void 0;
+const config_1 = require("../../../config");
+class NodeCalculationServices {
+    calculatePoint = ({ layer, currentNodeNumber, parentPositionX, expandCoefficient, childrenInRow, isHubNode, }) => {
+        const startPoint = parentPositionX
+            ? parentPositionX
+            : window.screen.width / 2;
+        const expand = Math.pow(childrenInRow, expandCoefficient);
+        const shift = expand * config_1.Config.HORIZONTAL_SHIFT;
+        return {
+            x: isHubNode
+                ? startPoint
+                : startPoint -
+                    (shift * (childrenInRow - 1)) / 2 +
+                    shift * currentNodeNumber,
+            y: config_1.Config.VERTICAL_SHIFT + layer * config_1.Config.VERTICAL_SHIFT,
+        };
+    };
+}
+exports.NodeCalculationServices = NodeCalculationServices;

package/lib/modules/node/types/index.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="react" />
+import { PointType, UpdateNodePosition } from '../../common/types';
+import { NodeTypeEnum } from '../enums';
+export type NodesFooterType = {
+    saveText?: string;
+    cancelText?: string;
+    deleteText?: string;
+    onSave?: (nodeId: string) => void | false;
+    onCancel?: (nodeId: string) => void;
+    onDelete?: (nodeId: string) => void;
+};
+export type SettingsType = {
+    settingsForm?: JSX.Element;
+    footer?: NodesFooterType;
+    customFooter?: JSX.Element;
+};
+export type NodeType = {
+    id: string;
+    name?: string;
+    nodeType?: string;
+    description?: string;
+    icon?: JSX.Element;
+    type: NodeTypeEnum;
+    childrenIds?: string[];
+    parentIds?: string[];
+    settings?: SettingsType;
+    expandCoefficient?: number;
+    startSectionNodeId?: string;
+    endSectionNodeId?: string;
+    blockedChildrenIds?: string[];
+    leftChildrenId?: string;
+    rightChildrenId?: string;
+    childFlowId?: string;
+};
+export type BaseDrawableNodeType = {
+    renderPoint: PointType;
+    nodeData?: NodeType;
+    id: string;
+    type: NodeTypeEnum;
+    isProcessed?: boolean;
+    isFailed?: boolean;
+    failedNodeColor?: string;
+    onRedirect?: (flowId: string) => void;
+    onUpdatePosition?: UpdateNodePosition;
+};
+export type SettingsContextValueType = {
+    node: NodeType | null;
+    setNode: (node: NodeType | null) => void;
+};

package/lib/modules/node/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flow-lib-creomnia",
-  "version": "1.0.7",
+  "version": "1.0.8-dev.2",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",