highcharts 10.2.0 → 10.2.1

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

@@ -0,0 +1,193 @@
+/* *
+ *
+ *  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 Verlet integration, force is applied on a node immidatelly to it's
+ * `plotX` and `plotY` position.
+ *
+ * @private
+ * @param {Highcharts.Point} link
+ *        Link that connects two nodes
+ * @param {number} force
+ *        Force calcualated in `repulsiveForceFunction`
+ * @param {Highcharts.PositionObject} distance
+ *        Distance between two nodes e.g. `{x, y}`
+ */
+function attractive(link, force, distanceXY) {
+    var massFactor = link.getMass(), translatedX = -distanceXY.x * force * this.diffTemperature, translatedY = -distanceXY.y * force * this.diffTemperature;
+    if (!link.fromNode.fixedPosition) {
+        link.fromNode.plotX -=
+            translatedX * massFactor.fromNode / link.fromNode.degree;
+        link.fromNode.plotY -=
+            translatedY * massFactor.fromNode / link.fromNode.degree;
+    }
+    if (!link.toNode.fixedPosition) {
+        link.toNode.plotX +=
+            translatedX * massFactor.toNode / link.toNode.degree;
+        link.toNode.plotY +=
+            translatedY * massFactor.toNode / link.toNode.degree;
+    }
+}
+/**
+ * Attractive force funtion. Can be replaced by API's
+ * `layoutAlgorithm.attractiveForce`
+ *
+ * @private
+ * @param {number} d current distance between two nodes
+ * @param {number} k expected distance between two nodes
+ * @return {number} force
+ */
+function attractiveForceFunction(d, k) {
+    // Used in API:
+    return (k - d) / d;
+}
+/**
+ * Barycenter force. Calculate and applys barycenter forces on the
+ * nodes. Making them closer to the center of their barycenter point.
+ *
+ * In Verlet integration, force is applied on a node immidatelly to it's
+ * `plotX` and `plotY` position.
+ *
+ * @private
+ */
+function barycenter() {
+    var gravitationalConstant = this.options.gravitationalConstant, xFactor = this.barycenter.xFactor, yFactor = this.barycenter.yFactor;
+    // To consider:
+    xFactor = (xFactor - (this.box.left + this.box.width) / 2) *
+        gravitationalConstant;
+    yFactor = (yFactor - (this.box.top + this.box.height) / 2) *
+        gravitationalConstant;
+    this.nodes.forEach(function (node) {
+        if (!node.fixedPosition) {
+            node.plotX -=
+                xFactor / node.mass / node.degree;
+            node.plotY -=
+                yFactor / node.mass / 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.5);
+}
+/**
+ * Integration method.
+ *
+ * In Verlet integration, forces are applied on node immidatelly to it's
+ * `plotX` and `plotY` position.
+ *
+ * Verlet without velocity:
+ *
+ *    x(n+1) = 2 * x(n) - x(n-1) + A(T) * deltaT ^ 2
+ *
+ * where:
+ *     - x(n+1) - new position
+ *     - x(n) - current position
+ *     - x(n-1) - previous position
+ *
+ * Assuming A(t) = 0 (no acceleration) and (deltaT = 1) we get:
+ *
+ *     x(n+1) = x(n) + (x(n) - x(n-1))
+ *
+ * where:
+ *     - (x(n) - x(n-1)) - position change
+ *
+ * TO DO:
+ * Consider Verlet with velocity to support additional
+ * forces. Or even Time-Corrected Verlet by Jonathan
+ * "lonesock" Dummer
+ *
+ * @private
+ * @param {Highcharts.NetworkgraphLayout} layout layout object
+ * @param {Highcharts.Point} node node that should be translated
+ */
+function integrate(layout, node) {
+    var friction = -layout.options.friction, maxSpeed = layout.options.maxSpeed, prevX = node.prevX, prevY = node.prevY, 
+    // Apply friciton:
+    diffX = ((node.plotX + node.dispX -
+        prevX) * friction), diffY = ((node.plotY + node.dispY -
+        prevY) * friction), abs = Math.abs, signX = abs(diffX) / (diffX || 1), // need to deal with 0
+    signY = abs(diffY) / (diffY || 1);
+    // Apply max speed:
+    diffX = signX * Math.min(maxSpeed, Math.abs(diffX));
+    diffY = signY * Math.min(maxSpeed, Math.abs(diffY));
+    // Store for the next iteration:
+    node.prevX = node.plotX + node.dispX;
+    node.prevY = node.plotY + node.dispY;
+    // Update positions:
+    node.plotX += diffX;
+    node.plotY += diffY;
+    node.temperature = layout.vectorLength({
+        x: diffX,
+        y: diffY
+    });
+}
+/**
+ * Repulsive force.
+ *
+ * In Verlet integration, force is applied on a node immidatelly to it's
+ * `plotX` and `plotY` position.
+ *
+ * @private
+ * @param {Highcharts.Point} node
+ *        Node that should be translated by force.
+ * @param {number} force
+ *        Force calcualated in `repulsiveForceFunction`
+ * @param {Highcharts.PositionObject} distance
+ *        Distance between two nodes e.g. `{x, y}`
+ */
+function repulsive(node, force, distanceXY) {
+    var factor = force * this.diffTemperature / node.mass / node.degree;
+    if (!node.fixedPosition) {
+        node.plotX += distanceXY.x * factor;
+        node.plotY += distanceXY.y * factor;
+    }
+}
+/**
+ * Repulsive force funtion. Can be replaced by API's
+ * `layoutAlgorithm.repulsiveForce`
+ *
+ * @private
+ * @param {number} d current distance between two nodes
+ * @param {number} k expected distance between two nodes
+ * @return {number} force
+ */
+function repulsiveForceFunction(d, k) {
+    // Used in API:
+    return (k - d) / d * (k > d ? 1 : 0); // Force only for close nodes
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+var VerletIntegration = {
+    attractive: attractive,
+    attractiveForceFunction: attractiveForceFunction,
+    barycenter: barycenter,
+    getK: getK,
+    integrate: integrate,
+    repulsive: repulsive,
+    repulsiveForceFunction: repulsiveForceFunction
+};
+export default VerletIntegration;

package/es-modules/Series/Organization/OrganizationSeries.js

@@ -182,7 +182,7 @@ var OrganizationSeries = /** @class */ (function (_super) {
     };
     OrganizationSeries.prototype.pointAttribs = function (point, state) {
         var series = this, attribs = SankeySeries.prototype.pointAttribs.call(series, point, state), level = point.isNode ? point.level : point.fromNode.level, levelOptions = series.mapOptionsToLevel[level || 0] || {}, options = point.options, stateOptions = (levelOptions.states &&
-            levelOptions.states[state]) || {}, values = ['borderRadius', 'linkColor', 'linkLineWidth']
+            levelOptions.states[state]) || {}, values = ['borderRadius', 'linkColor', 'linkLineWidth', 'linkOpacity']
             .reduce(function (obj, key) {
             obj[key] = pick(stateOptions[key], options[key], levelOptions[key], series.options[key]);
             return obj;
@@ -190,6 +190,7 @@ var OrganizationSeries = /** @class */ (function (_super) {
         if (!point.isNode) {
             attribs.stroke = values.linkColor;
             attribs['stroke-width'] = values.linkLineWidth;
+            attribs.opacity = values.linkOpacity;
             delete attribs.fill;
         }
         else {
@@ -302,12 +303,15 @@ var OrganizationSeries = /** @class */ (function (_super) {
      * @product      highcharts
      * @requires     modules/organization
      * @optionparent plotOptions.organization
+     *
+     * @private
      */
     OrganizationSeries.defaultOptions = merge(SankeySeries.defaultOptions, {
         /**
          * The border color of the node cards.
          *
          * @type {Highcharts.ColorString}
+         *
          * @private
          */
         borderColor: "#666666" /* Palette.neutralColor60 */,
@@ -457,12 +461,15 @@ var OrganizationSeries = /** @class */ (function (_super) {
          * @type {Highcharts.OrganizationHangingIndentTranslationValue}
          * @since 10.0.0
          * @default inherit
+         *
+         * @private
          */
         hangingIndentTranslation: 'inherit',
         /**
          * The color of the links between nodes.
          *
          * @type {Highcharts.ColorString}
+         *
          * @private
          */
         linkColor: "#666666" /* Palette.neutralColor60 */,
@@ -485,6 +492,7 @@ var OrganizationSeries = /** @class */ (function (_super) {
          * is set to `shrink`.
          *
          * @see [nodeWidth](#plotOptions.organization.nodeWidth)
+         *
          * @private
          */
         minNodeLength: 10,

package/es-modules/Series/PackedBubble/PackedBubbleIntegration.js

@@ -0,0 +1,81 @@
+/* *
+ *
+ *  (c) 2010-2021 Grzegorz Blachlinski, Sebastian Bochan
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import H from '../../Core/Globals.js';
+var noop = H.noop;
+import VerletIntegration from '../Networkgraph/VerletIntegration.js';
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * @private
+ */
+function barycenter() {
+    var layout = this, gravitationalConstant = layout.options.gravitationalConstant, box = layout.box, nodes = layout.nodes;
+    var centerX, centerY;
+    for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+        var node = nodes_1[_i];
+        if (layout.options.splitSeries && !node.isParentNode) {
+            centerX = node.series.parentNode.plotX;
+            centerY = node.series.parentNode.plotY;
+        }
+        else {
+            centerX = box.width / 2;
+            centerY = box.height / 2;
+        }
+        if (!node.fixedPosition) {
+            node.plotX -=
+                (node.plotX - centerX) *
+                    gravitationalConstant /
+                    (node.mass * Math.sqrt(nodes.length));
+            node.plotY -=
+                (node.plotY - centerY) *
+                    gravitationalConstant /
+                    (node.mass * Math.sqrt(nodes.length));
+        }
+    }
+}
+/**
+ * @private
+ */
+function repulsive(node, force, distanceXY, repNode) {
+    var factor = (force * this.diffTemperature / node.mass /
+        node.degree), x = distanceXY.x * factor, y = distanceXY.y * factor;
+    if (!node.fixedPosition) {
+        node.plotX += x;
+        node.plotY += y;
+    }
+    if (!repNode.fixedPosition) {
+        repNode.plotX -= x;
+        repNode.plotY -= y;
+    }
+}
+/**
+ * @private
+ */
+function repulsiveForceFunction(d, k, node, repNode) {
+    return Math.min(d, (node.marker.radius +
+        repNode.marker.radius) / 2);
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+var PackedBubbleIntegration = {
+    barycenter: barycenter,
+    getK: noop,
+    integrate: VerletIntegration.integrate,
+    repulsive: repulsive,
+    repulsiveForceFunction: repulsiveForceFunction
+};
+export default PackedBubbleIntegration;

package/es-modules/Series/PackedBubble/{PackedBubbleComposition.js → PackedBubbleLayout.js}

@@ -8,70 +8,96 @@
  *
  * */
 'use strict';
-import Chart from '../../Core/Chart/Chart.js';
-import H from '../../Core/Globals.js';
-import '../../Series/Networkgraph/Layouts.js';
-var Reingold = H.layouts['reingold-fruchterman'];
+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 GraphLayout from '../GraphLayoutComposition.js';
+import PackedBubbleIntegration from './PackedBubbleIntegration.js';
+import ReingoldFruchtermanLayout from '../Networkgraph/ReingoldFruchtermanLayout.js';
 import U from '../../Core/Utilities.js';
-var addEvent = U.addEvent, extendClass = U.extendClass, pick = U.pick;
+var addEvent = U.addEvent, pick = U.pick;
 /* *
  *
- *  Composition
+ *  Constants
  *
  * */
-Chart.prototype.getSelectedParentNodes = function () {
-    var chart = this, series = chart.series, selectedParentsNodes = [];
-    series.forEach(function (series) {
+var composedClasses = [];
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * @private
+ */
+function chartGetSelectedParentNodes() {
+    var allSeries = this.series, selectedParentsNodes = [];
+    allSeries.forEach(function (series) {
         if (series.parentNode && series.parentNode.selected) {
             selectedParentsNodes.push(series.parentNode);
         }
     });
     return selectedParentsNodes;
-};
-H.networkgraphIntegrations.packedbubble = {
-    repulsiveForceFunction: function (d, k, node, repNode) {
-        return Math.min(d, (node.marker.radius + repNode.marker.radius) / 2);
-    },
-    barycenter: function () {
-        var layout = this, gravitationalConstant = layout.options.gravitationalConstant, box = layout.box, nodes = layout.nodes, centerX, centerY;
-        nodes.forEach(function (node) {
-            if (layout.options.splitSeries && !node.isParentNode) {
-                centerX = node.series.parentNode.plotX;
-                centerY = node.series.parentNode.plotY;
-            }
-            else {
-                centerX = box.width / 2;
-                centerY = box.height / 2;
-            }
-            if (!node.fixedPosition) {
-                node.plotX -=
-                    (node.plotX - centerX) *
-                        gravitationalConstant /
-                        (node.mass * Math.sqrt(nodes.length));
-                node.plotY -=
-                    (node.plotY - centerY) *
-                        gravitationalConstant /
-                        (node.mass * Math.sqrt(nodes.length));
-            }
-        });
-    },
-    repulsive: function (node, force, distanceXY, repNode) {
-        var factor = (force * this.diffTemperature / node.mass /
-            node.degree), x = distanceXY.x * factor, y = distanceXY.y * factor;
-        if (!node.fixedPosition) {
-            node.plotX += x;
-            node.plotY += y;
-        }
-        if (!repNode.fixedPosition) {
-            repNode.plotX -= x;
-            repNode.plotY -= y;
+}
+/**
+ * Remove accumulated data points to redistribute all of them again
+ * (i.e after hiding series by legend)
+ * @private
+ */
+function onChartBeforeRedraw() {
+    if (this.allDataPoints) {
+        delete this.allDataPoints;
+    }
+}
+/* *
+ *
+ *  Class
+ *
+ * */
+var PackedBubbleLayout = /** @class */ (function (_super) {
+    __extends(PackedBubbleLayout, _super);
+    function PackedBubbleLayout() {
+        /* *
+         *
+         *  Static Functions
+         *
+         * */
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.index = NaN;
+        _this.nodes = [];
+        _this.options = void 0;
+        _this.series = [];
+        return _this;
+    }
+    PackedBubbleLayout.compose = function (ChartClass) {
+        ReingoldFruchtermanLayout.compose(ChartClass);
+        GraphLayout.integrations.packedbubble = PackedBubbleIntegration;
+        GraphLayout.layouts.packedbubble = PackedBubbleLayout;
+        if (composedClasses.indexOf(ChartClass) === -1) {
+            composedClasses.push(ChartClass);
+            addEvent(ChartClass, 'beforeRedraw', onChartBeforeRedraw);
+            var chartProto = ChartClass.prototype;
+            chartProto.getSelectedParentNodes = chartGetSelectedParentNodes;
         }
-    },
-    integrate: H.networkgraphIntegrations.verlet.integrate,
-    getK: H.noop
-};
-H.layouts.packedbubble = extendClass(Reingold, {
-    beforeStep: function () {
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    PackedBubbleLayout.prototype.beforeStep = function () {
         if (this.options.marker) {
             this.series.forEach(function (series) {
                 if (series) {
@@ -79,9 +105,9 @@ H.layouts.packedbubble = extendClass(Reingold, {
                 }
             });
         }
-    },
+    };
     // #14439, new stable check.
-    isStable: function () {
+    PackedBubbleLayout.prototype.isStable = function () {
         var tempDiff = Math.abs(this.prevSystemTemperature -
             this.systemTemperature);
         var upScaledTemperature = 10 * this.systemTemperature /
@@ -89,10 +115,12 @@ H.layouts.packedbubble = extendClass(Reingold, {
         return Math.abs(upScaledTemperature) < 1 &&
             tempDiff < 0.00001 ||
             this.temperature <= 0;
-    },
-    setCircularPositions: function () {
-        var layout = this, box = layout.box, nodes = layout.nodes, nodesLength = nodes.length + 1, angle = 2 * Math.PI / nodesLength, centerX, centerY, radius = layout.options.initialPositionRadius;
-        nodes.forEach(function (node, index) {
+    };
+    PackedBubbleLayout.prototype.setCircularPositions = function () {
+        var layout = this, box = layout.box, nodes = layout.nodes, nodesLength = nodes.length + 1, angle = 2 * Math.PI / nodesLength, radius = layout.options.initialPositionRadius;
+        var centerX, centerY, index = 0;
+        for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+            var node = nodes_1[_i];
             if (layout.options.splitSeries &&
                 !node.isParentNode) {
                 centerX = node.series.parentNode.plotX;
@@ -108,17 +136,19 @@ H.layouts.packedbubble = extendClass(Reingold, {
                 radius * Math.sin(node.index || index * angle));
             node.dispX = 0;
             node.dispY = 0;
-        });
-    },
-    repulsiveForces: function () {
-        var layout = this, force, distanceR, distanceXY, bubblePadding = layout.options.bubblePadding;
+            index++;
+        }
+    };
+    PackedBubbleLayout.prototype.repulsiveForces = function () {
+        var layout = this, bubblePadding = layout.options.bubblePadding;
+        var force, distanceR, distanceXY;
         layout.nodes.forEach(function (node) {
             node.degree = node.mass;
             node.neighbours = 0;
             layout.nodes.forEach(function (repNode) {
                 force = 0;
                 if (
-                // Node can not repulse itself:
+                // Node cannot repulse itself:
                 node !== repNode &&
                     // Only close nodes affect each other:
                     // Not dragged:
@@ -140,9 +170,10 @@ H.layouts.packedbubble = extendClass(Reingold, {
                 }
             });
         });
-    },
-    applyLimitBox: function (node) {
-        var layout = this, distanceXY, distanceR, factor = 0.01;
+    };
+    PackedBubbleLayout.prototype.applyLimitBox = function (node, box) {
+        var layout = this, factor = 0.01;
+        var distanceXY, distanceR;
         // parentNodeLimit should be used together
         // with seriesInteraction: false
         if (layout.options.splitSeries &&
@@ -158,13 +189,19 @@ H.layouts.packedbubble = extendClass(Reingold, {
                 node.plotY -= distanceXY.y * factor;
             }
         }
-        Reingold.prototype.applyLimitBox.apply(this, arguments);
-    }
-});
-// Remove accumulated data points to redistribute all of them again
-// (i.e after hiding series by legend)
-addEvent(Chart, 'beforeRedraw', function () {
-    if (this.allDataPoints) {
-        delete this.allDataPoints;
-    }
-});
+        _super.prototype.applyLimitBox.call(this, node, box);
+    };
+    return PackedBubbleLayout;
+}(ReingoldFruchtermanLayout));
+/* *
+ *
+ *  Registry
+ *
+ * */
+GraphLayout.layouts.packedbubble = PackedBubbleLayout;
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default PackedBubbleLayout;

package/es-modules/Series/PackedBubble/PackedBubblePoint.js

@@ -26,7 +26,7 @@ var __extends = (this && this.__extends) || (function () {
 import Chart from '../../Core/Chart/Chart.js';
 import Point from '../../Core/Series/Point.js';
 import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
-var BubbleSeries = SeriesRegistry.seriesTypes.bubble;
+var BubblePoint = SeriesRegistry.seriesTypes.bubble.prototype.pointClass;
 /* *
  *
  *  Class
@@ -91,7 +91,7 @@ var PackedBubblePoint = /** @class */ (function (_super) {
         }
     };
     return PackedBubblePoint;
-}(BubbleSeries.prototype.pointClass));
+}(BubblePoint));
 /* *
  *
  *  Default Export