flow-lib-creomnia 1.0.0

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;
+        extensionName?: 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,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandCoefficientServices = void 0;
+const config_1 = require("../../../config");
+class ExpandCoefficientServices {
+    calculateNodeExpandCoefficient = (nodes) => {
+        const calculateNodeExpandCoefficientRecursion = ({ startNode, expandCoefficient, indexOfEncapsulation, }) => {
+            if (!startNode.childrenIds?.length ||
+                (startNode.startSectionNodeId && indexOfEncapsulation <= 0)) {
+                return expandCoefficient;
+            }
+            if (startNode.startSectionNodeId && indexOfEncapsulation > 0) {
+                const childrenNodes = nodes.filter((node) => startNode.childrenIds?.includes(node.id));
+                const nextExpandCoefficient = calculateNodeExpandCoefficientRecursion({
+                    startNode: childrenNodes[0],
+                    expandCoefficient: 0,
+                    indexOfEncapsulation: indexOfEncapsulation - 1,
+                });
+                return Math.max(expandCoefficient, nextExpandCoefficient);
+            }
+            const childrenNodes = nodes.filter((node) => startNode.childrenIds?.includes(node.id));
+            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,145 @@
+"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 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 nodes.find((node) => node.id === 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 drawableNodes = currentNodes.map((node) => {
+                const startSectionNodeId = node.startSectionNodeId;
+                const parent = startSectionNodeId
+                    ? combinedNodes.find((node) => node.id === 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;
+    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;
+    extensionName?: 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

@@ -0,0 +1,65 @@
+{
+  "name": "flow-lib-creomnia",
+  "version": "1.0.0",
+  "description": "",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "private": false,
+  "scripts": {
+    "test": "jest --config jestconfig.json",
+    "clean": "rm -rf ./lib",
+    "copy-files": "cp -R src/assets lib/assets",
+    "build": "npm run clean && tsc && npm run copy-files",
+    "publish-package": "npm run build && npm publish"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/plugin-proposal-private-property-in-object": "^7.21.11",
+    "@types/jest": "^29.5.2",
+    "@types/react": "^18.2.12",
+    "@types/react-dom": "^18.2.5",
+    "@types/react-svg": "^5.0.0",
+    "jest": "^29.5.0",
+    "prettier": "^2.8.8",
+    "prop-types": "^15.8.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "ts-jest": "^29.1.0",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^5.1.3"
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "peerDependencies": {
+    "@emotion/react": "^11.11.1",
+    "@emotion/styled": "^11.11.0",
+    "@mui/icons-material": "^5.11.16",
+    "@mui/material": "^5.13.5",
+    "@mui/styled-engine-sc": "^5.12.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-svg": "^16.1.17",
+    "styled-components": "^5.3.11"
+  },
+  "dependencies": {
+    "@emotion/react": "^11.11.1",
+    "@emotion/styled": "^11.11.0",
+    "@mui/icons-material": "^5.11.16",
+    "@mui/material": "^5.13.5",
+    "@mui/styled-engine-sc": "^5.12.0",
+    "@react-spring/rafz": "^9.7.3",
+    "@react-spring/web": "^9.7.3",
+    "react": "^18.2.0",
+    "react-dnd": "^16.0.1",
+    "react-dnd-html5-backend": "^16.0.1",
+    "react-dom": "^18.2.0",
+    "react-svg": "^16.1.17",
+    "react-zoom-pan-pinch": "^3.3.0",
+    "styled-components": "^5.3.11"
+  },
+  "readme": "ERROR: No README data found!"
+}