ps-toolkit-ui 0.0.207 → 0.0.211

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Boost/BoostOverrides.js

@@ -0,0 +1,386 @@
+/* *
+ *
+ *  Copyright (c) 2019-2021 Highsoft AS
+ *
+ *  Boost module: stripped-down renderer for higher performance
+ *
+ *  License: highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import Chart from '../../Core/Chart/Chart.js';
+import D from '../../Core/DefaultOptions.js';
+var getOptions = D.getOptions;
+import Point from '../../Core/Series/Point.js';
+import Series from '../../Core/Series/Series.js';
+import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
+var seriesTypes = SeriesRegistry.seriesTypes;
+import U from '../../Core/Utilities.js';
+var addEvent = U.addEvent, error = U.error, isArray = U.isArray, isNumber = U.isNumber, pick = U.pick, wrap = U.wrap;
+import '../../Core/DefaultOptions.js';
+import butils from './BoostUtils.js';
+import boostable from './Boostables.js';
+import boostableMap from './BoostableMap.js';
+var boostEnabled = butils.boostEnabled, shouldForceChartSeriesBoosting = butils.shouldForceChartSeriesBoosting, plotOptions = getOptions().plotOptions;
+/**
+ * Returns true if the chart is in series boost mode.
+ *
+ * @function Highcharts.Chart#isChartSeriesBoosting
+ *
+ * @param {Highcharts.Chart} chart
+ *        the chart to check
+ *
+ * @return {boolean}
+ *         true if the chart is in series boost mode
+ */
+Chart.prototype.isChartSeriesBoosting = function () {
+    var isSeriesBoosting, threshold = pick(this.options.boost && this.options.boost.seriesThreshold, 50);
+    isSeriesBoosting = threshold <= this.series.length ||
+        shouldForceChartSeriesBoosting(this);
+    return isSeriesBoosting;
+};
+/* eslint-disable valid-jsdoc */
+/**
+ * Get the clip rectangle for a target, either a series or the chart. For the
+ * chart, we need to consider the maximum extent of its Y axes, in case of
+ * Highcharts Stock panes and navigator.
+ *
+ * @private
+ * @function Highcharts.Chart#getBoostClipRect
+ */
+Chart.prototype.getBoostClipRect = function (target) {
+    var clipBox = {
+        x: this.plotLeft,
+        y: this.plotTop,
+        width: this.plotWidth,
+        height: this.plotHeight
+    };
+    if (target === this) {
+        var verticalAxes = this.inverted ? this.xAxis : this.yAxis; // #14444
+        if (verticalAxes.length <= 1) {
+            clipBox.y = Math.min(verticalAxes[0].pos, clipBox.y);
+            clipBox.height = (verticalAxes[0].pos -
+                this.plotTop +
+                verticalAxes[0].len);
+        }
+        else {
+            clipBox.height = this.plotHeight;
+        }
+    }
+    return clipBox;
+};
+/**
+ * Return a full Point object based on the index.
+ * The boost module uses stripped point objects for performance reasons.
+ *
+ * @function Highcharts.Series#getPoint
+ *
+ * @param {object|Highcharts.Point} boostPoint
+ *        A stripped-down point object
+ *
+ * @return {Highcharts.Point}
+ *         A Point object as per https://api.highcharts.com/highcharts#Point
+ */
+Series.prototype.getPoint = function (boostPoint) {
+    var point = boostPoint, xData = (this.xData || this.options.xData || this.processedXData ||
+        false);
+    if (boostPoint && !(boostPoint instanceof this.pointClass)) {
+        point = (new this.pointClass()).init(// eslint-disable-line new-cap
+        this, this.options.data[boostPoint.i], xData ? xData[boostPoint.i] : void 0);
+        point.category = pick(this.xAxis.categories ?
+            this.xAxis.categories[point.x] :
+            point.x, // @todo simplify
+        point.x);
+        point.dist = boostPoint.dist;
+        point.distX = boostPoint.distX;
+        point.plotX = boostPoint.plotX;
+        point.plotY = boostPoint.plotY;
+        point.index = boostPoint.i;
+        point.isInside = this.isPointInside(boostPoint);
+    }
+    return point;
+};
+/* eslint-disable no-invalid-this */
+// Return a point instance from the k-d-tree
+wrap(Series.prototype, 'searchPoint', function (proceed) {
+    return this.getPoint(proceed.apply(this, [].slice.call(arguments, 1)));
+});
+// For inverted series, we need to swap X-Y values before running base methods
+wrap(Point.prototype, 'haloPath', function (proceed) {
+    var halo, point = this, series = point.series, chart = series.chart, plotX = point.plotX, plotY = point.plotY, inverted = chart.inverted;
+    if (series.isSeriesBoosting && inverted) {
+        point.plotX = series.yAxis.len - plotY;
+        point.plotY = series.xAxis.len - plotX;
+    }
+    halo = proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+    if (series.isSeriesBoosting && inverted) {
+        point.plotX = plotX;
+        point.plotY = plotY;
+    }
+    return halo;
+});
+wrap(Series.prototype, 'markerAttribs', function (proceed, point) {
+    var attribs, series = this, chart = series.chart, plotX = point.plotX, plotY = point.plotY, inverted = chart.inverted;
+    if (series.isSeriesBoosting && inverted) {
+        point.plotX = series.yAxis.len - plotY;
+        point.plotY = series.xAxis.len - plotX;
+    }
+    attribs = proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+    if (series.isSeriesBoosting && inverted) {
+        point.plotX = plotX;
+        point.plotY = plotY;
+    }
+    return attribs;
+});
+/*
+ * Extend series.destroy to also remove the fake k-d-tree points (#5137).
+ * Normally this is handled by Series.destroy that calls Point.destroy,
+ * but the fake search points are not registered like that.
+ */
+addEvent(Series, 'destroy', function () {
+    var series = this, chart = series.chart;
+    if (chart.markerGroup === series.markerGroup) {
+        series.markerGroup = null;
+    }
+    if (chart.hoverPoints) {
+        chart.hoverPoints = chart.hoverPoints.filter(function (point) {
+            return point.series === series;
+        });
+    }
+    if (chart.hoverPoint && chart.hoverPoint.series === series) {
+        chart.hoverPoint = null;
+    }
+});
+/*
+ * Do not compute extremes when min and max are set.
+ * If we use this in the core, we can add the hook
+ * to hasExtremes to the methods directly.
+ */
+wrap(Series.prototype, 'getExtremes', function (proceed) {
+    if (!this.isSeriesBoosting || (!this.hasExtremes || !this.hasExtremes())) {
+        return proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+    }
+    return {};
+});
+/*
+ * Override a bunch of methods the same way. If the number of points is
+ * below the threshold, run the original method. If not, check for a
+ * canvas version or do nothing.
+ *
+ * Note that we're not overriding any of these for heatmaps.
+ */
+[
+    'translate',
+    'generatePoints',
+    'drawTracker',
+    'drawPoints',
+    'render'
+].forEach(function (method) {
+    /**
+     * @private
+     */
+    function branch(proceed) {
+        var letItPass = this.options.stacking &&
+            (method === 'translate' || method === 'generatePoints');
+        if (!this.isSeriesBoosting ||
+            letItPass ||
+            !boostEnabled(this.chart) ||
+            this.type === 'heatmap' ||
+            this.type === 'treemap' ||
+            !boostableMap[this.type] ||
+            this.options.boostThreshold === 0) {
+            proceed.call(this);
+            // If a canvas version of the method exists, like renderCanvas(), run
+        }
+        else if (this[method + 'Canvas']) {
+            this[method + 'Canvas']();
+        }
+    }
+    wrap(Series.prototype, method, branch);
+    // A special case for some types - their translate method is already wrapped
+    if (method === 'translate') {
+        [
+            'column',
+            'bar',
+            'arearange',
+            'columnrange',
+            'heatmap',
+            'treemap'
+        ].forEach(function (type) {
+            if (seriesTypes[type]) {
+                wrap(seriesTypes[type].prototype, method, branch);
+            }
+        });
+    }
+});
+// If the series is a heatmap or treemap, or if the series is not boosting
+// do the default behaviour. Otherwise, process if the series has no extremes.
+wrap(Series.prototype, 'processData', function (proceed) {
+    var series = this;
+    var dataToMeasure = this.options.data;
+    /**
+     * Used twice in this function, first on this.options.data, the second
+     * time it runs the check again after processedXData is built.
+     * If the data is going to be grouped, the series shouldn't be boosted.
+     * @private
+     */
+    function getSeriesBoosting(data) {
+        // Check if will be grouped.
+        if (series.forceCrop) {
+            return false;
+        }
+        return series.chart.isChartSeriesBoosting() || ((data ? data.length : 0) >=
+            (series.options.boostThreshold || Number.MAX_VALUE));
+    }
+    if (boostEnabled(this.chart) && boostableMap[this.type]) {
+        // If there are no extremes given in the options, we also need to
+        // process the data to read the data extremes. If this is a heatmap, do
+        // default behaviour.
+        if (!getSeriesBoosting(dataToMeasure) || // First pass with options.data
+            this.type === 'heatmap' ||
+            this.type === 'treemap' ||
+            this.options.stacking || // processedYData for the stack (#7481)
+            !this.hasExtremes ||
+            !this.hasExtremes(true)) {
+            proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+            dataToMeasure = this.processedXData;
+        }
+        // Set the isBoosting flag, second pass with processedXData to see if we
+        // have zoomed.
+        this.isSeriesBoosting = getSeriesBoosting(dataToMeasure);
+        // Enter or exit boost mode
+        if (this.isSeriesBoosting) {
+            // Force turbo-mode:
+            var firstPoint = void 0;
+            if (this.options.data && this.options.data.length) {
+                firstPoint = this.getFirstValidPoint(this.options.data);
+                if (!isNumber(firstPoint) && !isArray(firstPoint)) {
+                    error(12, false, this.chart);
+                }
+            }
+            this.enterBoost();
+        }
+        else if (this.exitBoost) {
+            this.exitBoost();
+        }
+        // The series type is not boostable
+    }
+    else {
+        proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+    }
+});
+addEvent(Series, 'hide', function () {
+    if (this.canvas && this.renderTarget) {
+        if (this.ogl) {
+            this.ogl.clear();
+        }
+        this.boostClear();
+    }
+});
+/**
+ * Enter boost mode and apply boost-specific properties.
+ *
+ * @function Highcharts.Series#enterBoost
+ */
+Series.prototype.enterBoost = function () {
+    this.alteredByBoost = [];
+    // Save the original values, including whether it was an own property or
+    // inherited from the prototype.
+    ['allowDG', 'directTouch', 'stickyTracking'].forEach(function (prop) {
+        this.alteredByBoost.push({
+            prop: prop,
+            val: this[prop],
+            own: Object.hasOwnProperty.call(this, prop)
+        });
+    }, this);
+    this.allowDG = false;
+    this.directTouch = false;
+    this.stickyTracking = true;
+    // Prevent animation when zooming in on boosted series(#13421).
+    this.finishedAnimating = true;
+    // Hide series label if any
+    if (this.labelBySeries) {
+        this.labelBySeries = this.labelBySeries.destroy();
+    }
+};
+/**
+ * Exit from boost mode and restore non-boost properties.
+ *
+ * @function Highcharts.Series#exitBoost
+ */
+Series.prototype.exitBoost = function () {
+    // Reset instance properties and/or delete instance properties and go back
+    // to prototype
+    (this.alteredByBoost || []).forEach(function (setting) {
+        if (setting.own) {
+            this[setting.prop] = setting.val;
+        }
+        else {
+            // Revert to prototype
+            delete this[setting.prop];
+        }
+    }, this);
+    // Clear previous run
+    if (this.boostClear) {
+        this.boostClear();
+    }
+};
+/**
+ * @private
+ * @function Highcharts.Series#hasExtremes
+ */
+Series.prototype.hasExtremes = function (checkX) {
+    var options = this.options, data = options.data, xAxis = this.xAxis && this.xAxis.options, yAxis = this.yAxis && this.yAxis.options, colorAxis = this.colorAxis && this.colorAxis.options;
+    return data.length > (options.boostThreshold || Number.MAX_VALUE) &&
+        // Defined yAxis extremes
+        isNumber(yAxis.min) &&
+        isNumber(yAxis.max) &&
+        // Defined (and required) xAxis extremes
+        (!checkX ||
+            (isNumber(xAxis.min) && isNumber(xAxis.max))) &&
+        // Defined (e.g. heatmap) colorAxis extremes
+        (!colorAxis ||
+            (isNumber(colorAxis.min) && isNumber(colorAxis.max)));
+};
+/**
+ * If implemented in the core, parts of this can probably be
+ * shared with other similar methods in Highcharts.
+ *
+ * @function Highcharts.Series#destroyGraphics
+ */
+Series.prototype.destroyGraphics = function () {
+    var _this = this;
+    var series = this, points = this.points, point, i;
+    if (points) {
+        for (i = 0; i < points.length; i = i + 1) {
+            point = points[i];
+            if (point && point.destroyElements) {
+                point.destroyElements(); // #7557
+            }
+        }
+    }
+    ['graph', 'area', 'tracker'].forEach(function (prop) {
+        if (series[prop]) {
+            series[prop] = series[prop].destroy();
+        }
+    });
+    if (this.getZonesGraphs) {
+        var props = this.getZonesGraphs([['graph', 'highcharts-graph']]);
+        props.forEach(function (prop) {
+            var zoneGraph = _this[prop[0]];
+            if (zoneGraph) {
+                _this[prop[0]] = zoneGraph.destroy();
+            }
+        });
+    }
+};
+// Set default options
+boostable.forEach(function (type) {
+    if (plotOptions[type]) {
+        plotOptions[type].boostThreshold = 5000;
+        plotOptions[type].boostData = [];
+        seriesTypes[type].prototype.fillOpacity = true;
+    }
+});

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Boost/BoostUtils.js

@@ -0,0 +1,255 @@
+/* *
+ *
+ *  Copyright (c) 2019-2021 Highsoft AS
+ *
+ *  Boost module: stripped-down renderer for higher performance
+ *
+ *  License: highcharts.com/license
+ *
+ *  This files contains generic utility functions used by the boost module.
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import H from '../../Core/Globals.js';
+var win = H.win, doc = H.doc;
+import boostableMap from './BoostableMap.js';
+import createAndAttachRenderer from './BoostAttach.js';
+import U from '../../Core/Utilities.js';
+var pick = U.pick;
+// This should be a const.
+var CHUNK_SIZE = 3000;
+/**
+ * Tolerant max() function.
+ *
+ * @private
+ * @function patientMax
+ *
+ * @param {...Array<Array<unknown>>} args
+ * Max arguments
+ *
+ * @return {number}
+ * Max value
+ */
+function patientMax() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var r = -Number.MAX_VALUE;
+    args.forEach(function (t) {
+        if (typeof t !== 'undefined' &&
+            t !== null &&
+            typeof t.length !== 'undefined') {
+            // r = r < t.length ? t.length : r;
+            if (t.length > 0) {
+                r = t.length;
+                return true;
+            }
+        }
+    });
+    return r;
+}
+/**
+ * Return true if ths boost.enabled option is true
+ *
+ * @private
+ * @function boostEnabled
+ *
+ * @param {Highcharts.Chart} chart
+ * The chart
+ *
+ * @return {boolean}
+ * True, if boost is enabled.
+ */
+function boostEnabled(chart) {
+    return pick((chart &&
+        chart.options &&
+        chart.options.boost &&
+        chart.options.boost.enabled), true);
+}
+/**
+ * Returns true if we should force boosting the chart
+ * @private
+ * @function shouldForceChartSeriesBoosting
+ *
+ * @param {Highcharts.Chart} chart
+ * The chart to check for forcing on
+ *
+ * @return {boolean}
+ * True, if boosting should be forced.
+ */
+function shouldForceChartSeriesBoosting(chart) {
+    // If there are more than five series currently boosting,
+    // we should boost the whole chart to avoid running out of webgl contexts.
+    var sboostCount = 0, canBoostCount = 0, allowBoostForce = pick(chart.options.boost && chart.options.boost.allowForce, true), series;
+    if (typeof chart.boostForceChartBoost !== 'undefined') {
+        return chart.boostForceChartBoost;
+    }
+    if (chart.series.length > 1) {
+        for (var i = 0; i < chart.series.length; i++) {
+            series = chart.series[i];
+            // Don't count series with boostThreshold set to 0
+            // See #8950
+            // Also don't count if the series is hidden.
+            // See #9046
+            if (series.options.boostThreshold === 0 ||
+                series.visible === false) {
+                continue;
+            }
+            // Don't count heatmap series as they are handled differently.
+            // In the future we should make the heatmap/treemap path compatible
+            // with forcing. See #9636.
+            if (series.type === 'heatmap') {
+                continue;
+            }
+            if (boostableMap[series.type]) {
+                ++canBoostCount;
+            }
+            if (patientMax(series.processedXData, series.options.data, 
+            // series.xData,
+            series.points) >= (series.options.boostThreshold || Number.MAX_VALUE)) {
+                ++sboostCount;
+            }
+        }
+    }
+    chart.boostForceChartBoost = allowBoostForce && ((canBoostCount === chart.series.length &&
+        sboostCount > 0) ||
+        sboostCount > 5);
+    return chart.boostForceChartBoost;
+}
+/* eslint-disable valid-jsdoc */
+/**
+ * Performs the actual render if the renderer is
+ * attached to the series.
+ * @private
+ * @param renderer {OGLRenderer} - the renderer
+ * @param series {Highcharts.Series} - the series
+ */
+function renderIfNotSeriesBoosting(renderer, series, chart) {
+    if (renderer &&
+        series.renderTarget &&
+        series.canvas &&
+        !(chart || series.chart).isChartSeriesBoosting()) {
+        renderer.render(chart || series.chart);
+    }
+}
+/**
+ * @private
+ */
+function allocateIfNotSeriesBoosting(renderer, series) {
+    if (renderer &&
+        series.renderTarget &&
+        series.canvas &&
+        !series.chart.isChartSeriesBoosting()) {
+        renderer.allocateBufferForSingleSeries(series);
+    }
+}
+/**
+ * An "async" foreach loop. Uses a setTimeout to keep the loop from blocking the
+ * UI thread.
+ *
+ * @private
+ *
+ * @param arr {Array} - the array to loop through
+ * @param fn {Function} - the callback to call for each item
+ * @param finalFunc {Function} - the callback to call when done
+ * @param chunkSize {Number} - the number of iterations per timeout
+ * @param i {Number} - the current index
+ * @param noTimeout {Boolean} - set to true to skip timeouts
+ */
+function eachAsync(arr, fn, finalFunc, chunkSize, i, noTimeout) {
+    i = i || 0;
+    chunkSize = chunkSize || CHUNK_SIZE;
+    var threshold = i + chunkSize, proceed = true;
+    while (proceed && i < threshold && i < arr.length) {
+        proceed = fn(arr[i], i);
+        ++i;
+    }
+    if (proceed) {
+        if (i < arr.length) {
+            if (noTimeout) {
+                eachAsync(arr, fn, finalFunc, chunkSize, i, noTimeout);
+            }
+            else if (win.requestAnimationFrame) {
+                // If available, do requestAnimationFrame - shaves off a few ms
+                win.requestAnimationFrame(function () {
+                    eachAsync(arr, fn, finalFunc, chunkSize, i);
+                });
+            }
+            else {
+                setTimeout(function () {
+                    eachAsync(arr, fn, finalFunc, chunkSize, i);
+                });
+            }
+        }
+        else if (finalFunc) {
+            finalFunc();
+        }
+    }
+}
+/**
+ * Returns true if the current browser supports webgl
+ *
+ * @private
+ * @function hasWebGLSupport
+ */
+function hasWebGLSupport() {
+    var i = 0, canvas, contexts = ['webgl', 'experimental-webgl', 'moz-webgl', 'webkit-3d'], context = false;
+    if (typeof win.WebGLRenderingContext !== 'undefined') {
+        canvas = doc.createElement('canvas');
+        for (; i < contexts.length; i++) {
+            try {
+                context = canvas.getContext(contexts[i]);
+                if (typeof context !== 'undefined' && context !== null) {
+                    return true;
+                }
+            }
+            catch (e) {
+                // silent error
+            }
+        }
+    }
+    return false;
+}
+/* eslint-disable no-invalid-this */
+/**
+ * Used for treemap|heatmap.drawPoints
+ *
+ * @private
+ * @function pointDrawHandler
+ */
+function pointDrawHandler(proceed) {
+    var enabled = true, renderer;
+    if (this.chart.options && this.chart.options.boost) {
+        enabled = typeof this.chart.options.boost.enabled === 'undefined' ?
+            true :
+            this.chart.options.boost.enabled;
+    }
+    if (!enabled || !this.isSeriesBoosting) {
+        return proceed.call(this);
+    }
+    this.chart.isBoosting = true;
+    // Make sure we have a valid OGL context
+    renderer = createAndAttachRenderer(this.chart, this);
+    if (renderer) {
+        allocateIfNotSeriesBoosting(renderer, this);
+        renderer.pushSeries(this);
+    }
+    renderIfNotSeriesBoosting(renderer, this);
+}
+/* eslint-enable no-invalid-this, valid-jsdoc */
+var funs = {
+    patientMax: patientMax,
+    boostEnabled: boostEnabled,
+    shouldForceChartSeriesBoosting: shouldForceChartSeriesBoosting,
+    renderIfNotSeriesBoosting: renderIfNotSeriesBoosting,
+    allocateIfNotSeriesBoosting: allocateIfNotSeriesBoosting,
+    eachAsync: eachAsync,
+    hasWebGLSupport: hasWebGLSupport,
+    pointDrawHandler: pointDrawHandler
+};
+// This needs to be fixed.
+H.hasWebGLSupport = hasWebGLSupport;
+export default funs;

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Boost/BoostableMap.js

@@ -0,0 +1,18 @@
+/* *
+ *
+ *  Copyright (c) 2019-2021 Highsoft AS
+ *
+ *  Boost module: stripped-down renderer for higher performance
+ *
+ *  License: highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+import boostables from './Boostables.js';
+// These are the series we allow boosting for.
+var boostableMap = {};
+boostables.forEach(function (item) {
+    boostableMap[item] = 1;
+});
+export default boostableMap;

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Boost/Boostables.js

@@ -0,0 +1,25 @@
+/* *
+ *
+ *  Copyright (c) 2019-2021 Highsoft AS
+ *
+ *  Boost module: stripped-down renderer for higher performance
+ *
+ *  License: highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+// These are the series we allow boosting for.
+var boostables = [
+    'area',
+    'arearange',
+    'column',
+    'columnrange',
+    'bar',
+    'line',
+    'scatter',
+    'heatmap',
+    'bubble',
+    'treemap'
+];
+export default boostables;