highcharts 10.0.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/NodesComposition.js

@@ -4,8 +4,8 @@
  *
  * */
 'use strict';
-import Point from '../Core/Series/Point.js';
-import Series from '../Core/Series/Series.js';
+import SeriesRegistry from '../Core/Series/SeriesRegistry.js';
+var _a = SeriesRegistry.series, seriesProto = _a.prototype, pointProto = _a.prototype.pointClass.prototype;
 import U from '../Core/Utilities.js';
 var defined = U.defined, extend = U.extend, find = U.find, merge = U.merge, pick = U.pick;
 /* *
@@ -31,23 +31,22 @@ var NodesComposition;
      *  Functions
      *
      * */
-    /* eslint-disable valid-jsdoc */
     /**
      * @private
      */
     function compose(PointClass, SeriesClass) {
         if (composedClasses.indexOf(PointClass) === -1) {
             composedClasses.push(PointClass);
-            var pointProto = PointClass.prototype;
-            pointProto.setNodeState = setNodeState;
-            pointProto.setState = setNodeState;
-            pointProto.update = updateNode;
+            var pointProto_1 = PointClass.prototype;
+            pointProto_1.setNodeState = setNodeState;
+            pointProto_1.setState = setNodeState;
+            pointProto_1.update = updateNode;
         }
         if (composedClasses.indexOf(SeriesClass) === -1) {
             composedClasses.push(SeriesClass);
-            var seriesProto = SeriesClass.prototype;
-            seriesProto.destroy = destroy;
-            seriesProto.setData = setData;
+            var seriesProto_1 = SeriesClass.prototype;
+            seriesProto_1.destroy = destroy;
+            seriesProto_1.setData = setData;
         }
         return SeriesClass;
     }
@@ -62,25 +61,25 @@ var NodesComposition;
         var node = findById(this.nodes, id), options;
         if (!node) {
             options = this.options.nodes && findById(this.options.nodes, id);
-            node = (new PointClass()).init(this, extend({
+            var newNode_1 = (new PointClass()).init(this, extend({
                 className: 'highcharts-node',
                 isNode: true,
                 id: id,
                 y: 1 // Pass isNull test
             }, options));
-            node.linksTo = [];
-            node.linksFrom = [];
+            newNode_1.linksTo = [];
+            newNode_1.linksFrom = [];
             /**
              * Return the largest sum of either the incoming or outgoing links.
              * @private
              */
-            node.getSum = function () {
+            newNode_1.getSum = function () {
                 var sumTo = 0, sumFrom = 0;
-                node.linksTo.forEach(function (link) {
-                    sumTo += link.weight;
+                newNode_1.linksTo.forEach(function (link) {
+                    sumTo += link.weight || 0;
                 });
-                node.linksFrom.forEach(function (link) {
-                    sumFrom += link.weight;
+                newNode_1.linksFrom.forEach(function (link) {
+                    sumFrom += link.weight || 0;
                 });
                 return Math.max(sumTo, sumFrom);
             };
@@ -88,28 +87,29 @@ var NodesComposition;
              * Get the offset in weight values of a point/link.
              * @private
              */
-            node.offset = function (point, coll) {
+            newNode_1.offset = function (point, coll) {
                 var offset = 0;
-                for (var i = 0; i < node[coll].length; i++) {
-                    if (node[coll][i] === point) {
+                for (var i = 0; i < newNode_1[coll].length; i++) {
+                    if (newNode_1[coll][i] === point) {
                         return offset;
                     }
-                    offset += node[coll][i].weight;
+                    offset += newNode_1[coll][i].weight;
                 }
             };
             // Return true if the node has a shape, otherwise all links are
             // outgoing.
-            node.hasShape = function () {
+            newNode_1.hasShape = function () {
                 var outgoing = 0;
-                node.linksTo.forEach(function (link) {
+                newNode_1.linksTo.forEach(function (link) {
                     if (link.outgoing) {
                         outgoing++;
                     }
                 });
-                return (!node.linksTo.length ||
-                    outgoing !== node.linksTo.length);
+                return (!newNode_1.linksTo.length ||
+                    outgoing !== newNode_1.linksTo.length);
             };
-            node.index = this.nodes.push(node) - 1;
+            newNode_1.index = this.nodes.push(newNode_1) - 1;
+            node = newNode_1;
         }
         node.formatPrefix = 'node';
         // for use in formats
@@ -133,16 +133,18 @@ var NodesComposition;
         // Nodes must also be destroyed (#8682, #9300)
         this.data = []
             .concat(this.points || [], this.nodes);
-        return Series.prototype.destroy.apply(this, arguments);
+        return seriesProto.destroy.apply(this, arguments);
     }
     NodesComposition.destroy = destroy;
     /**
-     * Extend generatePoints by adding the nodes, which are Point objects
-     * but pushed to the this.nodes array.
+     * Extend generatePoints by adding the nodes, which are Point objects but
+     * pushed to the this.nodes array.
+     * @private
      */
     function generatePoints() {
+        var _this = this;
         var chart = this.chart, nodeLookup = {};
-        Series.prototype.generatePoints.call(this);
+        seriesProto.generatePoints.call(this);
         if (!this.nodes) {
             this.nodes = []; // List of Point-like node items
         }
@@ -157,7 +159,7 @@ var NodesComposition;
         this.points.forEach(function (point) {
             if (defined(point.from)) {
                 if (!nodeLookup[point.from]) {
-                    nodeLookup[point.from] = this.createNode(point.from);
+                    nodeLookup[point.from] = _this.createNode(point.from);
                 }
                 nodeLookup[point.from].linksFrom.push(point);
                 point.fromNode = nodeLookup[point.from];
@@ -172,7 +174,7 @@ var NodesComposition;
             }
             if (defined(point.to)) {
                 if (!nodeLookup[point.to]) {
-                    nodeLookup[point.to] = this.createNode(point.to);
+                    nodeLookup[point.to] = _this.createNode(point.to);
                 }
                 nodeLookup[point.to].linksTo.push(point);
                 point.toNode = nodeLookup[point.to];
@@ -194,11 +196,12 @@ var NodesComposition;
             });
             this.nodes.length = 0;
         }
-        Series.prototype.setData.apply(this, arguments);
+        seriesProto.setData.apply(this, arguments);
     }
     /**
      * When hovering node, highlight all connected links. When hovering a link,
      * highlight all connected nodes.
+     * @private
      */
     function setNodeState(state) {
         var args = arguments, others = this.isNode ? this.linksTo.concat(this.linksFrom) :
@@ -206,28 +209,30 @@ var NodesComposition;
         if (state !== 'select') {
             others.forEach(function (linkOrNode) {
                 if (linkOrNode && linkOrNode.series) {
-                    Point.prototype.setState.apply(linkOrNode, args);
+                    pointProto.setState.apply(linkOrNode, args);
                     if (!linkOrNode.isNode) {
                         if (linkOrNode.fromNode.graphic) {
-                            Point.prototype.setState.apply(linkOrNode.fromNode, args);
+                            pointProto.setState.apply(linkOrNode.fromNode, args);
                         }
                         if (linkOrNode.toNode && linkOrNode.toNode.graphic) {
-                            Point.prototype.setState.apply(linkOrNode.toNode, args);
+                            pointProto.setState.apply(linkOrNode.toNode, args);
                         }
                     }
                 }
             });
         }
-        Point.prototype.setState.apply(this, args);
+        pointProto.setState.apply(this, args);
     }
     NodesComposition.setNodeState = setNodeState;
     /**
-     * When updating a node, don't update `series.options.data`, but `series.options.nodes`
+     * When updating a node, don't update `series.options.data`, but
+     * `series.options.nodes`
+     * @private
      */
     function updateNode(options, redraw, animation, runEvent) {
         var _this = this;
         var nodes = this.series.options.nodes, data = this.series.options.data, dataLength = data && data.length || 0, linkConfig = data && data[this.index];
-        Point.prototype.update.call(this, options, this.isNode ? false : redraw, // Hold the redraw for nodes
+        pointProto.update.call(this, options, this.isNode ? false : redraw, // Hold the redraw for nodes
         animation, runEvent);
         if (this.isNode) {
             // this.index refers to `series.nodes`, not `options.nodes` array

package/es-modules/Series/OHLC/OHLCPoint.js

@@ -12,10 +12,12 @@ 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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+            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 __());

package/es-modules/Series/OHLC/OHLCSeries.js

@@ -12,10 +12,12 @@ 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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+            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 __());

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

@@ -14,10 +14,12 @@ 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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+            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 __());

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

@@ -14,10 +14,12 @@ 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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+            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 __());
@@ -180,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;
@@ -188,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 {
@@ -300,15 +303,18 @@ 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" /* neutralColor60 */,
+        borderColor: "#666666" /* Palette.neutralColor60 */,
         /**
          * The border radius of the node cards.
          *
@@ -455,15 +461,18 @@ 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" /* neutralColor60 */,
+        linkColor: "#666666" /* Palette.neutralColor60 */,
         /**
          * The line width of the links connecting nodes, in pixels.
          *
@@ -483,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;