highcharts 10.2.0 → 10.2.1

package/es-modules/Series/Networkgraph/EulerIntegration.js

@@ -0,0 +1,199 @@
+/* *
+ *
+ *  Networkgraph series
+ *
+ *  (c) 2010-2021 Paweł Fus
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Attractive force.
+ *
+ * In Euler integration, force is stored in a node, not changing it's
+ * position. Later, in `integrate()` forces are applied on nodes.
+ *
+ * @private
+ * @param {Highcharts.Point} link
+ *        Link that connects two nodes
+ * @param {number} force
+ *        Force calcualated in `repulsiveForceFunction`
+ * @param {Highcharts.PositionObject} distanceXY
+ *        Distance between two nodes e.g. `{x, y}`
+ * @param {number} distanceR
+     */
+function attractive(link, force, distanceXY, distanceR) {
+    var massFactor = link.getMass(), translatedX = (distanceXY.x / distanceR) * force, translatedY = (distanceXY.y / distanceR) * force;
+    if (!link.fromNode.fixedPosition) {
+        link.fromNode.dispX -=
+            translatedX * massFactor.fromNode / link.fromNode.degree;
+        link.fromNode.dispY -=
+            translatedY * massFactor.fromNode / link.fromNode.degree;
+    }
+    if (!link.toNode.fixedPosition) {
+        link.toNode.dispX +=
+            translatedX * massFactor.toNode / link.toNode.degree;
+        link.toNode.dispY +=
+            translatedY * massFactor.toNode / link.toNode.degree;
+    }
+}
+/**
+ * Attractive force funtion. Can be replaced by API's
+ * `layoutAlgorithm.attractiveForce`
+ *
+ * Other forces that can be used:
+ *
+ * basic, not recommended:
+ *    `function (d, k) { return d / k }`
+ *
+ * @private
+ * @param {number} d current distance between two nodes
+ * @param {number} k expected distance between two nodes
+ * @return {number} force
+ */
+function attractiveForceFunction(d, k) {
+    return d * d / k;
+}
+/**
+ * Barycenter force. Calculate and applys barycenter forces on the
+ * nodes. Making them closer to the center of their barycenter point.
+ *
+ * In Euler integration, force is stored in a node, not changing it's
+ * position. Later, in `integrate()` forces are applied on nodes.
+ *
+ * @private
+ */
+function barycenter() {
+    var gravitationalConstant = this.options.gravitationalConstant, xFactor = this.barycenter.xFactor, yFactor = this.barycenter.yFactor;
+    this.nodes.forEach(function (node) {
+        if (!node.fixedPosition) {
+            var degree = node.getDegree(), phi = degree * (1 + degree / 2);
+            node.dispX += ((xFactor - node.plotX) *
+                gravitationalConstant *
+                phi / node.degree);
+            node.dispY += ((yFactor - node.plotY) *
+                gravitationalConstant *
+                phi / node.degree);
+        }
+    });
+}
+/**
+ * Estiamte the best possible distance between two nodes, making graph
+ * readable.
+ * @private
+ */
+function getK(layout) {
+    return Math.pow(layout.box.width * layout.box.height / layout.nodes.length, 0.3);
+}
+/**
+ * Integration method.
+ *
+ * In Euler integration, force were stored in a node, not changing it's
+ * position. Now, in the integrator method, we apply changes.
+ *
+ * Euler:
+ *
+ * Basic form: `x(n+1) = x(n) + v(n)`
+ *
+ * With Rengoild-Fruchterman we get:
+ * `x(n+1) = x(n) + v(n) / length(v(n)) * min(v(n), temperature(n))`
+ * where:
+ * - `x(n+1)`: next position
+ * - `x(n)`: current position
+ * - `v(n)`: velocity (comes from net force)
+ * - `temperature(n)`: current temperature
+ *
+ * Known issues:
+ * Oscillations when force vector has the same magnitude but opposite
+ * direction in the next step. Potentially solved by decreasing force by
+ * `v * (1 / node.degree)`
+ *
+ * Note:
+ * Actually `min(v(n), temperature(n))` replaces simulated annealing.
+ *
+ * @private
+ * @param {Highcharts.NetworkgraphLayout} layout
+ *        Layout object
+ * @param {Highcharts.Point} node
+ *        Node that should be translated
+ */
+function integrate(layout, node) {
+    var distanceR;
+    node.dispX +=
+        node.dispX * layout.options.friction;
+    node.dispY +=
+        node.dispY * layout.options.friction;
+    distanceR = node.temperature = layout.vectorLength({
+        x: node.dispX,
+        y: node.dispY
+    });
+    if (distanceR !== 0) {
+        node.plotX += (node.dispX / distanceR *
+            Math.min(Math.abs(node.dispX), layout.temperature));
+        node.plotY += (node.dispY / distanceR *
+            Math.min(Math.abs(node.dispY), layout.temperature));
+    }
+}
+/**
+ * Repulsive force.
+ *
+ * @private
+ * @param {Highcharts.Point} node
+ *        Node that should be translated by force.
+ * @param {number} force
+ *        Force calcualated in `repulsiveForceFunction`
+ * @param {Highcharts.PositionObject} distanceXY
+ *        Distance between two nodes e.g. `{x, y}`
+ */
+function repulsive(node, force, distanceXY, distanceR) {
+    node.dispX +=
+        (distanceXY.x / distanceR) * force / node.degree;
+    node.dispY +=
+        (distanceXY.y / distanceR) * force / node.degree;
+}
+/**
+ * Repulsive force funtion. Can be replaced by API's
+ * `layoutAlgorithm.repulsiveForce`.
+ *
+ * Other forces that can be used:
+ *
+ * basic, not recommended:
+ *    `function (d, k) { return k / d }`
+ *
+ * standard:
+ *    `function (d, k) { return k * k / d }`
+ *
+ * grid-variant:
+ *    `function (d, k) { return k * k / d * (2 * k - d > 0 ? 1 : 0) }`
+ *
+ * @private
+ * @param {number} d current distance between two nodes
+ * @param {number} k expected distance between two nodes
+ * @return {number} force
+ */
+function repulsiveForceFunction(d, k) {
+    return k * k / d;
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+var EulerIntegration = {
+    attractive: attractive,
+    attractiveForceFunction: attractiveForceFunction,
+    barycenter: barycenter,
+    getK: getK,
+    integrate: integrate,
+    repulsive: repulsive,
+    repulsiveForceFunction: repulsiveForceFunction
+};
+export default EulerIntegration;

package/es-modules/Series/Networkgraph/NetworkgraphPoint.js

@@ -0,0 +1,290 @@
+/* *
+ *
+ *  Networkgraph series
+ *
+ *  (c) 2010-2021 Paweł Fus
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import NodesComposition from '../NodesComposition.js';
+import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
+var _a = SeriesRegistry.series, seriesProto = _a.prototype, Point = _a.prototype.pointClass;
+import U from '../../Core/Utilities.js';
+var addEvent = U.addEvent, css = U.css, defined = U.defined, extend = U.extend, pick = U.pick;
+/* *
+ *
+ *  Class
+ *
+ * */
+var NetworkgraphPoint = /** @class */ (function (_super) {
+    __extends(NetworkgraphPoint, _super);
+    function NetworkgraphPoint() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Destroy point. If it's a node, remove all links coming out of this
+     * node. Then remove point from the layout.
+     * @private
+     */
+    NetworkgraphPoint.prototype.destroy = function () {
+        if (this.isNode) {
+            this.linksFrom.concat(this.linksTo).forEach(function (link) {
+                // Removing multiple nodes at the same time
+                // will try to remove link between nodes twice
+                if (link.destroyElements) {
+                    link.destroyElements();
+                }
+            });
+        }
+        this.series.layout.removeElementFromCollection(this, this.series.layout[this.isNode ? 'nodes' : 'links']);
+        return Point.prototype.destroy.apply(this, arguments);
+    };
+    /**
+     * Return degree of a node. If node has no connections, it still has
+     * deg=1.
+     * @private
+     */
+    NetworkgraphPoint.prototype.getDegree = function () {
+        var deg = this.isNode ?
+            this.linksFrom.length + this.linksTo.length :
+            0;
+        return deg === 0 ? 1 : deg;
+    };
+    /**
+     * Get presentational attributes of link connecting two nodes.
+     * @private
+     */
+    NetworkgraphPoint.prototype.getLinkAttributes = function () {
+        var linkOptions = this.series.options.link, pointOptions = this.options;
+        return {
+            'stroke-width': pick(pointOptions.width, linkOptions.width),
+            stroke: (pointOptions.color || linkOptions.color),
+            dashstyle: (pointOptions.dashStyle || linkOptions.dashStyle),
+            opacity: pick(pointOptions.opacity, linkOptions.opacity, 1)
+        };
+    };
+    /**
+     * Get link path connecting two nodes.
+     * @private
+     * @return {Array<Highcharts.SVGPathArray>}
+     *         Path: `['M', x, y, 'L', x, y]`
+     */
+    NetworkgraphPoint.prototype.getLinkPath = function () {
+        var left = this.fromNode, right = this.toNode;
+        // Start always from left to the right node, to prevent rendering
+        // labels upside down
+        if (left.plotX > right.plotX) {
+            left = this.toNode;
+            right = this.fromNode;
+        }
+        return [
+            ['M', left.plotX || 0, left.plotY || 0],
+            ['L', right.plotX || 0, right.plotY || 0]
+        ];
+        /*
+        IDEA: different link shapes?
+        return [
+            'M',
+            from.plotX,
+            from.plotY,
+            'Q',
+            (to.plotX + from.plotX) / 2,
+            (to.plotY + from.plotY) / 2 + 15,
+            to.plotX,
+            to.plotY
+        ];*/
+    };
+    /**
+     * Get mass fraction applied on two nodes connected to each other. By
+     * default, when mass is equal to `1`, mass fraction for both nodes
+     * equal to 0.5.
+     * @private
+     * @return {Highcharts.Dictionary<number>}
+     *         For example `{ fromNode: 0.5, toNode: 0.5 }`
+     */
+    NetworkgraphPoint.prototype.getMass = function () {
+        var m1 = this.fromNode.mass, m2 = this.toNode.mass, sum = m1 + m2;
+        return {
+            fromNode: 1 - m1 / sum,
+            toNode: 1 - m2 / sum
+        };
+    };
+    /**
+     * Basic `point.init()` and additional styles applied when
+     * `series.draggable` is enabled.
+     * @private
+     */
+    NetworkgraphPoint.prototype.init = function (series, options, x) {
+        _super.prototype.init.call(this, series, options, x);
+        if (this.series.options.draggable &&
+            !this.series.chart.styledMode) {
+            addEvent(this, 'mouseOver', function () {
+                css(this.series.chart.container, { cursor: 'move' });
+            });
+            addEvent(this, 'mouseOut', function () {
+                css(this.series.chart.container, { cursor: 'default' });
+            });
+        }
+        return this;
+    };
+    /**
+     * @private
+     */
+    NetworkgraphPoint.prototype.isValid = function () {
+        return !this.isNode || defined(this.id);
+    };
+    /**
+     * Redraw link's path.
+     * @private
+     */
+    NetworkgraphPoint.prototype.redrawLink = function () {
+        var path = this.getLinkPath(), attribs;
+        if (this.graphic) {
+            this.shapeArgs = {
+                d: path
+            };
+            if (!this.series.chart.styledMode) {
+                attribs = this.series.pointAttribs(this);
+                this.graphic.attr(attribs);
+                (this.dataLabels || []).forEach(function (label) {
+                    if (label) {
+                        label.attr({
+                            opacity: attribs.opacity
+                        });
+                    }
+                });
+            }
+            this.graphic.animate(this.shapeArgs);
+            // Required for dataLabels
+            var start = path[0];
+            var end = path[1];
+            if (start[0] === 'M' && end[0] === 'L') {
+                this.plotX = (start[1] + end[1]) / 2;
+                this.plotY = (start[2] + end[2]) / 2;
+            }
+        }
+    };
+    /**
+     * Common method for removing points and nodes in networkgraph. To
+     * remove `link`, use `series.data[index].remove()`. To remove `node`
+     * with all connections, use `series.nodes[index].remove()`.
+     * @private
+     * @param {boolean} [redraw=true]
+     *        Whether to redraw the chart or wait for an explicit call. When
+     *        doing more operations on the chart, for example running
+     *        `point.remove()` in a loop, it is best practice to set
+     *        `redraw` to false and call `chart.redraw()` after.
+     * @param {boolean|Partial<Highcharts.AnimationOptionsObject>} [animation=false]
+     *        Whether to apply animation, and optionally animation
+     *        configuration.
+     */
+    NetworkgraphPoint.prototype.remove = function (redraw, animation) {
+        var point = this, series = point.series, nodesOptions = series.options.nodes || [], index, i = nodesOptions.length;
+        // For nodes, remove all connected links:
+        if (point.isNode) {
+            // Temporary disable series.points array, because
+            // Series.removePoint() modifies it
+            series.points = [];
+            // Remove link from all nodes collections:
+            []
+                .concat(point.linksFrom)
+                .concat(point.linksTo)
+                .forEach(function (linkFromTo) {
+                // Incoming links
+                index = linkFromTo.fromNode.linksFrom.indexOf(linkFromTo);
+                if (index > -1) {
+                    linkFromTo.fromNode.linksFrom.splice(index, 1);
+                }
+                // Outcoming links
+                index = linkFromTo.toNode.linksTo.indexOf(linkFromTo);
+                if (index > -1) {
+                    linkFromTo.toNode.linksTo.splice(index, 1);
+                }
+                // Remove link from data/points collections
+                seriesProto.removePoint.call(series, series.data.indexOf(linkFromTo), false, false);
+            });
+            // Restore points array, after links are removed
+            series.points = series.data.slice();
+            // Proceed with removing node. It's similar to
+            // Series.removePoint() method, but doesn't modify other arrays
+            series.nodes.splice(series.nodes.indexOf(point), 1);
+            // Remove node options from config
+            while (i--) {
+                if (nodesOptions[i].id === point.options.id) {
+                    series.options.nodes.splice(i, 1);
+                    break;
+                }
+            }
+            if (point) {
+                point.destroy();
+            }
+            // Run redraw if requested
+            series.isDirty = true;
+            series.isDirtyData = true;
+            if (redraw) {
+                series.chart.redraw(redraw);
+            }
+        }
+        else {
+            series.removePoint(series.data.indexOf(point), redraw, animation);
+        }
+    };
+    /**
+     * Render link and add it to the DOM.
+     * @private
+     */
+    NetworkgraphPoint.prototype.renderLink = function () {
+        var attribs;
+        if (!this.graphic) {
+            this.graphic = this.series.chart.renderer
+                .path(this.getLinkPath())
+                .addClass(this.getClassName(), true)
+                .add(this.series.group);
+            if (!this.series.chart.styledMode) {
+                attribs = this.series.pointAttribs(this);
+                this.graphic.attr(attribs);
+                (this.dataLabels || []).forEach(function (label) {
+                    if (label) {
+                        label.attr({
+                            opacity: attribs.opacity
+                        });
+                    }
+                });
+            }
+        }
+    };
+    return NetworkgraphPoint;
+}(Point));
+extend(NetworkgraphPoint.prototype, {
+    setState: NodesComposition.setNodeState
+});
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default NetworkgraphPoint;