landscape-widget 0.2.0 → 0.3.0-alpha

package/lib/IterateNoIntercomponentRepel.js

@@ -0,0 +1,282 @@
+/* eslint no-constant-condition: 0 */
+/* eslint no-restricted-properties: "warn" */
+/* eslint prefer-destructuring: "warn" */
+/* eslint no-param-reassign: "warn" */
+/**
+ * Graphology ForceAtlas2 Iteration
+ * =================================
+ *
+ * Function used to perform a single iteration of the algorithm.
+ */
+import { NODE_X, NODE_Y, NODE_DX, NODE_DY, NODE_FIXED, NODE_SIZE, NODE_MASS, NODE_CONVERGENCE, NODE_OLD_DX, NODE_OLD_DY, PPN, PPE, EDGE_SOURCE, EDGE_TARGET, EDGE_WEIGHT, } from './enum/layout';
+const MAX_FORCE = 10;
+/**
+ * Function used to calculate dx, dy for each node due to repulsion forces.
+ *
+ * @param  {object}       options    - Layout options.
+ * @param  {Float32Array} NodeMatrix - Node data. (operates in place)
+ * @param  {string[][]} graphComponents - Graph data.
+ * @return {object}                  - Some metadata.
+ */
+function getMovementDifferentialsDueToRepulsion(options, NodeMatrix, graphComponents) {
+    var _a;
+    const coefficient = (_a = options.scalingRatio) !== null && _a !== void 0 ? _a : 1;
+    const adjustSizes = options.adjustSizes;
+    let xDist;
+    let yDist;
+    let distance;
+    let factor;
+    let n1;
+    let n2;
+    if (adjustSizes === true) {
+        graphComponents.forEach((component) => {
+            for (let i = 0; i < component.length; i += 1) {
+                n1 = Number(component[i]) * PPN;
+                for (let j = 0; j < i; j += 1) {
+                    n2 = Number(component[j]) * PPN;
+                    xDist = NodeMatrix[n1 + NODE_X] - NodeMatrix[n2 + NODE_X];
+                    yDist = NodeMatrix[n1 + NODE_Y] - NodeMatrix[n2 + NODE_Y];
+                    // -- Anticollision Linear Repulsion
+                    distance =
+                        Math.sqrt(xDist * xDist + yDist * yDist) -
+                            NodeMatrix[n1 + NODE_SIZE] -
+                            NodeMatrix[n2 + NODE_SIZE];
+                    if (distance > 0) {
+                        factor =
+                            (coefficient * NodeMatrix[n1 + NODE_MASS] * NodeMatrix[n2 + NODE_MASS]) /
+                                distance /
+                                distance;
+                        // Updating nodes' dx and dy
+                        NodeMatrix[n1 + NODE_DX] += xDist * factor;
+                        NodeMatrix[n1 + NODE_DY] += yDist * factor;
+                        NodeMatrix[n2 + NODE_DX] -= xDist * factor;
+                        NodeMatrix[n2 + NODE_DY] -= yDist * factor;
+                    }
+                    else if (distance < 0) {
+                        factor = 100 * coefficient * NodeMatrix[n1 + NODE_MASS] * NodeMatrix[n2 + NODE_MASS];
+                        // Updating nodes' dx and dy
+                        NodeMatrix[n1 + NODE_DX] += xDist * factor;
+                        NodeMatrix[n1 + NODE_DY] += yDist * factor;
+                        NodeMatrix[n2 + NODE_DX] -= xDist * factor;
+                        NodeMatrix[n2 + NODE_DY] -= yDist * factor;
+                    }
+                }
+            }
+        });
+    }
+    else {
+        graphComponents.forEach((component, c) => {
+            for (let i = 0; i < component.length; i += 1) {
+                n1 = Number(component[i]) * PPN;
+                for (let j = 0; j < i; j += 1) {
+                    n2 = Number(component[j]) * PPN;
+                    xDist = NodeMatrix[n1 + NODE_X] - NodeMatrix[n2 + NODE_X];
+                    yDist = NodeMatrix[n1 + NODE_Y] - NodeMatrix[n2 + NODE_Y];
+                    // -- Linear Repulsion
+                    const distance_squared = xDist * xDist + yDist * yDist;
+                    if (distance_squared > 0) {
+                        distance = Math.sqrt(distance_squared);
+                        factor =
+                            (coefficient * NodeMatrix[n1 + NODE_MASS] * NodeMatrix[n2 + NODE_MASS]) /
+                                distance_squared;
+                        const norm_x = xDist / distance;
+                        const norm_y = yDist / distance;
+                        // Updating nodes' dx and dy
+                        NodeMatrix[n1 + NODE_DX] += norm_x * factor;
+                        NodeMatrix[n1 + NODE_DY] += norm_y * factor;
+                        NodeMatrix[n2 + NODE_DX] -= norm_x * factor;
+                        NodeMatrix[n2 + NODE_DY] -= norm_y * factor;
+                    }
+                }
+            }
+        });
+    }
+}
+/**
+ * Function used to perform a single interation of the algorithm.
+ *
+ * @param  {object}       options    - Layout options.
+ * @param  {Float32Array} NodeMatrix - Node data.
+ * @param  {Float32Array} EdgeMatrix - Edge data.
+ * @param  {string[][]}   graphComponents - Graph Components
+ * @return {object}                  - Some metadata.
+ */
+export function iterateNoIntercomponentRepel(options, NodeMatrix, EdgeMatrix, graphComponents) {
+    var _a, _b, _c, _d;
+    // Initializing variables
+    let n;
+    let n1;
+    let n2;
+    let e;
+    const adjustSizes = options.adjustSizes;
+    let outboundAttCompensation;
+    let xDist;
+    let yDist;
+    let ewc;
+    let distance;
+    let factor = 0;
+    let force;
+    let swinging;
+    let traction;
+    let nodespeed;
+    // 1) Initializing layout data
+    //-----------------------------
+    // Resetting movements.
+    for (n = 0; n < NodeMatrix.length; n += PPN) {
+        NodeMatrix[n + NODE_OLD_DX] = NodeMatrix[n + NODE_DX];
+        NodeMatrix[n + NODE_OLD_DY] = NodeMatrix[n + NODE_DY];
+        NodeMatrix[n + NODE_DX] = 0;
+        NodeMatrix[n + NODE_DY] = 0;
+    }
+    const numberVertices = NodeMatrix.length / PPN;
+    // If outbound attraction distribution, compensate
+    if (options.outboundAttractionDistribution) {
+        outboundAttCompensation = 0;
+        for (n = 0; n < NodeMatrix.length; n += PPN) {
+            outboundAttCompensation += NodeMatrix[n + NODE_MASS];
+        }
+        outboundAttCompensation /= numberVertices;
+    }
+    // Repulsion
+    //--------------
+    // NOTES: adjustSizes = antiCollision & scalingRatio = coefficient
+    // Writes to NodeMatrix.
+    getMovementDifferentialsDueToRepulsion(options, NodeMatrix, graphComponents);
+    // 4) Attraction
+    //---------------
+    const coefficient = options.outboundAttractionDistribution ? outboundAttCompensation : 1;
+    if (!coefficient)
+        return;
+    const size = EdgeMatrix.length;
+    for (e = 0; e < size; e += PPE) {
+        n1 = EdgeMatrix[e + EDGE_SOURCE];
+        n2 = EdgeMatrix[e + EDGE_TARGET];
+        const w = EdgeMatrix[e + EDGE_WEIGHT];
+        // Edge weight influence
+        ewc = Math.pow(w, ((_a = options.edgeWeightInfluence) !== null && _a !== void 0 ? _a : 1));
+        // Common measures
+        xDist = NodeMatrix[n1 + NODE_X] - NodeMatrix[n2 + NODE_X];
+        yDist = NodeMatrix[n1 + NODE_Y] - NodeMatrix[n2 + NODE_Y];
+        // Applying attraction to nodes
+        if (adjustSizes === true) {
+            distance =
+                Math.sqrt(xDist * xDist + yDist * yDist) -
+                    NodeMatrix[n1 + NODE_SIZE] -
+                    NodeMatrix[n2 + NODE_SIZE];
+            if (options.linLogMode) {
+                if (options.outboundAttractionDistribution) {
+                    // -- LinLog Degree Distributed Anti-collision Attraction
+                    if (distance > 0) {
+                        factor =
+                            (-coefficient * ewc * Math.log(1 + distance)) / distance / NodeMatrix[n1 + NODE_MASS];
+                    }
+                }
+                else if (distance > 0) {
+                    // -- LinLog Anti-collision Attraction
+                    factor = (-coefficient * ewc * Math.log(1 + distance)) / distance;
+                }
+            }
+            else if (options.outboundAttractionDistribution) {
+                // -- Linear Degree Distributed Anti-collision Attraction
+                if (distance > 0) {
+                    factor = (-coefficient * ewc) / NodeMatrix[n1 + NODE_MASS];
+                }
+            }
+            else if (distance > 0) {
+                // -- Linear Anti-collision Attraction
+                factor = -coefficient * ewc;
+            }
+        }
+        else {
+            distance = Math.sqrt(xDist * xDist + yDist * yDist);
+            if (options.linLogMode) {
+                if (options.outboundAttractionDistribution) {
+                    // -- LinLog Degree Distributed Attraction
+                    if (distance > 0) {
+                        factor =
+                            (-coefficient * ewc * Math.log(1 + distance)) / distance / NodeMatrix[n1 + NODE_MASS];
+                    }
+                }
+                else if (distance > 0) {
+                    factor = (-coefficient * ewc * Math.log(1 + distance)) / distance;
+                }
+            }
+            else if (options.outboundAttractionDistribution) {
+                // -- Linear Attraction Mass Distributed
+                // NOTE: Distance is set to 1 to override next condition
+                distance = 1;
+                factor = (-coefficient * ewc) / NodeMatrix[n1 + NODE_MASS];
+            }
+            else {
+                // -- Linear Attraction
+                // NOTE: Distance is set to 1 to override next condition
+                distance = 1;
+                factor = -coefficient * ewc;
+            }
+        }
+        // Updating nodes' dx and dy
+        // TODO: if condition or factor = 1?
+        if (distance > 0) {
+            // Updating nodes' dx and dy
+            NodeMatrix[n1 + NODE_DX] += xDist * factor;
+            NodeMatrix[n1 + NODE_DY] += yDist * factor;
+            NodeMatrix[n2 + NODE_DX] -= xDist * factor;
+            NodeMatrix[n2 + NODE_DY] -= yDist * factor;
+        }
+    }
+    // Apply Forces
+    // -----------------
+    // MATH: sqrt and square distances
+    if (adjustSizes === true) {
+        for (n = 0; n < NodeMatrix.length; n += PPN) {
+            if (NodeMatrix[n + NODE_FIXED] !== 1) {
+                force = Math.sqrt(Math.pow(NodeMatrix[n + NODE_DX], 2) + Math.pow(NodeMatrix[n + NODE_DY], 2));
+                if (force > MAX_FORCE) {
+                    NodeMatrix[n + NODE_DX] = (NodeMatrix[n + NODE_DX] * MAX_FORCE) / force;
+                    NodeMatrix[n + NODE_DY] = (NodeMatrix[n + NODE_DY] * MAX_FORCE) / force;
+                }
+                swinging =
+                    NodeMatrix[n + NODE_MASS] *
+                        Math.sqrt((NodeMatrix[n + NODE_OLD_DX] - NodeMatrix[n + NODE_DX]) *
+                            (NodeMatrix[n + NODE_OLD_DX] - NodeMatrix[n + NODE_DX]) +
+                            (NodeMatrix[n + NODE_OLD_DY] - NodeMatrix[n + NODE_DY]) *
+                                (NodeMatrix[n + NODE_OLD_DY] - NodeMatrix[n + NODE_DY]));
+                traction =
+                    Math.sqrt((NodeMatrix[n + NODE_OLD_DX] + NodeMatrix[n + NODE_DX]) *
+                        (NodeMatrix[n + NODE_OLD_DX] + NodeMatrix[n + NODE_DX]) +
+                        (NodeMatrix[n + NODE_OLD_DY] + NodeMatrix[n + NODE_DY]) *
+                            (NodeMatrix[n + NODE_OLD_DY] + NodeMatrix[n + NODE_DY])) / 2;
+                nodespeed = (0.1 * Math.log(1 + traction)) / (1 + Math.sqrt(swinging));
+                // Updating node's positon
+                const deltaX = NodeMatrix[n + NODE_DX] * (nodespeed / ((_b = options.slowDown) !== null && _b !== void 0 ? _b : 1));
+                NodeMatrix[n + NODE_X] += deltaX;
+                const deltaY = NodeMatrix[n + NODE_DY] * (nodespeed / ((_c = options.slowDown) !== null && _c !== void 0 ? _c : 1));
+                NodeMatrix[n + NODE_Y] += deltaY;
+            }
+        }
+    }
+    else {
+        for (n = 0; n < NodeMatrix.length; n += PPN) {
+            if (NodeMatrix[n + NODE_FIXED] !== 1) {
+                const ddx = NodeMatrix[n + NODE_OLD_DX] - NodeMatrix[n + NODE_DX];
+                const ddy = NodeMatrix[n + NODE_OLD_DY] - NodeMatrix[n + NODE_DY];
+                swinging = NodeMatrix[n + NODE_MASS] * Math.sqrt(Math.pow(ddx, 2) + Math.pow(ddy, 2));
+                const dxSum = NodeMatrix[n + NODE_OLD_DX] + NodeMatrix[n + NODE_DX];
+                const dySum = NodeMatrix[n + NODE_OLD_DY] + NodeMatrix[n + NODE_DY];
+                const swingingNormTerm = 1 + Math.sqrt(swinging);
+                traction = Math.sqrt(Math.pow(dxSum, 2) + Math.pow(dySum, 2)) / 2;
+                nodespeed = (NodeMatrix[n + NODE_CONVERGENCE] * Math.log(1 + traction)) / swingingNormTerm;
+                // Updating node convergence
+                NodeMatrix[n + NODE_CONVERGENCE] = Math.min(1, Math.sqrt((nodespeed * (Math.pow(NodeMatrix[n + NODE_DX], 2) + Math.pow(NodeMatrix[n + NODE_DY], 2))) /
+                    swingingNormTerm));
+                // Updating node's positon
+                const stepSize = nodespeed / ((_d = options.slowDown) !== null && _d !== void 0 ? _d : 1);
+                NodeMatrix[n + NODE_X] += NodeMatrix[n + NODE_DX] * stepSize;
+                NodeMatrix[n + NODE_Y] += NodeMatrix[n + NODE_DY] * stepSize;
+            }
+        }
+    }
+    // We return the information about the layout (no need to return the matrices)
+    return {};
+}
+//# sourceMappingURL=IterateNoIntercomponentRepel.js.map

package/lib/LoadGraph.js

@@ -0,0 +1,132 @@
+import { useCallback, useEffect } from 'react';
+import { useRegisterEvents, useSigma } from '@react-sigma/core';
+export const LoadGraph = ({ graph, animator, animate, selectedNodes, setSelectedNodes, addSelectedNodes, }) => {
+    const sigma = useSigma();
+    const registerEvents = useRegisterEvents();
+    useEffect(() => {
+        sigma.setGraph(graph);
+        sigma.refresh();
+    }, [graph]);
+    useEffect(() => {
+        graph.updateEachNodeAttributes((key, attr) => {
+            const n = Number(key);
+            if (selectedNodes.some((node) => node === n)) {
+                return Object.assign(Object.assign({}, attr), { highlighted: true });
+            }
+            return Object.assign(Object.assign({}, attr), { highlighted: false });
+        });
+    }, [selectedNodes, graph]);
+    const handleSelectionClear = useCallback(() => {
+        setSelectedNodes([]);
+        selectedNodes.forEach((node) => {
+            graph.setNodeAttribute(node, 'highlighted', false);
+        });
+    }, [setSelectedNodes, selectedNodes, graph]);
+    const onNodeDoubleClick = (e) => {
+        e.preventSigmaDefault();
+        const nodeValue = Number(e.node);
+        const isNodeSelectedAlready = selectedNodes.some((n) => n === nodeValue);
+        if (isNodeSelectedAlready) {
+            setSelectedNodes(selectedNodes.filter((n) => n !== nodeValue));
+        }
+        else {
+            addSelectedNodes([nodeValue]);
+        }
+    };
+    useEffect(() => {
+        let draggedNode;
+        let isDragging = false;
+        let isDraggedNodeSelected = false;
+        let previousPosition = null;
+        registerEvents({
+            downNode: (e) => {
+                isDragging = true;
+                draggedNode = e.node;
+                const nodeValue = Number(e.node);
+                graph.setNodeAttribute(draggedNode, 'highlighted', true);
+                isDraggedNodeSelected = selectedNodes.some((n) => n === nodeValue);
+                if (isDraggedNodeSelected) {
+                    selectedNodes.map((node) => graph.updateNodeAttribute(node, 'fixed', () => true));
+                }
+                else {
+                    graph.setNodeAttribute(draggedNode, 'fixed', true);
+                }
+                previousPosition = sigma.viewportToGraph(e.event);
+                if (!animator.isRunning() && animate) {
+                    animator.start();
+                }
+                animator.resetNIters();
+            },
+            mousemovebody: (e) => {
+                if (!isDragging || !draggedNode || !previousPosition)
+                    return;
+                animator.resetNIters();
+                const pos = sigma.viewportToGraph(e);
+                const dx = pos.x - previousPosition.x;
+                const dy = pos.y - previousPosition.y;
+                previousPosition = pos;
+                if (isDraggedNodeSelected) {
+                    selectedNodes.map((node) => graph.updateNodeAttributes(node, (attr) => (Object.assign(Object.assign({}, attr), { x: attr.x + dx, y: attr.y + dy }))));
+                }
+                else {
+                    graph.updateNodeAttributes(draggedNode, (attr) => (Object.assign(Object.assign({}, attr), { x: attr.x + dx, y: attr.y + dy })));
+                }
+                // Prevent sigma to move camera:
+                e.preventSigmaDefault();
+                e.original.preventDefault();
+                e.original.stopPropagation();
+            },
+            mouseup: () => {
+                if (draggedNode) {
+                    if (isDraggedNodeSelected) {
+                        selectedNodes.map((node) => graph.removeNodeAttribute(node, 'fixed'));
+                    }
+                    else {
+                        graph.removeNodeAttribute(draggedNode, 'fixed');
+                        graph.removeNodeAttribute(draggedNode, 'highlighted');
+                    }
+                    previousPosition = null;
+                }
+                isDragging = false;
+                draggedNode = null;
+                isDraggedNodeSelected = false;
+            },
+            mousedown: () => {
+                if (!sigma.getCustomBBox())
+                    sigma.setCustomBBox(sigma.getBBox());
+            },
+            doubleClickNode: (e) => onNodeDoubleClick(e),
+            doubleClickStage: (e) => {
+                handleSelectionClear();
+                e.preventSigmaDefault();
+            },
+            wheel: (e) => {
+                const camera = sigma.getCamera();
+                const cameraState = camera.getState();
+                // too large a step makes the motion very unsmooth
+                const delta = Math.max(-1.5, Math.min(1.5, e.delta));
+                const newRatio = camera.getBoundedRatio(cameraState.ratio * (1 - delta / 8));
+                const event = e.original;
+                if (event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL) {
+                    console.warn('WheelEvent.deltaMode is not DOM_DELTA_PIXEL. Zoom behavior may not be as expected.');
+                }
+                // shift the center so that the mouse cursor is the fixed point of the zoom
+                const newState = sigma.getViewportZoomedState(e, newRatio);
+                camera.setState(newState);
+                e.preventSigmaDefault(); // this call is supposed to work but doesn't
+                // eslint-disable-next-line no-param-reassign
+                e.sigmaDefaultPrevented = true; // so we have to set this flag manually
+            },
+        });
+    }, [
+        registerEvents,
+        setSelectedNodes,
+        addSelectedNodes,
+        selectedNodes,
+        handleSelectionClear,
+        graph,
+        animate,
+    ]);
+    return null;
+};
+//# sourceMappingURL=LoadGraph.js.map

package/lib/SigmaLasso.js

@@ -0,0 +1,118 @@
+import React, { useCallback, useRef } from 'react';
+import { useSigma } from '@react-sigma/core';
+export const SigmaLasso = ({ active, setSelectedNodes, addSelectedNodes }) => {
+    const sigma = useSigma();
+    const lassoCanvasRef = useRef(null);
+    const getLassoCanvas = useCallback(() => {
+        if (active)
+            return lassoCanvasRef.current;
+        return null;
+    }, [active]);
+    const isDrawing = useRef(false);
+    const drawnPoints = useRef([]);
+    const onDrawingStart = (event) => {
+        const lassoCanvas = getLassoCanvas();
+        if (!lassoCanvas)
+            return;
+        isDrawing.current = true;
+        drawnPoints.current = [];
+        const drawingRectangle = lassoCanvas.getBoundingClientRect();
+        drawnPoints.current.push({
+            x: event.clientX - drawingRectangle.left,
+            y: event.clientY - drawingRectangle.top,
+        });
+        event.stopPropagation();
+    };
+    const onDrawing = (event) => {
+        const lassoCanvas = getLassoCanvas();
+        if (!lassoCanvas)
+            return;
+        if (isDrawing.current) {
+            let x;
+            let y;
+            const drawingRectangle = lassoCanvas.getBoundingClientRect();
+            const drawingContext = lassoCanvas.getContext('2d');
+            switch (event.type) {
+                case 'touchmove':
+                    x = event.touches[0].clientX;
+                    y = event.touches[0].clientY;
+                    break;
+                default:
+                    x = event.clientX;
+                    y = event.clientY;
+                    break;
+            }
+            drawnPoints.current.push({
+                x: x - drawingRectangle.left,
+                y: y - drawingRectangle.top,
+            });
+            // Drawing styles
+            drawingContext.strokeStyle = 'black';
+            drawingContext.lineWidth = 2;
+            drawingContext.fillStyle = 'rgba(200, 200, 200, 0.25)';
+            drawingContext.lineJoin = 'round';
+            drawingContext.lineCap = 'round';
+            // Clear the canvas
+            drawingContext.clearRect(0, 0, drawingContext.canvas.width, drawingContext.canvas.height);
+            // Redraw the complete path for a smoother effect
+            // Even smoother with quadratic curves
+            let sourcePoint = drawnPoints.current[0];
+            let destinationPoint = drawnPoints.current[1];
+            const pointsLength = drawnPoints.current.length;
+            const getMiddlePointCoordinates = (firstPoint, secondPoint) => ({
+                x: firstPoint.x + (secondPoint.x - firstPoint.x) / 2,
+                y: firstPoint.y + (secondPoint.y - firstPoint.y) / 2,
+            });
+            drawingContext.beginPath();
+            drawingContext.moveTo(sourcePoint.x, sourcePoint.y);
+            for (let i = 1; i < pointsLength; i += 1) {
+                const middlePoint = getMiddlePointCoordinates(sourcePoint, destinationPoint);
+                drawingContext.quadraticCurveTo(sourcePoint.x, sourcePoint.y, middlePoint.x, middlePoint.y);
+                sourcePoint = drawnPoints.current[i];
+                destinationPoint = drawnPoints.current[i + 1];
+            }
+            drawingContext.lineTo(sourcePoint.x, sourcePoint.y);
+            drawingContext.stroke();
+            drawingContext.fill();
+            event.stopPropagation();
+        }
+    };
+    const onDrawingEnd = useCallback((event) => {
+        const lassoCanvas = getLassoCanvas();
+        const viewRectangle = sigma.viewRectangle();
+        const graph = sigma.getGraph();
+        if (!lassoCanvas)
+            return;
+        isDrawing.current = false;
+        // @ts-ignore - There are no other ways to get visible nodes
+        const quadtreeRectangle = sigma.quadtree.rectangle(viewRectangle.x1, 1 - viewRectangle.y1, viewRectangle.x2, 1 - viewRectangle.y2, viewRectangle.height);
+        const visibleNodes = Array.from(new Set(quadtreeRectangle));
+        const drawingContext = lassoCanvas.getContext('2d');
+        const newSelectedNodes = [];
+        visibleNodes.forEach((key) => {
+            const nodeValue = Number(key);
+            const { x, y } = graph.getNodeAttributes(nodeValue);
+            const coordinates = sigma.graphToViewport({ x, y });
+            if (drawingContext.isPointInPath(coordinates.x, coordinates.y)) {
+                newSelectedNodes.push(nodeValue);
+            }
+        });
+        if (event.shiftKey) {
+            addSelectedNodes(newSelectedNodes);
+        }
+        else {
+            setSelectedNodes(newSelectedNodes);
+        }
+        drawingContext.clearRect(0, 0, lassoCanvas.width, lassoCanvas.height);
+        drawnPoints.current = [];
+        event.stopPropagation();
+    }, [setSelectedNodes, addSelectedNodes, getLassoCanvas, sigma]);
+    const onLassoScroll = (e) => {
+        const mouseCaptor = sigma.getMouseCaptor();
+        mouseCaptor.handleWheel(e.nativeEvent);
+    };
+    if (!active)
+        return null;
+    return (React.createElement("canvas", { ref: lassoCanvasRef, width: sigma.getContainer().offsetWidth, height: sigma.getContainer().offsetHeight, style: { position: 'absolute', top: '0px', cursor: 'crosshair' }, onMouseDown: onDrawingStart, onMouseMove: onDrawing, onMouseUp: onDrawingEnd, onWheel: onLassoScroll }));
+};
+//# sourceMappingURL=SigmaLasso.js.map

package/lib/enum/layout.js

@@ -0,0 +1,24 @@
+export var LayoutEnum;
+(function (LayoutEnum) {
+    LayoutEnum["GRID"] = "grid";
+    LayoutEnum["TABLE"] = "table";
+})(LayoutEnum || (LayoutEnum = {}));
+/**
+ * Matrices properties accessors.
+ */
+export const NODE_X = 0;
+export const NODE_Y = 1;
+export const NODE_DX = 2;
+export const NODE_DY = 3;
+export const NODE_OLD_DX = 4;
+export const NODE_OLD_DY = 5;
+export const NODE_MASS = 6;
+export const NODE_CONVERGENCE = 7;
+export const NODE_SIZE = 8;
+export const NODE_FIXED = 9;
+export const PPN = 10;
+export const PPE = 3;
+export const EDGE_SOURCE = 0;
+export const EDGE_TARGET = 1;
+export const EDGE_WEIGHT = 2;
+//# sourceMappingURL=layout.js.map