highcharts 10.2.0 → 10.2.1

package/es-modules/Core/Axis/TreeGrid/TreeGridTick.js

@@ -0,0 +1,313 @@
+/* *
+ *
+ *  (c) 2016 Highsoft AS
+ *  Authors: Jon Arild Nygard
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import U from '../../Utilities.js';
+var addEvent = U.addEvent, isObject = U.isObject, isNumber = U.isNumber, pick = U.pick, wrap = U.wrap;
+/* *
+ *
+ *  Constants
+ *
+ * */
+var composedClasses = [];
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * @private
+ */
+function onTickInit() {
+    var tick = this;
+    if (!tick.treeGrid) {
+        tick.treeGrid = new TreeGridTickAdditions(tick);
+    }
+}
+/**
+ * @private
+ */
+function onTickHover(label) {
+    label.addClass('highcharts-treegrid-node-active');
+    if (!label.renderer.styledMode) {
+        label.css({
+            textDecoration: 'underline'
+        });
+    }
+}
+/**
+ * @private
+ */
+function onTickHoverExit(label, options) {
+    var css = isObject(options.style) ? options.style : {};
+    label.removeClass('highcharts-treegrid-node-active');
+    if (!label.renderer.styledMode) {
+        label.css({ textDecoration: css.textDecoration });
+    }
+}
+/**
+ * @private
+ */
+function renderLabelIcon(tick, params) {
+    var treeGrid = tick.treeGrid, isNew = !treeGrid.labelIcon, renderer = params.renderer, labelBox = params.xy, options = params.options, width = options.width || 0, height = options.height || 0, iconCenter = {
+        x: labelBox.x - (width / 2) - (options.padding || 0),
+        y: labelBox.y - (height / 2)
+    }, rotation = params.collapsed ? 90 : 180, shouldRender = params.show && isNumber(iconCenter.y);
+    var icon = treeGrid.labelIcon;
+    if (!icon) {
+        treeGrid.labelIcon = icon = renderer
+            .path(renderer.symbols[options.type](options.x || 0, options.y || 0, width, height))
+            .addClass('highcharts-label-icon')
+            .add(params.group);
+    }
+    // Set the new position, and show or hide
+    icon[shouldRender ? 'show' : 'hide'](); // #14904, #1338
+    // Presentational attributes
+    if (!renderer.styledMode) {
+        icon
+            .attr({
+            cursor: 'pointer',
+            'fill': pick(params.color, "#666666" /* Palette.neutralColor60 */),
+            'stroke-width': 1,
+            stroke: options.lineColor,
+            strokeWidth: options.lineWidth || 0
+        });
+    }
+    // Update the icon positions
+    icon[isNew ? 'attr' : 'animate']({
+        translateX: iconCenter.x,
+        translateY: iconCenter.y,
+        rotation: rotation
+    });
+}
+/**
+ * @private
+ */
+function wrapGetLabelPosition(proceed, x, y, label, horiz, labelOptions, tickmarkOffset, index, step) {
+    var tick = this, lbOptions = pick(tick.options && tick.options.labels, labelOptions), pos = tick.pos, axis = tick.axis, options = axis.options, isTreeGrid = options.type === 'treegrid', result = proceed.apply(tick, [x, y, label, horiz, lbOptions, tickmarkOffset, index, step]);
+    var symbolOptions, indentation, mapOfPosToGridNode, node, level;
+    if (isTreeGrid) {
+        symbolOptions = (lbOptions && isObject(lbOptions.symbol, true) ?
+            lbOptions.symbol :
+            {});
+        indentation = (lbOptions && isNumber(lbOptions.indentation) ?
+            lbOptions.indentation :
+            0);
+        mapOfPosToGridNode = axis.treeGrid.mapOfPosToGridNode;
+        node = mapOfPosToGridNode && mapOfPosToGridNode[pos];
+        level = (node && node.depth) || 1;
+        result.x += (
+        // Add space for symbols
+        ((symbolOptions.width || 0) +
+            ((symbolOptions.padding || 0) * 2)) +
+            // Apply indentation
+            ((level - 1) * indentation));
+    }
+    return result;
+}
+/**
+ * @private
+ */
+function wrapRenderLabel(proceed) {
+    var tick = this, pos = tick.pos, axis = tick.axis, label = tick.label, mapOfPosToGridNode = axis.treeGrid.mapOfPosToGridNode, options = axis.options, labelOptions = pick(tick.options && tick.options.labels, options && options.labels), symbolOptions = (labelOptions && isObject(labelOptions.symbol, true) ?
+        labelOptions.symbol :
+        {}), node = mapOfPosToGridNode && mapOfPosToGridNode[pos], level = node && node.depth, isTreeGrid = options.type === 'treegrid', shouldRender = axis.tickPositions.indexOf(pos) > -1, prefixClassName = 'highcharts-treegrid-node-', styledMode = axis.chart.styledMode;
+    var collapsed, addClassName, removeClassName;
+    if (isTreeGrid && node) {
+        // Add class name for hierarchical styling.
+        if (label &&
+            label.element) {
+            label.addClass(prefixClassName + 'level-' + level);
+        }
+    }
+    proceed.apply(tick, Array.prototype.slice.call(arguments, 1));
+    if (isTreeGrid &&
+        label &&
+        label.element &&
+        node &&
+        node.descendants &&
+        node.descendants > 0) {
+        collapsed = axis.treeGrid.isCollapsed(node);
+        renderLabelIcon(tick, {
+            color: (!styledMode &&
+                label.styles &&
+                label.styles.color ||
+                ''),
+            collapsed: collapsed,
+            group: label.parentGroup,
+            options: symbolOptions,
+            renderer: label.renderer,
+            show: shouldRender,
+            xy: label.xy
+        });
+        // Add class name for the node.
+        addClassName = prefixClassName +
+            (collapsed ? 'collapsed' : 'expanded');
+        removeClassName = prefixClassName +
+            (collapsed ? 'expanded' : 'collapsed');
+        label
+            .addClass(addClassName)
+            .removeClass(removeClassName);
+        if (!styledMode) {
+            label.css({
+                cursor: 'pointer'
+            });
+        }
+        // Add events to both label text and icon
+        [label, tick.treeGrid.labelIcon].forEach(function (object) {
+            if (object && !object.attachedTreeGridEvents) {
+                // On hover
+                addEvent(object.element, 'mouseover', function () {
+                    onTickHover(label);
+                });
+                // On hover out
+                addEvent(object.element, 'mouseout', function () {
+                    onTickHoverExit(label, labelOptions);
+                });
+                addEvent(object.element, 'click', function () {
+                    tick.treeGrid.toggleCollapse();
+                });
+                object.attachedTreeGridEvents = true;
+            }
+        });
+    }
+}
+/* *
+ *
+ *  Classes
+ *
+ * */
+/**
+ * @private
+ * @class
+ */
+var TreeGridTickAdditions = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    /**
+     * @private
+     */
+    function TreeGridTickAdditions(tick) {
+        this.tick = tick;
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * @private
+     */
+    TreeGridTickAdditions.compose = function (TickClass) {
+        if (composedClasses.indexOf(TickClass) === -1) {
+            composedClasses.push(TickClass);
+            addEvent(TickClass, 'init', onTickInit);
+            wrap(TickClass.prototype, 'getLabelPosition', wrapGetLabelPosition);
+            wrap(TickClass.prototype, 'renderLabel', wrapRenderLabel);
+            // backwards compatibility
+            TickClass.prototype.collapse = function (redraw) {
+                this.treeGrid.collapse(redraw);
+            };
+            TickClass.prototype.expand = function (redraw) {
+                this.treeGrid.expand(redraw);
+            };
+            TickClass.prototype.toggleCollapse = function (redraw) {
+                this.treeGrid.toggleCollapse(redraw);
+            };
+        }
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Collapse the grid cell. Used when axis is of type treegrid.
+     *
+     * @see gantt/treegrid-axis/collapsed-dynamically/demo.js
+     *
+     * @private
+     * @function Highcharts.Tick#collapse
+     *
+     * @param {boolean} [redraw=true]
+     * Whether to redraw the chart or wait for an explicit call to
+     * {@link Highcharts.Chart#redraw}
+     */
+    TreeGridTickAdditions.prototype.collapse = function (redraw) {
+        var tick = this.tick, axis = tick.axis, brokenAxis = axis.brokenAxis;
+        if (brokenAxis &&
+            axis.treeGrid.mapOfPosToGridNode) {
+            var pos = tick.pos, node = axis.treeGrid.mapOfPosToGridNode[pos], breaks = axis.treeGrid.collapse(node);
+            brokenAxis.setBreaks(breaks, pick(redraw, true));
+        }
+    };
+    /**
+     * Destroy remaining labelIcon if exist.
+     *
+     * @private
+     * @function Highcharts.Tick#destroy
+     */
+    TreeGridTickAdditions.prototype.destroy = function () {
+        if (this.labelIcon) {
+            this.labelIcon.destroy();
+        }
+    };
+    /**
+     * Expand the grid cell. Used when axis is of type treegrid.
+     *
+     * @see gantt/treegrid-axis/collapsed-dynamically/demo.js
+     *
+     * @private
+     * @function Highcharts.Tick#expand
+     *
+     * @param {boolean} [redraw=true]
+     * Whether to redraw the chart or wait for an explicit call to
+     * {@link Highcharts.Chart#redraw}
+     */
+    TreeGridTickAdditions.prototype.expand = function (redraw) {
+        var tick = this.tick, axis = tick.axis, brokenAxis = axis.brokenAxis;
+        if (brokenAxis &&
+            axis.treeGrid.mapOfPosToGridNode) {
+            var pos = tick.pos, node = axis.treeGrid.mapOfPosToGridNode[pos], breaks = axis.treeGrid.expand(node);
+            brokenAxis.setBreaks(breaks, pick(redraw, true));
+        }
+    };
+    /**
+     * Toggle the collapse/expand state of the grid cell. Used when axis is
+     * of type treegrid.
+     *
+     * @see gantt/treegrid-axis/collapsed-dynamically/demo.js
+     *
+     * @private
+     * @function Highcharts.Tick#toggleCollapse
+     *
+     * @param {boolean} [redraw=true]
+     * Whether to redraw the chart or wait for an explicit call to
+     * {@link Highcharts.Chart#redraw}
+     */
+    TreeGridTickAdditions.prototype.toggleCollapse = function (redraw) {
+        var tick = this.tick, axis = tick.axis, brokenAxis = axis.brokenAxis;
+        if (brokenAxis &&
+            axis.treeGrid.mapOfPosToGridNode) {
+            var pos = tick.pos, node = axis.treeGrid.mapOfPosToGridNode[pos], breaks = axis.treeGrid.toggleCollapse(node);
+            brokenAxis.setBreaks(breaks, pick(redraw, true));
+        }
+    };
+    return TreeGridTickAdditions;
+}());
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default TreeGridTickAdditions;

package/es-modules/Core/Axis/WaterfallAxis.js

@@ -8,7 +8,7 @@
  *
  * */
 'use strict';
-import StackItem from '../../Extensions/Stacking.js';
+import StackItem from './Stacking/StackItem.js';
 import U from '../Utilities.js';
 var addEvent = U.addEvent, objectEach = U.objectEach;
 /**

package/es-modules/Core/Axis/ZAxis.js

@@ -26,56 +26,46 @@ var __extends = (this && this.__extends) || (function () {
 import Axis from './Axis.js';
 import U from '../Utilities.js';
 var addEvent = U.addEvent, merge = U.merge, pick = U.pick, splat = U.splat;
-/* eslint-disable valid-jsdoc */
+/* *
+ *
+ *  Constants
+ *
+ * */
+var composedClasses = [];
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * @private
+ */
+function chartAddZAxis(options) {
+    return new ZAxis(this, options);
+}
 /**
- * 3D chart with support of z coordinates.
+ * Get the Z axis in addition to the default X and Y.
  * @private
- * @class
  */
-var ZChart = /** @class */ (function () {
-    function ZChart() {
+function onChartAfterGetAxes() {
+    var _this = this;
+    var zAxisOptions = this.options.zAxis = splat(this.options.zAxis || {});
+    if (!this.is3d()) {
+        return;
     }
-    /* *
-     *
-     *  Static Functions
-     *
-     * */
-    ZChart.compose = function (ChartClass) {
-        addEvent(ChartClass, 'afterGetAxes', ZChart.onAfterGetAxes);
-        var chartProto = ChartClass.prototype;
-        chartProto.addZAxis = ZChart.wrapAddZAxis;
-        chartProto.collectionsWithInit.zAxis = [chartProto.addZAxis];
-        chartProto.collectionsWithUpdate.push('zAxis');
-    };
-    /**
-     * Get the Z axis in addition to the default X and Y.
-     * @private
-     */
-    ZChart.onAfterGetAxes = function () {
-        var chart = this;
-        var options = this.options;
-        var zAxisOptions = options.zAxis = splat(options.zAxis || {});
-        if (!chart.is3d()) {
-            return;
-        }
-        chart.zAxis = [];
-        zAxisOptions.forEach(function (axisOptions, i) {
-            axisOptions.index = i;
-            // Z-Axis is shown horizontally, so it's kind of a X-Axis
-            axisOptions.isX = true;
-            chart
-                .addZAxis(axisOptions)
-                .setScale();
-        });
-    };
-    /**
-     * @private
-     */
-    ZChart.wrapAddZAxis = function (options) {
-        return new ZAxis(this, options);
-    };
-    return ZChart;
-}());
+    this.zAxis = [];
+    zAxisOptions.forEach(function (axisOptions, i) {
+        axisOptions.index = i;
+        // Z-Axis is shown horizontally, so it's kind of a X-Axis
+        axisOptions.isX = true;
+        _this.addZAxis(axisOptions).setScale();
+    });
+}
+/* *
+ *
+ *  Class
+ *
+ * */
 /**
  * 3D axis for z coordinates.
  */
@@ -83,7 +73,7 @@ var ZAxis = /** @class */ (function (_super) {
     __extends(ZAxis, _super);
     /* *
      *
-     *  Constructors
+     *  Constructor
      *
      * */
     function ZAxis(chart, userOptions) {
@@ -91,34 +81,49 @@ var ZAxis = /** @class */ (function (_super) {
         _this.isZAxis = true;
         return _this;
     }
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    ZAxis.compose = function (ChartClass) {
+        if (composedClasses.indexOf(ChartClass) === -1) {
+            composedClasses.push(ChartClass);
+            addEvent(ChartClass, 'afterGetAxes', onChartAfterGetAxes);
+            var chartProto = ChartClass.prototype;
+            chartProto.addZAxis = chartAddZAxis;
+            chartProto.collectionsWithInit.zAxis = [chartProto.addZAxis];
+            chartProto.collectionsWithUpdate.push('zAxis');
+        }
+    };
     /* *
      *
      *  Functions
      *
      * */
     ZAxis.prototype.getSeriesExtremes = function () {
-        var axis = this;
-        var chart = axis.chart;
-        axis.hasVisibleSeries = false;
+        var _this = this;
+        var chart = this.chart;
+        this.hasVisibleSeries = false;
         // Reset properties in case we're redrawing (#3353)
-        axis.dataMin = axis.dataMax = axis.ignoreMinPadding = (axis.ignoreMaxPadding = void 0);
-        if (axis.stacking) {
-            axis.stacking.buildStacks();
+        this.dataMin = this.dataMax = this.ignoreMinPadding = (this.ignoreMaxPadding = void 0);
+        if (this.stacking) {
+            this.stacking.buildStacks();
         }
         // loop through this axis' series
-        axis.series.forEach(function (series) {
+        this.series.forEach(function (series) {
             if (series.visible ||
                 !chart.options.chart.ignoreHiddenSeries) {
-                var seriesOptions = series.options, zData = void 0, threshold = seriesOptions.threshold;
-                axis.hasVisibleSeries = true;
+                var threshold = series.options.threshold;
+                _this.hasVisibleSeries = true;
                 // Validate threshold in logarithmic axes
-                if (axis.positiveValuesOnly && threshold <= 0) {
+                if (_this.positiveValuesOnly && threshold <= 0) {
                     threshold = void 0;
                 }
-                zData = series.zData;
+                var zData = series.zData;
                 if (zData.length) {
-                    axis.dataMin = Math.min(pick(axis.dataMin, zData[0]), Math.min.apply(null, zData));
-                    axis.dataMax = Math.max(pick(axis.dataMax, zData[0]), Math.max.apply(null, zData));
+                    _this.dataMin = Math.min(pick(_this.dataMin, zData[0]), Math.min.apply(null, zData));
+                    _this.dataMax = Math.max(pick(_this.dataMax, zData[0]), Math.max.apply(null, zData));
                 }
             }
         });
@@ -127,12 +132,11 @@ var ZAxis = /** @class */ (function (_super) {
      * @private
      */
     ZAxis.prototype.setAxisSize = function () {
-        var axis = this;
-        var chart = axis.chart;
+        var chart = this.chart;
         _super.prototype.setAxisSize.call(this);
-        axis.width = axis.len = (chart.options.chart.options3d &&
+        this.width = this.len = (chart.options.chart.options3d &&
             chart.options.chart.options3d.depth) || 0;
-        axis.right = chart.chartWidth - axis.width - axis.left;
+        this.right = chart.chartWidth - this.width - this.left;
     };
     /**
      * @private
@@ -147,12 +151,11 @@ var ZAxis = /** @class */ (function (_super) {
         _super.prototype.setOptions.call(this, userOptions);
         this.coll = 'zAxis';
     };
-    /* *
-     *
-     *  Static Properties
-     *
-     * */
-    ZAxis.ZChartComposition = ZChart;
     return ZAxis;
 }(Axis));
+/* *
+ *
+ *  Default Export
+ *
+ * */
 export default ZAxis;

package/es-modules/Core/Chart/Chart.js

@@ -219,6 +219,15 @@ var Chart = /** @class */ (function () {
             this.labelCollectors = [];
             this.callback = callback;
             this.isResizing = 0;
+            var zooming = optionsChart.zooming = optionsChart.zooming || {};
+            // Other options have no default so just pick
+            if (userOptions.chart && !userOptions.chart.zooming) {
+                zooming.resetButton = optionsChart.resetZoomButton;
+            }
+            zooming.key = pick(zooming.key, optionsChart.zoomKey);
+            zooming.pinchType = pick(zooming.pinchType, optionsChart.pinchType);
+            zooming.singleTouch = pick(zooming.singleTouch, optionsChart.zoomBySingleTouch);
+            zooming.type = pick(zooming.type, optionsChart.zoomType);
             /**
              * The options structure for the chart after merging
              * {@link #defaultOptions} and {@link #userOptions}. It contains
@@ -2515,7 +2524,7 @@ var Chart = /** @class */ (function () {
      * @emits Highcharts.Chart#event:beforeShowResetZoom
      */
     Chart.prototype.showResetZoom = function () {
-        var chart = this, lang = defaultOptions.lang, btnOptions = chart.options.chart.resetZoomButton, theme = btnOptions.theme, alignTo = (btnOptions.relativeTo === 'chart' ||
+        var chart = this, lang = defaultOptions.lang, btnOptions = chart.options.chart.zooming.resetButton, theme = btnOptions.theme, alignTo = (btnOptions.relativeTo === 'chart' ||
             btnOptions.relativeTo === 'spacingBox' ?
             null :
             'scrollablePlotBox');
@@ -2740,6 +2749,8 @@ extend(Chart.prototype, {
      *
      * Note: We need to define these references after initializers are bound to
      * chart's prototype.
+     *
+     * @private
      */
     collectionsWithInit: {
         // collectionName: [ initializingMethod, [extraArguments] ]
@@ -2750,6 +2761,7 @@ extend(Chart.prototype, {
     /**
      * These collections (arrays) implement update() methods with support for
      * one-to-one option.
+     * @private
      */
     collectionsWithUpdate: [
         'xAxis',
@@ -2759,6 +2771,7 @@ extend(Chart.prototype, {
     /**
      * These properties cause isDirtyBox to be set to true when updating. Can be
      * extended from plugins.
+     * @private
      */
     propsRequireDirtyBox: [
         'backgroundColor',
@@ -2775,7 +2788,7 @@ extend(Chart.prototype, {
     /**
      * These properties require a full reflow of chart elements, best
      * implemented through running `Chart.setSize` internally (#8190).
-     * @type {Array}
+     * @private
      */
     propsRequireReflow: [
         'margin',
@@ -2792,6 +2805,7 @@ extend(Chart.prototype, {
     /**
      * These properties cause all series to be updated when updating. Can be
      * extended from plugins.
+     * @private
      */
     propsRequireUpdateSeries: [
         'chart.inverted',

package/es-modules/Core/Chart/Chart3D.js

@@ -12,7 +12,7 @@
 'use strict';
 import Color from '../Color/Color.js';
 var color = Color.parse;
-import Math3D from '../../Extensions/Math3D.js';
+import Math3D from '../Math3D.js';
 var perspective = Math3D.perspective, shapeArea3D = Math3D.shapeArea3D;
 import D from '../DefaultOptions.js';
 var genericDefaultOptions = D.defaultOptions;
@@ -469,7 +469,7 @@ var Chart3D;
              */
             options3d: {
                 /**
-                 * Wether to render the chart using the 3D functionality.
+                 * Whether to render the chart using the 3D functionality.
                  *
                  * @since   4.0
                  * @product highcharts