ps-toolkit-ui 0.0.207 → 0.0.211

package/src/assets/plugins/highcharts/code/es-modules/Core/Scrollbar.js

@@ -0,0 +1,658 @@
+/* *
+ *
+ *  (c) 2010-2021 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import D from './DefaultOptions.js';
+var defaultOptions = D.defaultOptions;
+import H from './Globals.js';
+import ScrollbarAxis from './Axis/ScrollbarAxis.js';
+import ScrollbarDefaults from './ScrollbarDefaults.js';
+import U from './Utilities.js';
+var addEvent = U.addEvent, correctFloat = U.correctFloat, defined = U.defined, destroyObjectProperties = U.destroyObjectProperties, fireEvent = U.fireEvent, merge = U.merge, pick = U.pick, removeEvent = U.removeEvent;
+/* *
+ *
+ *  Constants
+ *
+ * */
+/* eslint-disable no-invalid-this, valid-jsdoc */
+/**
+ * A reusable scrollbar, internally used in Highcharts Stock's
+ * navigator and optionally on individual axes.
+ *
+ * @private
+ * @class
+ * @name Highcharts.Scrollbar
+ * @param {Highcharts.SVGRenderer} renderer
+ * @param {Highcharts.ScrollbarOptions} options
+ * @param {Highcharts.Chart} chart
+ */
+var Scrollbar = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function Scrollbar(renderer, options, chart) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        this._events = [];
+        this.chart = void 0;
+        this.chartX = 0;
+        this.chartY = 0;
+        this.from = 0;
+        this.group = void 0;
+        this.options = void 0;
+        this.renderer = void 0;
+        this.scrollbar = void 0;
+        this.scrollbarButtons = [];
+        this.scrollbarGroup = void 0;
+        this.scrollbarLeft = 0;
+        this.scrollbarRifles = void 0;
+        this.scrollbarStrokeWidth = 1;
+        this.scrollbarTop = 0;
+        this.size = 0;
+        this.to = 0;
+        this.track = void 0;
+        this.trackBorderWidth = 1;
+        this.userOptions = void 0;
+        this.x = 0;
+        this.y = 0;
+        this.init(renderer, options, chart);
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    Scrollbar.compose = function (AxisClass) {
+        ScrollbarAxis.compose(AxisClass, Scrollbar);
+    };
+    /**
+     * When we have vertical scrollbar, rifles and arrow in buttons should be
+     * rotated. The same method is used in Navigator's handles, to rotate them.
+     *
+     * @function Highcharts.swapXY
+     *
+     * @param {Highcharts.SVGPathArray} path
+     * Path to be rotated.
+     *
+     * @param {boolean} [vertical]
+     * If vertical scrollbar, swap x-y values.
+     *
+     * @return {Highcharts.SVGPathArray}
+     * Rotated path.
+     *
+     * @requires modules/stock
+     */
+    Scrollbar.swapXY = function (path, vertical) {
+        if (vertical) {
+            path.forEach(function (seg) {
+                var len = seg.length;
+                var temp;
+                for (var i = 0; i < len; i += 2) {
+                    temp = seg[i + 1];
+                    if (typeof temp === 'number') {
+                        seg[i + 1] = seg[i + 2];
+                        seg[i + 2] = temp;
+                    }
+                }
+            });
+        }
+        return path;
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Set up the mouse and touch events for the Scrollbar
+     *
+     * @private
+     * @function Highcharts.Scrollbar#addEvents
+     */
+    Scrollbar.prototype.addEvents = function () {
+        var buttonsOrder = this.options.inverted ? [1, 0] : [0, 1], buttons = this.scrollbarButtons, bar = this.scrollbarGroup.element, track = this.track.element, mouseDownHandler = this.mouseDownHandler.bind(this), mouseMoveHandler = this.mouseMoveHandler.bind(this), mouseUpHandler = this.mouseUpHandler.bind(this);
+        // Mouse events
+        var _events = [
+            [
+                buttons[buttonsOrder[0]].element,
+                'click',
+                this.buttonToMinClick.bind(this)
+            ],
+            [
+                buttons[buttonsOrder[1]].element,
+                'click',
+                this.buttonToMaxClick.bind(this)
+            ],
+            [track, 'click', this.trackClick.bind(this)],
+            [bar, 'mousedown', mouseDownHandler],
+            [bar.ownerDocument, 'mousemove', mouseMoveHandler],
+            [bar.ownerDocument, 'mouseup', mouseUpHandler]
+        ];
+        // Touch events
+        if (H.hasTouch) {
+            _events.push([bar, 'touchstart', mouseDownHandler], [bar.ownerDocument, 'touchmove', mouseMoveHandler], [bar.ownerDocument, 'touchend', mouseUpHandler]);
+        }
+        // Add them all
+        _events.forEach(function (args) {
+            addEvent.apply(null, args);
+        });
+        this._events = _events;
+    };
+    Scrollbar.prototype.buttonToMaxClick = function (e) {
+        var scroller = this;
+        var range = ((scroller.to - scroller.from) *
+            pick(scroller.options.step, 0.2));
+        scroller.updatePosition(scroller.from + range, scroller.to + range);
+        fireEvent(scroller, 'changed', {
+            from: scroller.from,
+            to: scroller.to,
+            trigger: 'scrollbar',
+            DOMEvent: e
+        });
+    };
+    Scrollbar.prototype.buttonToMinClick = function (e) {
+        var scroller = this;
+        var range = correctFloat(scroller.to - scroller.from) *
+            pick(scroller.options.step, 0.2);
+        scroller.updatePosition(correctFloat(scroller.from - range), correctFloat(scroller.to - range));
+        fireEvent(scroller, 'changed', {
+            from: scroller.from,
+            to: scroller.to,
+            trigger: 'scrollbar',
+            DOMEvent: e
+        });
+    };
+    /**
+     * Get normalized (0-1) cursor position over the scrollbar
+     *
+     * @private
+     * @function Highcharts.Scrollbar#cursorToScrollbarPosition
+     *
+     * @param  {*} normalizedEvent
+     *         normalized event, with chartX and chartY values
+     *
+     * @return {Highcharts.Dictionary<number>}
+     *         Local position {chartX, chartY}
+     */
+    Scrollbar.prototype.cursorToScrollbarPosition = function (normalizedEvent) {
+        var scroller = this, options = scroller.options, minWidthDifference = options.minWidth > scroller.calculatedWidth ?
+            options.minWidth :
+            0; // minWidth distorts translation
+        return {
+            chartX: (normalizedEvent.chartX - scroller.x -
+                scroller.xOffset) /
+                (scroller.barWidth - minWidthDifference),
+            chartY: (normalizedEvent.chartY - scroller.y -
+                scroller.yOffset) /
+                (scroller.barWidth - minWidthDifference)
+        };
+    };
+    /**
+     * Destroys allocated elements.
+     *
+     * @private
+     * @function Highcharts.Scrollbar#destroy
+     */
+    Scrollbar.prototype.destroy = function () {
+        var scroller = this, navigator = scroller.chart.scroller;
+        // Disconnect events added in addEvents
+        scroller.removeEvents();
+        // Destroy properties
+        [
+            'track',
+            'scrollbarRifles',
+            'scrollbar',
+            'scrollbarGroup',
+            'group'
+        ].forEach(function (prop) {
+            if (scroller[prop] && scroller[prop].destroy) {
+                scroller[prop] = scroller[prop].destroy();
+            }
+        });
+        // #6421, chart may have more scrollbars
+        if (navigator && scroller === navigator.scrollbar) {
+            navigator.scrollbar = null;
+            // Destroy elements in collection
+            destroyObjectProperties(navigator.scrollbarButtons);
+        }
+    };
+    /**
+     * Draw the scrollbar buttons with arrows
+     *
+     * @private
+     * @function Highcharts.Scrollbar#drawScrollbarButton
+     * @param {number} index
+     *        0 is left, 1 is right
+     */
+    Scrollbar.prototype.drawScrollbarButton = function (index) {
+        var scroller = this, renderer = scroller.renderer, scrollbarButtons = scroller.scrollbarButtons, options = scroller.options, size = scroller.size, group = renderer.g().add(scroller.group);
+        var tempElem;
+        scrollbarButtons.push(group);
+        // Create a rectangle for the scrollbar button
+        tempElem = renderer.rect()
+            .addClass('highcharts-scrollbar-button')
+            .add(group);
+        // Presentational attributes
+        if (!scroller.chart.styledMode) {
+            tempElem.attr({
+                stroke: options.buttonBorderColor,
+                'stroke-width': options.buttonBorderWidth,
+                fill: options.buttonBackgroundColor
+            });
+        }
+        // Place the rectangle based on the rendered stroke width
+        tempElem.attr(tempElem.crisp({
+            x: -0.5,
+            y: -0.5,
+            width: size + 1,
+            height: size + 1,
+            r: options.buttonBorderRadius
+        }, tempElem.strokeWidth()));
+        // Button arrow
+        tempElem = renderer
+            .path(Scrollbar.swapXY([[
+                'M',
+                size / 2 + (index ? -1 : 1),
+                size / 2 - 3
+            ], [
+                'L',
+                size / 2 + (index ? -1 : 1),
+                size / 2 + 3
+            ], [
+                'L',
+                size / 2 + (index ? 2 : -2),
+                size / 2
+            ]], options.vertical))
+            .addClass('highcharts-scrollbar-arrow')
+            .add(scrollbarButtons[index]);
+        if (!scroller.chart.styledMode) {
+            tempElem.attr({
+                fill: options.buttonArrowColor
+            });
+        }
+    };
+    /**
+     * @private
+     * @function Highcharts.Scrollbar#init
+     * @param {Highcharts.SVGRenderer} renderer
+     * @param {Highcharts.ScrollbarOptions} options
+     * @param {Highcharts.Chart} chart
+     */
+    Scrollbar.prototype.init = function (renderer, options, chart) {
+        var scroller = this;
+        scroller.scrollbarButtons = [];
+        scroller.renderer = renderer;
+        scroller.userOptions = options;
+        scroller.options = merge(ScrollbarDefaults, defaultOptions.scrollbar, options);
+        scroller.chart = chart;
+        // backward compatibility
+        scroller.size = pick(scroller.options.size, scroller.options.height);
+        // Init
+        if (options.enabled) {
+            scroller.render();
+            scroller.addEvents();
+        }
+    };
+    Scrollbar.prototype.mouseDownHandler = function (e) {
+        var scroller = this, normalizedEvent = scroller.chart.pointer.normalize(e), mousePosition = scroller.cursorToScrollbarPosition(normalizedEvent);
+        scroller.chartX = mousePosition.chartX;
+        scroller.chartY = mousePosition.chartY;
+        scroller.initPositions = [scroller.from, scroller.to];
+        scroller.grabbedCenter = true;
+    };
+    /**
+     * Event handler for the mouse move event.
+     * @private
+     */
+    Scrollbar.prototype.mouseMoveHandler = function (e) {
+        var scroller = this, normalizedEvent = scroller.chart.pointer.normalize(e), options = scroller.options, direction = options.vertical ?
+            'chartY' : 'chartX', initPositions = scroller.initPositions || [];
+        var scrollPosition, chartPosition, change;
+        // 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.
+        if (scroller.grabbedCenter &&
+            // #4696, scrollbar failed on Android
+            (!e.touches || e.touches[0][direction] !== 0)) {
+            chartPosition = scroller.cursorToScrollbarPosition(normalizedEvent)[direction];
+            scrollPosition = scroller[direction];
+            change = chartPosition - scrollPosition;
+            scroller.hasDragged = true;
+            scroller.updatePosition(initPositions[0] + change, initPositions[1] + change);
+            if (scroller.hasDragged) {
+                fireEvent(scroller, 'changed', {
+                    from: scroller.from,
+                    to: scroller.to,
+                    trigger: 'scrollbar',
+                    DOMType: e.type,
+                    DOMEvent: e
+                });
+            }
+        }
+    };
+    /**
+     * Event handler for the mouse up event.
+     * @private
+     */
+    Scrollbar.prototype.mouseUpHandler = function (e) {
+        var scroller = this;
+        if (scroller.hasDragged) {
+            fireEvent(scroller, 'changed', {
+                from: scroller.from,
+                to: scroller.to,
+                trigger: 'scrollbar',
+                DOMType: e.type,
+                DOMEvent: e
+            });
+        }
+        scroller.grabbedCenter =
+            scroller.hasDragged =
+                scroller.chartX =
+                    scroller.chartY = null;
+    };
+    /**
+     * Position the scrollbar, method called from a parent with defined
+     * dimensions.
+     *
+     * @private
+     * @function Highcharts.Scrollbar#position
+     * @param {number} x
+     *        x-position on the chart
+     * @param {number} y
+     *        y-position on the chart
+     * @param {number} width
+     *        width of the scrollbar
+     * @param {number} height
+     *        height of the scorllbar
+     */
+    Scrollbar.prototype.position = function (x, y, width, height) {
+        var scroller = this, options = scroller.options, vertical = options.vertical, method = scroller.rendered ? 'animate' : 'attr';
+        var xOffset = height, yOffset = 0;
+        scroller.x = x;
+        scroller.y = y + this.trackBorderWidth;
+        scroller.width = width; // width with buttons
+        scroller.height = height;
+        scroller.xOffset = xOffset;
+        scroller.yOffset = yOffset;
+        // If Scrollbar is a vertical type, swap options:
+        if (vertical) {
+            scroller.width = scroller.yOffset = width = yOffset = scroller.size;
+            scroller.xOffset = xOffset = 0;
+            scroller.barWidth = height - width * 2; // width without buttons
+            scroller.x = x = x + scroller.options.margin;
+        }
+        else {
+            scroller.height = scroller.xOffset = height = xOffset =
+                scroller.size;
+            scroller.barWidth = width - height * 2; // width without buttons
+            scroller.y = scroller.y + scroller.options.margin;
+        }
+        // Set general position for a group:
+        scroller.group[method]({
+            translateX: x,
+            translateY: scroller.y
+        });
+        // Resize background/track:
+        scroller.track[method]({
+            width: width,
+            height: height
+        });
+        // Move right/bottom button ot it's place:
+        scroller.scrollbarButtons[1][method]({
+            translateX: vertical ? 0 : width - xOffset,
+            translateY: vertical ? height - yOffset : 0
+        });
+    };
+    /**
+     * Removes the event handlers attached previously with addEvents.
+     *
+     * @private
+     * @function Highcharts.Scrollbar#removeEvents
+     */
+    Scrollbar.prototype.removeEvents = function () {
+        this._events.forEach(function (args) {
+            removeEvent.apply(null, args);
+        });
+        this._events.length = 0;
+    };
+    /**
+     * Render scrollbar with all required items.
+     *
+     * @private
+     * @function Highcharts.Scrollbar#render
+     */
+    Scrollbar.prototype.render = function () {
+        var scroller = this, renderer = scroller.renderer, options = scroller.options, size = scroller.size, styledMode = scroller.chart.styledMode, group = renderer.g('scrollbar').attr({
+            zIndex: options.zIndex,
+            translateY: -99999
+        }).add();
+        // Draw the scrollbar group
+        scroller.group = group;
+        // Draw the scrollbar track:
+        scroller.track = renderer.rect()
+            .addClass('highcharts-scrollbar-track')
+            .attr({
+            x: 0,
+            r: options.trackBorderRadius || 0,
+            height: size,
+            width: size
+        }).add(group);
+        if (!styledMode) {
+            scroller.track.attr({
+                fill: options.trackBackgroundColor,
+                stroke: options.trackBorderColor,
+                'stroke-width': options.trackBorderWidth
+            });
+        }
+        scroller.trackBorderWidth = scroller.track.strokeWidth();
+        scroller.track.attr({
+            y: -this.trackBorderWidth % 2 / 2
+        });
+        // Draw the scrollbar itself
+        scroller.scrollbarGroup = renderer.g().add(group);
+        scroller.scrollbar = renderer.rect()
+            .addClass('highcharts-scrollbar-thumb')
+            .attr({
+            height: size,
+            width: size,
+            r: options.barBorderRadius || 0
+        }).add(scroller.scrollbarGroup);
+        scroller.scrollbarRifles = renderer
+            .path(Scrollbar.swapXY([
+            ['M', -3, size / 4],
+            ['L', -3, 2 * size / 3],
+            ['M', 0, size / 4],
+            ['L', 0, 2 * size / 3],
+            ['M', 3, size / 4],
+            ['L', 3, 2 * size / 3]
+        ], options.vertical))
+            .addClass('highcharts-scrollbar-rifles')
+            .add(scroller.scrollbarGroup);
+        if (!styledMode) {
+            scroller.scrollbar.attr({
+                fill: options.barBackgroundColor,
+                stroke: options.barBorderColor,
+                'stroke-width': options.barBorderWidth
+            });
+            scroller.scrollbarRifles.attr({
+                stroke: options.rifleColor,
+                'stroke-width': 1
+            });
+        }
+        scroller.scrollbarStrokeWidth = scroller.scrollbar.strokeWidth();
+        scroller.scrollbarGroup.translate(-scroller.scrollbarStrokeWidth % 2 / 2, -scroller.scrollbarStrokeWidth % 2 / 2);
+        // Draw the buttons:
+        scroller.drawScrollbarButton(0);
+        scroller.drawScrollbarButton(1);
+    };
+    /**
+     * Set scrollbar size, with a given scale.
+     *
+     * @private
+     * @function Highcharts.Scrollbar#setRange
+     * @param {number} from
+     *        scale (0-1) where bar should start
+     * @param {number} to
+     *        scale (0-1) where bar should end
+     */
+    Scrollbar.prototype.setRange = function (from, to) {
+        var scroller = this, options = scroller.options, vertical = options.vertical, minWidth = options.minWidth, fullWidth = scroller.barWidth, method = (this.rendered &&
+            !this.hasDragged &&
+            !(this.chart.navigator && this.chart.navigator.hasDragged)) ? 'animate' : 'attr';
+        if (!defined(fullWidth)) {
+            return;
+        }
+        var toPX = fullWidth * Math.min(to, 1);
+        var fromPX, newSize;
+        from = Math.max(from, 0);
+        fromPX = Math.ceil(fullWidth * from);
+        scroller.calculatedWidth = newSize = correctFloat(toPX - fromPX);
+        // We need to recalculate position, if minWidth is used
+        if (newSize < minWidth) {
+            fromPX = (fullWidth - minWidth + newSize) * from;
+            newSize = minWidth;
+        }
+        var newPos = Math.floor(fromPX + scroller.xOffset + scroller.yOffset);
+        var newRiflesPos = newSize / 2 - 0.5; // -0.5 -> rifle line width / 2
+        // Store current position:
+        scroller.from = from;
+        scroller.to = to;
+        if (!vertical) {
+            scroller.scrollbarGroup[method]({
+                translateX: newPos
+            });
+            scroller.scrollbar[method]({
+                width: newSize
+            });
+            scroller.scrollbarRifles[method]({
+                translateX: newRiflesPos
+            });
+            scroller.scrollbarLeft = newPos;
+            scroller.scrollbarTop = 0;
+        }
+        else {
+            scroller.scrollbarGroup[method]({
+                translateY: newPos
+            });
+            scroller.scrollbar[method]({
+                height: newSize
+            });
+            scroller.scrollbarRifles[method]({
+                translateY: newRiflesPos
+            });
+            scroller.scrollbarTop = newPos;
+            scroller.scrollbarLeft = 0;
+        }
+        if (newSize <= 12) {
+            scroller.scrollbarRifles.hide();
+        }
+        else {
+            scroller.scrollbarRifles.show(true);
+        }
+        // Show or hide the scrollbar based on the showFull setting
+        if (options.showFull === false) {
+            if (from <= 0 && to >= 1) {
+                scroller.group.hide();
+            }
+            else {
+                scroller.group.show();
+            }
+        }
+        scroller.rendered = true;
+    };
+    /**
+     * Checks if the extremes should be updated in response to a scrollbar
+     * change event.
+     *
+     * @private
+     * @function Highcharts.Scrollbar#shouldUpdateExtremes
+     */
+    Scrollbar.prototype.shouldUpdateExtremes = function (eventType) {
+        return (pick(this.options.liveRedraw, H.svg && !H.isTouchDevice && !this.chart.isBoosting) ||
+            // Mouseup always should change extremes
+            eventType === 'mouseup' ||
+            eventType === 'touchend' ||
+            // Internal events
+            !defined(eventType));
+    };
+    Scrollbar.prototype.trackClick = function (e) {
+        var scroller = this;
+        var normalizedEvent = scroller.chart.pointer.normalize(e), range = scroller.to - scroller.from, top = scroller.y + scroller.scrollbarTop, left = scroller.x + scroller.scrollbarLeft;
+        if ((scroller.options.vertical && normalizedEvent.chartY > top) ||
+            (!scroller.options.vertical && normalizedEvent.chartX > left)) {
+            // On the top or on the left side of the track:
+            scroller.updatePosition(scroller.from + range, scroller.to + range);
+        }
+        else {
+            // On the bottom or the right side of the track:
+            scroller.updatePosition(scroller.from - range, scroller.to - range);
+        }
+        fireEvent(scroller, 'changed', {
+            from: scroller.from,
+            to: scroller.to,
+            trigger: 'scrollbar',
+            DOMEvent: e
+        });
+    };
+    /**
+     * Update the scrollbar with new options
+     *
+     * @private
+     * @function Highcharts.Scrollbar#update
+     * @param  {Highcharts.ScrollbarOptions} options
+     */
+    Scrollbar.prototype.update = function (options) {
+        this.destroy();
+        this.init(this.chart.renderer, merge(true, this.options, options), this.chart);
+    };
+    /**
+     * Update position option in the Scrollbar, with normalized 0-1 scale
+     *
+     * @private
+     * @function Highcharts.Scrollbar#updatePosition
+     * @param  {number} from
+     * @param  {number} to
+     */
+    Scrollbar.prototype.updatePosition = function (from, to) {
+        if (to > 1) {
+            from = correctFloat(1 - correctFloat(to - from));
+            to = 1;
+        }
+        if (from < 0) {
+            to = correctFloat(to - from);
+            from = 0;
+        }
+        this.from = from;
+        this.to = to;
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    Scrollbar.defaultOptions = ScrollbarDefaults;
+    return Scrollbar;
+}());
+/* *
+ *
+ *  Registry
+ *
+ * */
+defaultOptions.scrollbar = merge(true, Scrollbar.defaultOptions, defaultOptions.scrollbar);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default Scrollbar;