aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/es-modules/modules/debugger.src.js

@@ -0,0 +1,109 @@
+/* *
+ *
+ *  (c) 2010-2019 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+
+var addEvent = H.addEvent,
+    isNumber = H.isNumber,
+    setOptions = H.setOptions,
+    each = H.each;
+
+setOptions({
+    /**
+     * @optionparent chart
+     */
+    chart: {
+        /**
+         * Whether to display errors on the chart. When `false`, the errors will
+         * be shown only in the console.
+         *
+         * Requires `debugger.js` module.
+         *
+         * @sample highcharts/chart/display-errors/
+         *         Show errors on chart
+         *
+         * @since 7.0.0
+         */
+        displayErrors: true
+    }
+});
+
+addEvent(H.Chart, 'displayError', function (e) {
+    var chart = this,
+        code = e.code,
+        msg,
+        options = chart.options.chart,
+        renderer = chart.renderer,
+        chartWidth,
+        chartHeight;
+
+    if (chart.errorElements) {
+        each(chart.errorElements, function (el) {
+            if (el) {
+                el.destroy();
+            }
+        });
+    }
+
+    if (options && options.displayErrors) {
+        chart.errorElements = [];
+        msg = isNumber(code) ? 'Highcharts error #' + code + ': ' +
+            H.errorMessages[code].title + H.errorMessages[code].text : code;
+        chartWidth = chart.chartWidth;
+        chartHeight = chart.chartHeight;
+
+        // Render red chart frame.
+        chart.errorElements[0] = renderer.rect(
+            2,
+            2,
+            chartWidth - 4,
+            chartHeight - 4
+        ).attr({
+            'stroke-width': 4,
+            stroke: '#ff0000',
+            zIndex: 3
+        }).add();
+
+        // Render error message.
+        chart.errorElements[1] = renderer.label(
+            msg,
+            0,
+            0,
+            'rect',
+            null,
+            null,
+            true
+        ).css({
+            color: '#ffffff',
+            width: chartWidth - 16,
+            padding: 0
+        }).attr({
+            fill: '#ff0000',
+            width: chartWidth,
+            padding: 8,
+            zIndex: 10
+        }).add();
+
+        chart.errorElements[1].attr({
+            y: chartHeight - this.errorElements[1].getBBox().height
+        });
+    }
+});
+
+addEvent(H.Chart, 'beforeRedraw', function () {
+    var errorElements = this.errorElements;
+
+    if (errorElements && errorElements.length) {
+        each(errorElements, function (el) {
+            el.destroy();
+        });
+    }
+    this.errorElements = null;
+});

data/vendor/assets/javascripts/highstock/es-modules/modules/dependency-wheel.src.js

@@ -0,0 +1,199 @@
+/* *
+ * Experimental dependency wheel module
+ *
+ * (c) 2018 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import '../parts/Options.js';
+import '../mixins/nodes.js';
+
+var unsupportedSeriesType = H.seriesType;
+
+var base = H.seriesTypes.sankey.prototype;
+
+unsupportedSeriesType('dependencywheel', 'sankey', {
+    center: [],
+    curveFactor: 0.6,
+    startAngle: 0
+}, {
+    orderNodes: false,
+    getCenter: H.seriesTypes.pie.prototype.getCenter,
+
+    // Dependency wheel has only one column, it runs along the perimeter
+    createNodeColumns: function () {
+        var columns = [this.createNodeColumn()];
+        this.nodes.forEach(function (node) {
+            node.column = 0;
+            columns[0].push(node);
+        });
+        return columns;
+    },
+
+    // Translate from vertical pixels to perimeter
+    getNodePadding: function () {
+        return this.options.nodePadding / Math.PI;
+    },
+
+    createNode: function (id) {
+        var node = base.createNode.call(this, id);
+        node.index = this.nodes.length - 1;
+
+        // Return the sum of incoming and outgoing links
+        node.getSum = function () {
+            return node.linksFrom.concat(node.linksTo)
+                .reduce(function (acc, link) {
+                    return acc + link.weight;
+                }, 0);
+        };
+
+        // Get the offset in weight values of a point/link.
+        node.offset = function (point) {
+
+            var offset = 0,
+                i,
+                links = node.linksFrom.concat(node.linksTo),
+                sliced;
+
+            function otherNode(link) {
+                if (link.fromNode === node) {
+                    return link.toNode;
+                }
+                return link.fromNode;
+            }
+
+            // Sort and slice the links to avoid links going out of each node
+            // crossing each other.
+            links.sort(function (a, b) {
+                return otherNode(a).index - otherNode(b).index;
+            });
+            for (i = 0; i < links.length; i++) {
+                if (otherNode(links[i]).index > node.index) {
+                    links = links.slice(0, i).reverse().concat(
+                        links.slice(i).reverse()
+                    );
+                    sliced = true;
+                    break;
+                }
+            }
+            if (!sliced) {
+                links.reverse();
+            }
+
+            for (i = 0; i < links.length; i++) {
+                if (links[i] === point) {
+                    return offset;
+                }
+                offset += links[i].weight;
+            }
+        };
+
+        return node;
+    },
+
+    // @todo: Override the refactored sankey translateLink and translateNode
+    // functions instead of the whole translate function
+    translate: function () {
+
+        var options = this.options,
+            factor = 2 * Math.PI /
+                (this.chart.plotHeight + this.getNodePadding()),
+            center = this.getCenter(),
+            startAngle = (options.startAngle - 90) * H.deg2rad;
+
+        base.translate.call(this);
+
+        this.nodeColumns[0].forEach(function (node) {
+            var shapeArgs = node.shapeArgs,
+                centerX = center[0],
+                centerY = center[1],
+                r = center[2] / 2,
+                innerR = r - options.nodeWidth,
+                start = startAngle + factor * shapeArgs.y,
+                end = startAngle + factor * (shapeArgs.y + shapeArgs.height);
+
+            node.shapeType = 'arc';
+            node.shapeArgs = {
+                x: centerX,
+                y: centerY,
+                r: r,
+                innerR: innerR,
+                start: start,
+                end: end
+            };
+
+            node.dlBox = {
+                x: centerX + Math.cos((start + end) / 2) * (r + innerR) / 2,
+                y: centerY + Math.sin((start + end) / 2) * (r + innerR) / 2,
+                width: 1,
+                height: 1
+            };
+
+            // Draw the links from this node
+            node.linksFrom.forEach(function (point) {
+                var distance;
+                var corners = point.linkBase.map(function (top, i) {
+                    var angle = factor * top,
+                        x = Math.cos(startAngle + angle) * (innerR + 1),
+                        y = Math.sin(startAngle + angle) * (innerR + 1),
+                        curveFactor = options.curveFactor;
+
+                    // The distance between the from and to node along the
+                    // perimeter. This affect how curved the link is, so that
+                    // links between neighbours don't extend too far towards the
+                    // center.
+                    distance = Math.abs(point.linkBase[3 - i] * factor - angle);
+                    if (distance > Math.PI) {
+                        distance = 2 * Math.PI - distance;
+                    }
+                    distance = distance * innerR;
+                    if (distance < innerR) {
+                        curveFactor *= (distance / innerR);
+                    }
+
+
+                    return {
+                        x: centerX + x,
+                        y: centerY + y,
+                        cpX: centerX + (1 - curveFactor) * x,
+                        cpY: centerY + (1 - curveFactor) * y
+                    };
+                });
+
+                point.shapeArgs = {
+                    d: [
+                        'M',
+                        corners[0].x, corners[0].y,
+                        'A',
+                        innerR, innerR,
+                        0,
+                        0, // long arc
+                        1, // clockwise
+                        corners[1].x, corners[1].y,
+                        'C',
+                        corners[1].cpX, corners[1].cpY,
+                        corners[2].cpX, corners[2].cpY,
+                        corners[2].x, corners[2].y,
+                        'A',
+                        innerR, innerR,
+                        0,
+                        0,
+                        1,
+                        corners[3].x, corners[3].y,
+                        'C',
+                        corners[3].cpX, corners[3].cpY,
+                        corners[0].cpX, corners[0].cpY,
+                        corners[0].x, corners[0].y
+                    ]
+                };
+
+            });
+
+        });
+    }
+});

data/vendor/assets/javascripts/highstock/es-modules/modules/drag-panes.src.js

@@ -0,0 +1,624 @@
+/* *
+ * Plugin for resizing axes / panes in a chart.
+ *
+ * (c) 2010-2017 Highsoft AS
+ * Author: Kacper Madej
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import '../parts/Axis.js';
+import '../parts/Pointer.js';
+
+var hasTouch = H.hasTouch,
+    merge = H.merge,
+    wrap = H.wrap,
+    isNumber = H.isNumber,
+    addEvent = H.addEvent,
+    relativeLength = H.relativeLength,
+    objectEach = H.objectEach,
+    Axis = H.Axis,
+    Pointer = H.Pointer,
+
+    // Default options for AxisResizer.
+    resizerOptions = {
+        /**
+         * Minimal size of a resizable axis. Could be set as a percent
+         * of plot area or pixel size.
+         *
+         * This feature requires the `drag-panes.js` module.
+         *
+         * @type      {Number|String}
+         * @product   highstock
+         * @sample    {highstock} stock/yaxis/resize-min-max-length
+         *            minLength and maxLength
+         * @apioption yAxis.minLength
+         */
+        minLength: '10%',
+
+        /**
+         * Maximal size of a resizable axis. Could be set as a percent
+         * of plot area or pixel size.
+         *
+         * This feature requires the `drag-panes.js` module.
+         *
+         * @type      {String|Number}
+         * @product   highstock
+         * @sample    {highstock} stock/yaxis/resize-min-max-length
+         *            minLength and maxLength
+         * @apioption yAxis.maxLength
+         */
+        maxLength: '100%',
+
+        /**
+         * Options for axis resizing. This feature requires the
+         * [drag-panes.js](http://code.highcharts.com/stock/modules/drag-panes.js)
+         * module. It adds a thick line between panes which the user can drag
+         * in order to resize the panes.
+         *
+         * @product highstock
+         * @sample    {highstock} stock/demo/candlestick-and-volume
+         *          Axis resizing enabled
+         * @optionparent yAxis.resize
+         */
+        resize: {
+
+            /**
+             * Contains two arrays of axes that are controlled by control line
+             * of the axis.
+             *
+             * This feature requires the `drag-panes.js` module.
+             */
+            controlledAxis: {
+
+                /**
+                 * Array of axes that should move out of the way of resizing
+                 * being done for the current axis. If not set, the next axis
+                 * will be used.
+                 *
+                 * This feature requires the `drag-panes.js` module.
+                 *
+                 * @type    {Array<String|Number>}
+                 * @default []
+                 * @sample  {highstock} stock/yaxis/multiple-resizers
+                 *          Three panes with resizers
+                 * @sample  {highstock} stock/yaxis/resize-multiple-axes
+                 *          One resizer controlling multiple axes
+                 */
+                next: [],
+
+                /**
+                 * Array of axes that should move with the current axis
+                 * while resizing.
+                 *
+                 * This feature requires the `drag-panes.js` module.
+                 *
+                 * @type    {Array<String|Number>}
+                 * @sample  {highstock} stock/yaxis/multiple-resizers
+                 *          Three panes with resizers
+                 * @sample  {highstock} stock/yaxis/resize-multiple-axes
+                 *          One resizer controlling multiple axes
+                 */
+                prev: []
+            },
+
+            /**
+             * Enable or disable resize by drag for the axis.
+             *
+             * This feature requires the `drag-panes.js` module.
+             *
+             * @sample {highstock} stock/demo/candlestick-and-volume
+             *         Enabled resizer
+             */
+            enabled: false,
+
+            /**
+             * Cursor style for the control line.
+             *
+             * In styled mode use class `highcharts-axis-resizer` instead.
+             *
+             * This feature requires the `drag-panes.js` module.
+             */
+            cursor: 'ns-resize',
+
+            /**
+             * Color of the control line.
+             *
+             * In styled mode use class `highcharts-axis-resizer` instead.
+             *
+             * This feature requires the `drag-panes.js` module.
+             *
+             * @type   {Color}
+             * @sample {highstock} stock/yaxis/styled-resizer Styled resizer
+             */
+            lineColor: '#cccccc',
+
+            /**
+             * Dash style of the control line.
+             *
+             * In styled mode use class `highcharts-axis-resizer` instead.
+             *
+             * This feature requires the `drag-panes.js` module.
+             *
+             * @sample {highstock} stock/yaxis/styled-resizer Styled resizer
+             * @see    For supported options check
+             *         [dashStyle](#plotOptions.series.dashStyle)
+             */
+            lineDashStyle: 'Solid',
+
+            /**
+             * Width of the control line.
+             *
+             * In styled mode use class `highcharts-axis-resizer` instead.
+             *
+             * This feature requires the `drag-panes.js` module.
+             *
+             * @sample {highstock} stock/yaxis/styled-resizer Styled resizer
+             */
+            lineWidth: 4,
+
+            /**
+             * Horizontal offset of the control line.
+             *
+             * This feature requires the `drag-panes.js` module.
+             *
+             * @sample {highstock} stock/yaxis/styled-resizer Styled resizer
+             */
+            x: 0,
+
+            /**
+             * Vertical offset of the control line.
+             *
+             * This feature requires the `drag-panes.js` module.
+             *
+             * @sample {highstock} stock/yaxis/styled-resizer Styled resizer
+             */
+            y: 0
+        }
+    };
+
+merge(true, Axis.prototype.defaultYAxisOptions, resizerOptions);
+
+/**
+ * The AxisResizer class.
+ *
+ * @private
+ * @class
+ * @name Highcharts.AxisResizer
+ *
+ * @param {Highcharts.Axis} axis
+ *        Main axis for the AxisResizer.
+ */
+H.AxisResizer = function (axis) {
+    this.init(axis);
+};
+
+H.AxisResizer.prototype = {
+    /**
+     * Initialize the AxisResizer object.
+     *
+     * @function Highcharts.AxisResizer#init
+     *
+     * @param {Highcharts.Axis} axis
+     *        Main axis for the AxisResizer.
+     */
+    init: function (axis, update) {
+        this.axis = axis;
+        this.options = axis.options.resize;
+        this.render();
+
+        if (!update) {
+            // Add mouse events.
+            this.addMouseEvents();
+        }
+    },
+
+    /**
+     * Render the AxisResizer
+     *
+     * @function Highcharts.AxisResizer#render
+     */
+    render: function () {
+        var resizer = this,
+            axis = resizer.axis,
+            chart = axis.chart,
+            options = resizer.options,
+            x = options.x,
+            y = options.y,
+            // Normalize control line position according to the plot area
+            pos = Math.min(
+                Math.max(
+                    axis.top + axis.height + y,
+                    chart.plotTop
+                ),
+                chart.plotTop + chart.plotHeight
+            ),
+            attr = {},
+            lineWidth;
+
+        if (!chart.styledMode) {
+            attr = {
+                cursor: options.cursor,
+                stroke: options.lineColor,
+                'stroke-width': options.lineWidth,
+                dashstyle: options.lineDashStyle
+            };
+        }
+
+        // Register current position for future reference.
+        resizer.lastPos = pos - y;
+
+        if (!resizer.controlLine) {
+            resizer.controlLine = chart.renderer.path()
+                .addClass('highcharts-axis-resizer');
+        }
+
+        // Add to axisGroup after axis update, because the group is recreated
+        // Do .add() before path is calculated because strokeWidth() needs it.
+        resizer.controlLine.add(axis.axisGroup);
+
+        lineWidth = chart.styledMode ?
+            resizer.controlLine.strokeWidth() :
+            options.lineWidth;
+
+        attr.d = chart.renderer.crispLine(
+            [
+                'M', axis.left + x, pos,
+                'L', axis.left + axis.width + x, pos
+            ],
+            lineWidth
+        );
+
+        resizer.controlLine.attr(attr);
+    },
+
+    /**
+     * Set up the mouse and touch events for the control line.
+     *
+     * @function Highcharts.AxisResizer#addMouseEvents
+     */
+    addMouseEvents: function () {
+        var resizer = this,
+            ctrlLineElem = resizer.controlLine.element,
+            container = resizer.axis.chart.container,
+            eventsToUnbind = [],
+            mouseMoveHandler,
+            mouseUpHandler,
+            mouseDownHandler;
+
+        /**
+         * Create mouse events' handlers.
+         * Make them as separate functions to enable wrapping them:
+         */
+        resizer.mouseMoveHandler = mouseMoveHandler = function (e) {
+            resizer.onMouseMove(e);
+        };
+        resizer.mouseUpHandler = mouseUpHandler = function (e) {
+            resizer.onMouseUp(e);
+        };
+        resizer.mouseDownHandler = mouseDownHandler = function (e) {
+            resizer.onMouseDown(e);
+        };
+
+        /**
+         * Add mouse move and mouseup events. These are bind to doc/container,
+         * because resizer.grabbed flag is stored in mousedown events.
+        */
+        eventsToUnbind.push(
+            addEvent(container, 'mousemove', mouseMoveHandler),
+            addEvent(container.ownerDocument, 'mouseup', mouseUpHandler),
+            addEvent(ctrlLineElem, 'mousedown', mouseDownHandler)
+        );
+
+        // Touch events.
+        if (hasTouch) {
+            eventsToUnbind.push(
+                addEvent(container, 'touchmove', mouseMoveHandler),
+                addEvent(container.ownerDocument, 'touchend', mouseUpHandler),
+                addEvent(ctrlLineElem, 'touchstart', mouseDownHandler)
+            );
+        }
+
+        resizer.eventsToUnbind = eventsToUnbind;
+    },
+
+    /**
+     * Mouse move event based on x/y mouse position.
+     *
+     * @function Highcharts.AxisResizer#onMouseMove
+     *
+     * @param {global.PointerEvent} e
+     *        Mouse event.
+     */
+    onMouseMove: function (e) {
+        /*
+         * In iOS, a mousemove event with e.pageX === 0 is fired when holding
+         * the finger down in the center of the scrollbar. This should
+         * be ignored. Borrowed from Navigator.
+         */
+        if (!e.touches || e.touches[0].pageX !== 0) {
+            // Drag the control line
+            if (this.grabbed) {
+                this.hasDragged = true;
+                this.updateAxes(this.axis.chart.pointer.normalize(e).chartY -
+                    this.options.y);
+            }
+        }
+    },
+
+    /**
+     * Mouse up event based on x/y mouse position.
+     *
+     * @function Highcharts.AxisResizer#onMouseUp
+     *
+     * @param {global.PointerEvent} e
+     *        Mouse event.
+     */
+    onMouseUp: function (e) {
+        if (this.hasDragged) {
+            this.updateAxes(this.axis.chart.pointer.normalize(e).chartY -
+                this.options.y);
+        }
+
+        // Restore runPointActions.
+        this.grabbed = this.hasDragged = this.axis.chart.activeResizer = null;
+    },
+
+    /**
+     * Mousedown on a control line.
+     * Will store necessary information for drag&drop.
+     *
+     * @function Highcharts.AxisResizer#onMouseDown
+     */
+    onMouseDown: function () {
+        // Clear all hover effects.
+        this.axis.chart.pointer.reset(false, 0);
+
+        // Disable runPointActions.
+        this.grabbed = this.axis.chart.activeResizer = true;
+    },
+
+    /**
+     * Update all connected axes after a change of control line position
+     *
+     * @function Highcharts.AxisResizer#updateAxes
+     *
+     * @param {number} chartY
+     */
+    updateAxes: function (chartY) {
+        var resizer = this,
+            chart = resizer.axis.chart,
+            axes = resizer.options.controlledAxis,
+            nextAxes = axes.next.length === 0 ?
+                [chart.yAxis.indexOf(resizer.axis) + 1] : axes.next,
+            // Main axis is included in the prev array by default
+            prevAxes = [resizer.axis].concat(axes.prev),
+            axesConfigs = [], // prev and next configs
+            stopDrag = false,
+            plotTop = chart.plotTop,
+            plotHeight = chart.plotHeight,
+            plotBottom = plotTop + plotHeight,
+            yDelta,
+            calculatePercent = function (value) {
+                return value * 100 / plotHeight + '%';
+            },
+            normalize = function (val, min, max) {
+                return Math.round(Math.min(Math.max(val, min), max));
+            };
+
+        // Normalize chartY to plot area limits
+        chartY = Math.max(Math.min(chartY, plotBottom), plotTop);
+
+        yDelta = chartY - resizer.lastPos;
+
+        // Update on changes of at least 1 pixel in the desired direction
+        if (yDelta * yDelta < 1) {
+            return;
+        }
+
+        // First gather info how axes should behave
+        [prevAxes, nextAxes].forEach(function (axesGroup, isNext) {
+            axesGroup.forEach(function (axisInfo, i) {
+                // Axes given as array index, axis object or axis id
+                var axis = isNumber(axisInfo) ?
+                        // If it's a number - it's an index
+                        chart.yAxis[axisInfo] :
+                        (
+                            // If it's first elem. in first group
+                            (!isNext && !i) ?
+                                // then it's an Axis object
+                                axisInfo :
+                                // else it should be an id
+                                chart.get(axisInfo)
+                        ),
+                    axisOptions = axis && axis.options,
+                    optionsToUpdate = {},
+                    hDelta = 0,
+                    height, top,
+                    minLength, maxLength;
+
+                // Skip if axis is not found
+                // or it is navigator's yAxis (#7732)
+                if (
+                    !axisOptions ||
+                    axisOptions.id === 'navigator-y-axis'
+                ) {
+                    return;
+                }
+
+                top = axis.top;
+
+                minLength = Math.round(
+                    relativeLength(
+                        axisOptions.minLength,
+                        plotHeight
+                    )
+                );
+                maxLength = Math.round(
+                    relativeLength(
+                        axisOptions.maxLength,
+                        plotHeight
+                    )
+                );
+
+                if (isNext) {
+                    // Try to change height first. yDelta could had changed
+                    yDelta = chartY - resizer.lastPos;
+
+                    // Normalize height to option limits
+                    height = normalize(axis.len - yDelta, minLength, maxLength);
+
+                    // Adjust top, so the axis looks like shrinked from top
+                    top = axis.top + yDelta;
+
+                    // Check for plot area limits
+                    if (top + height > plotBottom) {
+                        hDelta = plotBottom - height - top;
+                        chartY += hDelta;
+                        top += hDelta;
+                    }
+
+                    // Fit to plot - when overflowing on top
+                    if (top < plotTop) {
+                        top = plotTop;
+                        if (top + height > plotBottom) {
+                            height = plotHeight;
+                        }
+                    }
+
+                    // If next axis meets min length, stop dragging:
+                    if (height === minLength) {
+                        stopDrag = true;
+                    }
+
+                    axesConfigs.push({
+                        axis: axis,
+                        options: {
+                            top: calculatePercent(top - plotTop),
+                            height: calculatePercent(height)
+                        }
+                    });
+                } else {
+                    // Normalize height to option limits
+                    height = normalize(chartY - top, minLength, maxLength);
+
+                    // If prev axis meets max length, stop dragging:
+                    if (height === maxLength) {
+                        stopDrag = true;
+                    }
+
+                    // Check axis size limits
+                    chartY = top + height;
+                    axesConfigs.push({
+                        axis: axis,
+                        options: {
+                            height: calculatePercent(height)
+                        }
+                    });
+                }
+
+                optionsToUpdate.height = height;
+            });
+        });
+
+        // If we hit the min/maxLength with dragging, don't do anything:
+        if (!stopDrag) {
+            // Now update axes:
+            axesConfigs.forEach(function (config) {
+                config.axis.update(config.options, false);
+            });
+
+            chart.redraw(false);
+        }
+    },
+
+    /**
+     * Destroy AxisResizer. Clear outside references, clear events,
+     * destroy elements, nullify properties.
+     *
+     * @function Highcharts.AxisResizer#destroy
+     */
+    destroy: function () {
+        var resizer = this,
+            axis = resizer.axis;
+
+        // Clear resizer in axis
+        delete axis.resizer;
+
+        // Clear control line events
+        if (this.eventsToUnbind) {
+            this.eventsToUnbind.forEach(function (unbind) {
+                unbind();
+            });
+        }
+
+        // Destroy AxisResizer elements
+        resizer.controlLine.destroy();
+
+        // Nullify properties
+        objectEach(resizer, function (val, key) {
+            resizer[key] = null;
+        });
+    }
+};
+
+// Keep resizer reference on axis update
+Axis.prototype.keepProps.push('resizer');
+
+// Add new AxisResizer, update or remove it
+addEvent(Axis, 'afterRender', function () {
+    var axis = this,
+        resizer = axis.resizer,
+        resizerOptions = axis.options.resize,
+        enabled;
+
+    if (resizerOptions) {
+        enabled = resizerOptions.enabled !== false;
+
+        if (resizer) {
+            // Resizer present and enabled
+            if (enabled) {
+                // Update options
+                resizer.init(axis, true);
+
+            // Resizer present, but disabled
+            } else {
+                // Destroy the resizer
+                resizer.destroy();
+            }
+        } else {
+            // Resizer not present and enabled
+            if (enabled) {
+                // Add new resizer
+                axis.resizer = new H.AxisResizer(axis);
+            }
+            // Resizer not present and disabled, so do nothing
+        }
+    }
+});
+
+// Clear resizer on axis remove.
+addEvent(Axis, 'destroy', function (e) {
+    if (!e.keepEvents && this.resizer) {
+        this.resizer.destroy();
+    }
+});
+
+// Prevent any hover effects while dragging a control line of AxisResizer.
+wrap(Pointer.prototype, 'runPointActions', function (proceed) {
+    if (!this.chart.activeResizer) {
+        proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+    }
+});
+
+// Prevent default drag action detection while dragging a control line of
+// AxisResizer. (#7563)
+wrap(Pointer.prototype, 'drag', function (proceed) {
+    if (!this.chart.activeResizer) {
+        proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+    }
+});