ps-toolkit-ui 0.0.207 → 0.0.211

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

@@ -0,0 +1,318 @@
+/* *
+ *
+ *  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 H from '../../Core/Globals.js';
+var noop = H.noop;
+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, extend = U.extend, fireEvent = U.fireEvent, wrap = U.wrap;
+import butils from './BoostUtils.js';
+import createAndAttachRenderer from './BoostAttach.js';
+var eachAsync = butils.eachAsync, pointDrawHandler = butils.pointDrawHandler, allocateIfNotSeriesBoosting = butils.allocateIfNotSeriesBoosting, renderIfNotSeriesBoosting = butils.renderIfNotSeriesBoosting, shouldForceChartSeriesBoosting = butils.shouldForceChartSeriesBoosting, index;
+/* eslint-disable valid-jsdoc */
+/**
+ * Initialize the boot module.
+ *
+ * @private
+ * @return {void}
+ */
+function init() {
+    extend(Series.prototype, {
+        /**
+         * @private
+         * @function Highcharts.Series#renderCanvas
+         */
+        renderCanvas: function () {
+            var series = this, options = series.options || {}, renderer = false, chart = series.chart, xAxis = this.xAxis, yAxis = this.yAxis, xData = options.xData || series.processedXData, yData = options.yData || series.processedYData, rawData = options.data, xExtremes = xAxis.getExtremes(), xMin = xExtremes.min, xMax = xExtremes.max, yExtremes = yAxis.getExtremes(), yMin = yExtremes.min, yMax = yExtremes.max, pointTaken = {}, lastClientX, sampling = !!series.sampling, points, enableMouseTracking = options.enableMouseTracking !== false, threshold = options.threshold, yBottom = yAxis.getThreshold(threshold), isRange = series.pointArrayMap &&
+                series.pointArrayMap.join(',') === 'low,high', isStacked = !!options.stacking, cropStart = series.cropStart || 0, requireSorting = series.requireSorting, useRaw = !xData, minVal, maxVal, minI, maxI, boostOptions, compareX = options.findNearestPointBy === 'x', xDataFull = (this.xData ||
+                this.options.xData ||
+                this.processedXData ||
+                false), addKDPoint = function (clientX, plotY, i) {
+                // We need to do ceil on the clientX to make things
+                // snap to pixel values. The renderer will frequently
+                // draw stuff on "sub-pixels".
+                clientX = Math.ceil(clientX);
+                // Shaves off about 60ms compared to repeated concatenation
+                index = compareX ? clientX : clientX + ',' + plotY;
+                // The k-d tree requires series points.
+                // Reduce the amount of points, since the time to build the
+                // tree increases exponentially.
+                if (enableMouseTracking && !pointTaken[index]) {
+                    pointTaken[index] = true;
+                    if (chart.inverted) {
+                        clientX = xAxis.len - clientX;
+                        plotY = yAxis.len - plotY;
+                    }
+                    points.push({
+                        x: xDataFull ? xDataFull[cropStart + i] : false,
+                        clientX: clientX,
+                        plotX: clientX,
+                        plotY: plotY,
+                        i: cropStart + i
+                    });
+                }
+            };
+            // Get or create the renderer
+            renderer = createAndAttachRenderer(chart, series);
+            chart.isBoosting = true;
+            boostOptions = renderer.settings;
+            if (!this.visible) {
+                return;
+            }
+            // If we are zooming out from SVG mode, destroy the graphics
+            if (this.points || this.graph) {
+                this.destroyGraphics();
+            }
+            // If we're rendering per. series we should create the marker groups
+            // as usual.
+            if (!chart.isChartSeriesBoosting()) {
+                // If all series were boosting, but are not anymore
+                // restore private markerGroup
+                if (this.markerGroup === chart.markerGroup) {
+                    this.markerGroup = void 0;
+                }
+                this.markerGroup = series.plotGroup('markerGroup', 'markers', true, 1, chart.seriesGroup);
+            }
+            else {
+                // If series has a private markeGroup, remove that
+                // and use common markerGroup
+                if (this.markerGroup &&
+                    this.markerGroup !== chart.markerGroup) {
+                    this.markerGroup.destroy();
+                }
+                // Use a single group for the markers
+                this.markerGroup = chart.markerGroup;
+                // When switching from chart boosting mode, destroy redundant
+                // series boosting targets
+                if (this.renderTarget) {
+                    this.renderTarget = this.renderTarget.destroy();
+                }
+            }
+            points = this.points = [];
+            // Do not start building while drawing
+            series.buildKDTree = noop;
+            if (renderer) {
+                allocateIfNotSeriesBoosting(renderer, this);
+                renderer.pushSeries(series);
+                // Perform the actual renderer if we're on series level
+                renderIfNotSeriesBoosting(renderer, this, chart);
+            }
+            /**
+             * This builds the KD-tree
+             * @private
+             */
+            function processPoint(d, i) {
+                var x, y, clientX, plotY, isNull, low = false, chartDestroyed = typeof chart.index === 'undefined', isYInside = true;
+                if (typeof d === 'undefined') {
+                    return true;
+                }
+                if (!chartDestroyed) {
+                    if (useRaw) {
+                        x = d[0];
+                        y = d[1];
+                    }
+                    else {
+                        x = d;
+                        y = yData[i];
+                    }
+                    // Resolve low and high for range series
+                    if (isRange) {
+                        if (useRaw) {
+                            y = d.slice(1, 3);
+                        }
+                        low = y[0];
+                        y = y[1];
+                    }
+                    else if (isStacked) {
+                        x = d.x;
+                        y = d.stackY;
+                        low = y - d.y;
+                    }
+                    isNull = y === null;
+                    // Optimize for scatter zooming
+                    if (!requireSorting) {
+                        isYInside = y >= yMin && y <= yMax;
+                    }
+                    if (!isNull && x >= xMin && x <= xMax && isYInside) {
+                        clientX = xAxis.toPixels(x, true);
+                        if (sampling) {
+                            if (typeof minI === 'undefined' ||
+                                clientX === lastClientX) {
+                                if (!isRange) {
+                                    low = y;
+                                }
+                                if (typeof maxI === 'undefined' ||
+                                    y > maxVal) {
+                                    maxVal = y;
+                                    maxI = i;
+                                }
+                                if (typeof minI === 'undefined' ||
+                                    low < minVal) {
+                                    minVal = low;
+                                    minI = i;
+                                }
+                            }
+                            // Add points and reset
+                            if (clientX !== lastClientX) {
+                                // maxI is number too:
+                                if (typeof minI !== 'undefined') {
+                                    plotY =
+                                        yAxis.toPixels(maxVal, true);
+                                    yBottom =
+                                        yAxis.toPixels(minVal, true);
+                                    addKDPoint(clientX, plotY, maxI);
+                                    if (yBottom !== plotY) {
+                                        addKDPoint(clientX, yBottom, minI);
+                                    }
+                                }
+                                minI = maxI = void 0;
+                                lastClientX = clientX;
+                            }
+                        }
+                        else {
+                            plotY = Math.ceil(yAxis.toPixels(y, true));
+                            addKDPoint(clientX, plotY, i);
+                        }
+                    }
+                }
+                return !chartDestroyed;
+            }
+            /**
+             * @private
+             */
+            function doneProcessing() {
+                fireEvent(series, 'renderedCanvas');
+                // Go back to prototype, ready to build
+                delete series.buildKDTree;
+                series.buildKDTree();
+                if (boostOptions.debug.timeKDTree) {
+                    console.timeEnd('kd tree building'); // eslint-disable-line no-console
+                }
+            }
+            // Loop over the points to build the k-d tree - skip this if
+            // exporting
+            if (!chart.renderer.forExport) {
+                if (boostOptions.debug.timeKDTree) {
+                    console.time('kd tree building'); // eslint-disable-line no-console
+                }
+                eachAsync(isStacked ? series.data : (xData || rawData), processPoint, doneProcessing);
+            }
+        }
+    });
+    /*
+     * We need to handle heatmaps separatly, since we can't perform the
+     * size/color calculations in the shader easily.
+     *
+     * This likely needs future optimization.
+     */
+    ['heatmap', 'treemap'].forEach(function (t) {
+        if (seriesTypes[t]) {
+            wrap(seriesTypes[t].prototype, 'drawPoints', pointDrawHandler);
+        }
+    });
+    /* eslint-disable no-invalid-this */
+    if (seriesTypes.bubble) {
+        // By default, the bubble series does not use the KD-tree, so force it
+        // to.
+        delete seriesTypes.bubble.prototype.buildKDTree;
+        // seriesTypes.bubble.prototype.directTouch = false;
+        // Needed for markers to work correctly
+        wrap(seriesTypes.bubble.prototype, 'markerAttribs', function (proceed) {
+            if (this.isSeriesBoosting) {
+                return false;
+            }
+            return proceed.apply(this, [].slice.call(arguments, 1));
+        });
+    }
+    seriesTypes.scatter.prototype.fill = true;
+    extend(seriesTypes.area.prototype, {
+        fill: true,
+        fillOpacity: true,
+        sampling: true
+    });
+    extend(seriesTypes.column.prototype, {
+        fill: true,
+        sampling: true
+    });
+    Chart.prototype.propsRequireUpdateSeries.push('boost');
+    // Take care of the canvas blitting
+    Chart.prototype.callbacks.push(function (chart) {
+        /**
+         * Convert chart-level canvas to image.
+         * @private
+         */
+        function canvasToSVG() {
+            if (chart.ogl && chart.isChartSeriesBoosting()) {
+                chart.ogl.render(chart);
+            }
+        }
+        /**
+         * Clear chart-level canvas.
+         * @private
+         */
+        function preRender() {
+            // Reset force state
+            chart.boostForceChartBoost = void 0;
+            chart.boostForceChartBoost = shouldForceChartSeriesBoosting(chart);
+            chart.isBoosting = false;
+            if (!chart.isChartSeriesBoosting() && chart.didBoost) {
+                chart.didBoost = false;
+            }
+            // Clear the canvas
+            if (chart.boostClear) {
+                chart.boostClear();
+            }
+            if (chart.canvas && chart.ogl && chart.isChartSeriesBoosting()) {
+                chart.didBoost = true;
+                // Allocate
+                chart.ogl.allocateBuffer(chart);
+            }
+            // see #6518 + #6739
+            if (chart.markerGroup &&
+                chart.xAxis &&
+                chart.xAxis.length > 0 &&
+                chart.yAxis &&
+                chart.yAxis.length > 0) {
+                chart.markerGroup.translate(chart.xAxis[0].pos, chart.yAxis[0].pos);
+            }
+        }
+        addEvent(chart, 'predraw', preRender);
+        addEvent(chart, 'render', canvasToSVG);
+        // addEvent(chart, 'zoom', function () {
+        //     chart.boostForceChartBoost =
+        //         shouldForceChartSeriesBoosting(chart);
+        // });
+        var prevX = -1;
+        var prevY = -1;
+        addEvent(chart.pointer, 'afterGetHoverData', function () {
+            var series = chart.hoverSeries;
+            if (chart.markerGroup && series) {
+                var xAxis = chart.inverted ? series.yAxis : series.xAxis;
+                var yAxis = chart.inverted ? series.xAxis : series.yAxis;
+                if ((xAxis && xAxis.pos !== prevX) ||
+                    (yAxis && yAxis.pos !== prevY)) {
+                    // #10464: Keep the marker group position in sync with the
+                    // position of the hovered series axes since there is only
+                    // one shared marker group when boosting.
+                    chart.markerGroup.translate(xAxis.pos, yAxis.pos);
+                    prevX = xAxis.pos;
+                    prevY = yAxis.pos;
+                }
+            }
+        });
+    });
+    /* eslint-enable no-invalid-this */
+}
+export default init;

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

@@ -0,0 +1,219 @@
+/* *
+ *
+ *  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 '../../Core/Globals.js';
+/**
+ * Options for the Boost module. The Boost module allows certain series types
+ * to be rendered by WebGL instead of the default SVG. This allows hundreds of
+ * thousands of data points to be rendered in milliseconds. In addition to the
+ * WebGL rendering it saves time by skipping processing and inspection of the
+ * data wherever possible. This introduces some limitations to what features are
+ * available in boost mode. See [the docs](
+ * https://www.highcharts.com/docs/advanced-chart-features/boost-module) for
+ * details.
+ *
+ * In addition to the global `boost` option, each series has a
+ * [boostThreshold](#plotOptions.series.boostThreshold) that defines when the
+ * boost should kick in.
+ *
+ * Requires the `modules/boost.js` module.
+ *
+ * @sample {highstock} highcharts/boost/line-series-heavy-stock
+ *         Stock chart
+ * @sample {highstock} highcharts/boost/line-series-heavy-dynamic
+ *         Dynamic stock chart
+ * @sample highcharts/boost/line
+ *         Line chart
+ * @sample highcharts/boost/line-series-heavy
+ *         Line chart with hundreds of series
+ * @sample highcharts/boost/scatter
+ *         Scatter chart
+ * @sample highcharts/boost/area
+ *         Area chart
+ * @sample highcharts/boost/arearange
+ *         Area range chart
+ * @sample highcharts/boost/column
+ *         Column chart
+ * @sample highcharts/boost/columnrange
+ *         Column range chart
+ * @sample highcharts/boost/bubble
+ *         Bubble chart
+ * @sample highcharts/boost/heatmap
+ *         Heat map
+ * @sample highcharts/boost/treemap
+ *         Tree map
+ *
+ * @product   highcharts highstock
+ * @requires  modules/boost
+ * @apioption boost
+ */
+/**
+ * Set the series threshold for when the boost should kick in globally.
+ *
+ * Setting to e.g. 20 will cause the whole chart to enter boost mode
+ * if there are 20 or more series active. When the chart is in boost mode,
+ * every series in it will be rendered to a common canvas. This offers
+ * a significant speed improvment in charts with a very high
+ * amount of series.
+ *
+ * @type      {number}
+ * @default   50
+ * @apioption boost.seriesThreshold
+ */
+/**
+ * Enable or disable boost on a chart.
+ *
+ * @type      {boolean}
+ * @default   true
+ * @apioption boost.enabled
+ */
+/**
+ * Debugging options for boost.
+ * Useful for benchmarking, and general timing.
+ *
+ * @apioption boost.debug
+ */
+/**
+ * Time the series rendering.
+ *
+ * This outputs the time spent on actual rendering in the console when
+ * set to true.
+ *
+ * @type      {boolean}
+ * @default   false
+ * @apioption boost.debug.timeRendering
+ */
+/**
+ * Time the series processing.
+ *
+ * This outputs the time spent on transforming the series data to
+ * vertex buffers when set to true.
+ *
+ * @type      {boolean}
+ * @default   false
+ * @apioption boost.debug.timeSeriesProcessing
+ */
+/**
+ * Time the the WebGL setup.
+ *
+ * This outputs the time spent on setting up the WebGL context,
+ * creating shaders, and textures.
+ *
+ * @type      {boolean}
+ * @default   false
+ * @apioption boost.debug.timeSetup
+ */
+/**
+ * Time the building of the k-d tree.
+ *
+ * This outputs the time spent building the k-d tree used for
+ * markers etc.
+ *
+ * Note that the k-d tree is built async, and runs post-rendering.
+ * Following, it does not affect the performance of the rendering itself.
+ *
+ * @type      {boolean}
+ * @default   false
+ * @apioption boost.debug.timeKDTree
+ */
+/**
+ * Show the number of points skipped through culling.
+ *
+ * When set to true, the number of points skipped in series processing
+ * is outputted. Points are skipped if they are closer than 1 pixel from
+ * each other.
+ *
+ * @type      {boolean}
+ * @default   false
+ * @apioption boost.debug.showSkipSummary
+ */
+/**
+ * Time the WebGL to SVG buffer copy
+ *
+ * After rendering, the result is copied to an image which is injected
+ * into the SVG.
+ *
+ * If this property is set to true, the time it takes for the buffer copy
+ * to complete is outputted.
+ *
+ * @type      {boolean}
+ * @default   false
+ * @apioption boost.debug.timeBufferCopy
+ */
+/**
+ * Enable or disable GPU translations. GPU translations are faster than doing
+ * the translation in JavaScript.
+ *
+ * This option may cause rendering issues with certain datasets.
+ * Namely, if your dataset has large numbers with small increments (such as
+ * timestamps), it won't work correctly. This is due to floating point
+ * precission.
+ *
+ * @type      {boolean}
+ * @default   false
+ * @apioption boost.useGPUTranslations
+ */
+/**
+ * Enable or disable pre-allocation of vertex buffers.
+ *
+ * Enabling this will make it so that the binary data arrays required for
+ * storing the series data will be allocated prior to transforming the data
+ * to a WebGL-compatible format.
+ *
+ * This saves a copy operation on the order of O(n) and so is significantly more
+ * performant. However, this is currently an experimental option, and may cause
+ * visual artifacts with some datasets.
+ *
+ * As such, care should be taken when using this setting to make sure that
+ * it doesn't cause any rendering glitches with the given use-case.
+ *
+ * @type      {boolean}
+ * @default   false
+ * @apioption boost.usePreallocated
+ */
+/**
+ * Set the point threshold for when a series should enter boost mode.
+ *
+ * Setting it to e.g. 2000 will cause the series to enter boost mode when there
+ * are 2000 or more points in the series.
+ *
+ * To disable boosting on the series, set the `boostThreshold` to 0. Setting it
+ * to 1 will force boosting.
+ *
+ * Note that the [cropThreshold](plotOptions.series.cropThreshold) also affects
+ * this setting. When zooming in on a series that has fewer points than the
+ * `cropThreshold`, all points are rendered although outside the visible plot
+ * area, and the `boostThreshold` won't take effect.
+ *
+ * @type      {number}
+ * @default   5000
+ * @requires  modules/boost
+ * @apioption plotOptions.series.boostThreshold
+ */
+/**
+ * If set to true, the whole chart will be boosted if one of the series
+ * crosses its threshold, and all the series can be boosted.
+ *
+ * @type      {boolean}
+ * @default   true
+ * @apioption boost.allowForce
+ */
+/**
+ * Sets the color blending in the boost module.
+ *
+ * @type       {string}
+ * @default    undefined
+ * @validvalue ["add", "multiply", "darken"]
+ * @requires   modules/boost
+ * @apioption  plotOptions.series.boostBlending
+ */
+''; // adds doclets above to transpiled file