ngx-hana-nameserver-history-viewer 1.1.1 → 1.1.9-1.beta

package/esm2020/src/nameserver-history-viewer/utils/chartjs-downsample/lttb_data_mipmap.mjs

@@ -0,0 +1,106 @@
+import * as utils from './utils';
+import { DataMipmap } from './data_mipmap';
+/**
+ * A mipmap data structure that uses Largest-Triangle-Three-Buckets algorithm to downsample data
+ */
+export class LTTBDataMipmap extends DataMipmap {
+    getMipMapIndexForResolution(resolution) {
+        if (utils.isNil(resolution)) {
+            return 0;
+        }
+        let index = utils.findIndexInArray(this.resolutions, (levelResolution) => levelResolution >= resolution);
+        if (index === -1) {
+            // use smallest mipmap as fallback
+            index = this.resolutions.length - 1;
+        }
+        return index;
+    }
+    createMipMap() {
+        super.createMipMap();
+        this.resolutions = this.mipMaps.map((level) => this.computeAverageResolution(level));
+    }
+    /**
+     * This method is adapted from: https://github.com/sveinn-steinarsson/flot-downsample
+     *
+     * The MIT License
+     * Copyright (c) 2013 by Sveinn Steinarsson
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    downsampleToResolution(data, targetResolution, targetLength) {
+        const dataLength = data.length;
+        if (targetLength >= dataLength || targetLength === 0) {
+            return data; // data has target size
+        }
+        const output = [];
+        // bucket size, leave room for start and end data points
+        const bucksetSize = (dataLength - 2) / (targetLength - 2);
+        let a = 0; // initially a is the first point in the triangle
+        let maxAreaPoint;
+        let maxArea;
+        let area;
+        let nextA;
+        // always add the first point
+        output.push(data[a]);
+        for (let i = 0; i < targetLength - 2; ++i) {
+            // Calculate point average for next bucket (containing c)
+            let avgX = 0;
+            let avgY = 0;
+            let avgRangeStart = Math.floor((i + 1) * bucksetSize) + 1;
+            let avgRangeEnd = Math.floor((i + 2) * bucksetSize) + 1;
+            avgRangeEnd = avgRangeEnd < dataLength ? avgRangeEnd : dataLength;
+            const avgRangeLength = avgRangeEnd - avgRangeStart;
+            for (; avgRangeStart < avgRangeEnd; avgRangeStart++) {
+                avgX += this.getTime(data[avgRangeStart]);
+                avgY += data[avgRangeStart].y * 1;
+            }
+            avgX /= avgRangeLength;
+            avgY /= avgRangeLength;
+            // Get the range for this bucket
+            let rangeOffs = Math.floor((i + 0) * bucksetSize) + 1;
+            const rangeTo = Math.floor((i + 1) * bucksetSize) + 1;
+            // Point a
+            const pointA = data[a];
+            const pointAX = this.getTime(pointA);
+            const pointAY = pointA.y * 1;
+            maxArea = area = -1;
+            for (; rangeOffs < rangeTo; rangeOffs++) {
+                // Calculate triangle area over three buckets
+                area = Math.abs((pointAX - avgX) * (data[rangeOffs].y - pointAY) -
+                    (pointAX - this.getTime(data[rangeOffs])) * (avgY - pointAY)) * 0.5;
+                if (area > maxArea) {
+                    maxArea = area;
+                    maxAreaPoint = data[rangeOffs];
+                    nextA = rangeOffs; // Next a is this b
+                }
+            }
+            output.push(maxAreaPoint); // Pick this point from the bucket
+            a = nextA; // This a is the next a (chosen b)
+        }
+        output.push(data[dataLength - 1]); // Always add last
+        return output;
+    }
+    computeAverageResolution(data) {
+        let timeDistances = 0;
+        for (let i = 0, end = this.originalData.length - 1; i < end; ++i) {
+            const current = this.originalData[i];
+            const next = this.originalData[i + 1];
+            timeDistances += Math.abs(this.getTime(current) - this.getTime(next));
+        }
+        return timeDistances / (data.length - 1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lttb_data_mipmap.js","sourceRoot":"","sources":["../../../../../../src/nameserver-history-viewer/utils/chartjs-downsample/lttb_data_mipmap.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * This plugin is adapted from: https://github.com/3dcl/chartjs-plugin-responsive-downsample\r\n * for controlling the radius of point.\r\n *\r\n * MIT License\r\n * Copyright (c) 2018 3D Content Logistics\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nimport { ChartPoint } from 'chart.js';\r\nimport * as utils from './utils';\r\nimport { DataMipmap } from './data_mipmap';\r\n\r\n/**\r\n * A mipmap data structure that uses Largest-Triangle-Three-Buckets algorithm to downsample data\r\n */\r\nexport class LTTBDataMipmap extends DataMipmap {\r\n    protected resolutions: number[];\r\n\r\n    getMipMapIndexForResolution(resolution: number): number {\r\n        if (utils.isNil(resolution)) { return 0; }\r\n\r\n        let index = utils.findIndexInArray(this.resolutions, (levelResolution) => levelResolution >= resolution);\r\n        if (index === -1) {\r\n            // use smallest mipmap as fallback\r\n            index = this.resolutions.length - 1;\r\n        }\r\n\r\n        return index;\r\n    }\r\n\r\n    protected createMipMap(): void {\r\n        super.createMipMap();\r\n        this.resolutions = this.mipMaps.map((level) => this.computeAverageResolution(level));\r\n    }\r\n\r\n    /**\r\n     * This method is adapted from: https://github.com/sveinn-steinarsson/flot-downsample\r\n     *\r\n     * The MIT License\r\n     * Copyright (c) 2013 by Sveinn Steinarsson\r\n     * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n     * of this software and associated documentation files (the \"Software\"), to deal\r\n     * in the Software without restriction, including without limitation the rights\r\n     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n     * copies of the Software, and to permit persons to whom the Software is\r\n     * furnished to do so, subject to the following conditions:\r\n     * The above copyright notice and this permission notice shall be included in\r\n     * all copies or substantial portions of the Software.\r\n     * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n     * THE SOFTWARE.\r\n     */\r\n    protected downsampleToResolution(\r\n        data: ChartPoint[],\r\n        targetResolution: number,\r\n        targetLength: number\r\n    ) {\r\n        const dataLength = data.length;\r\n        if (targetLength >= dataLength || targetLength === 0) {\r\n            return data; // data has target size\r\n        }\r\n\r\n        const output: ChartPoint[] = [];\r\n\r\n        // bucket size, leave room for start and end data points\r\n        const bucksetSize = (dataLength - 2) / (targetLength - 2);\r\n\r\n        let a = 0;  // initially a is the first point in the triangle\r\n        let maxAreaPoint: ChartPoint;\r\n        let maxArea: number;\r\n        let area: number;\r\n        let nextA: number;\r\n\r\n        // always add the first point\r\n        output.push(data[a]);\r\n\r\n        for (let i = 0; i < targetLength - 2; ++i) {\r\n            // Calculate point average for next bucket (containing c)\r\n            let avgX = 0;\r\n            let avgY = 0;\r\n            let avgRangeStart = Math.floor((i + 1) * bucksetSize) + 1;\r\n            let avgRangeEnd = Math.floor((i + 2) * bucksetSize) + 1;\r\n            avgRangeEnd = avgRangeEnd < dataLength ? avgRangeEnd : dataLength;\r\n\r\n            const avgRangeLength = avgRangeEnd - avgRangeStart;\r\n\r\n            for (; avgRangeStart < avgRangeEnd; avgRangeStart++) {\r\n                avgX += this.getTime(data[avgRangeStart]);\r\n                avgY += data[avgRangeStart].y as number * 1;\r\n            }\r\n            avgX /= avgRangeLength;\r\n            avgY /= avgRangeLength;\r\n\r\n            // Get the range for this bucket\r\n            let rangeOffs = Math.floor((i + 0) * bucksetSize) + 1;\r\n            const rangeTo = Math.floor((i + 1) * bucksetSize) + 1;\r\n\r\n            // Point a\r\n            const pointA = data[a];\r\n            const pointAX = this.getTime(pointA);\r\n            const pointAY = pointA.y as number * 1;\r\n\r\n            maxArea = area = -1;\r\n\r\n            for (; rangeOffs < rangeTo; rangeOffs++) {\r\n                // Calculate triangle area over three buckets\r\n                area = Math.abs((pointAX - avgX) * (data[rangeOffs].y as number - pointAY) -\r\n                    (pointAX - this.getTime(data[rangeOffs])) * (avgY - pointAY)\r\n                ) * 0.5;\r\n\r\n                if (area > maxArea) {\r\n                    maxArea = area;\r\n                    maxAreaPoint = data[rangeOffs];\r\n                    nextA = rangeOffs; // Next a is this b\r\n                }\r\n            }\r\n\r\n            output.push(maxAreaPoint); // Pick this point from the bucket\r\n            a = nextA; // This a is the next a (chosen b)\r\n        }\r\n\r\n        output.push(data[dataLength - 1]); // Always add last\r\n\r\n        return output;\r\n    }\r\n\r\n    protected computeAverageResolution(data: ChartPoint[]): number {\r\n        let timeDistances = 0;\r\n\r\n        for (let i = 0, end = this.originalData.length - 1; i < end; ++i) {\r\n            const current = this.originalData[i];\r\n            const next = this.originalData[i + 1];\r\n\r\n            timeDistances += Math.abs(this.getTime(current) - this.getTime(next));\r\n        }\r\n        return timeDistances / (data.length - 1);\r\n    }\r\n}\r\n"]}

package/esm2020/src/nameserver-history-viewer/utils/chartjs-downsample/responsive_downsample_plugin.mjs

@@ -0,0 +1,168 @@
+/**
+ * This plugin is adapted from: https://github.com/3dcl/chartjs-plugin-responsive-downsample
+ * for controlling the radius of point.
+ *
+ * MIT License
+ * Copyright (c) 2018 3D Content Logistics
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import * as moment_module from 'moment';
+const moment = (window && window.moment) ? window.moment : moment_module;
+import * as utils from './utils';
+import { DataMipmap } from './data_mipmap';
+import { LTTBDataMipmap } from './lttb_data_mipmap';
+import * as data_culling from './data_culling';
+// Using dynamic flag to fix the issue of ng-packagr #696: Lambda not supported
+// @dynamic
+/**
+ * Chart js Plugin for downsampling data
+ */
+export class ResponsiveDownsamplePlugin {
+    static getPluginOptions(chart) {
+        const options = chart.options.responsiveDownsample || {};
+        utils.defaultsDeep(options, {
+            enabled: false,
+            aggregationAlgorithm: 'LTTB',
+            desiredDataPointDistance: 1,
+            minNumPoints: 100,
+            maxNumPointsToDraw: 100,
+            cullData: true
+        });
+        if (options.enabled) {
+            chart.options.responsiveDownsample = options;
+        }
+        return options;
+    }
+    static hasDataChanged(chart) {
+        return !utils.isNil(utils.findInArray(chart.data.datasets, (dataset) => {
+            return utils.isNil(dataset.mipMap);
+        }));
+    }
+    static createDataMipMap(chart, options) {
+        chart.data.datasets.forEach((dataset) => {
+            // @ts-ignore
+            const data = !utils.isNil(dataset.originalData) ? dataset.originalData : dataset.data;
+            const mipMap = (options.aggregationAlgorithm === 'LTTB')
+                ? new LTTBDataMipmap(data, options.minNumPoints)
+                : new DataMipmap(data, options.minNumPoints);
+            dataset.originalData = data;
+            dataset.mipMap = mipMap;
+            // @ts-ignore
+            dataset.data = mipMap.getMipMapLevel(mipMap.getNumLevel() - 1); // set last level for first render pass
+        });
+    }
+    static restoreOriginalData(chart) {
+        let updated = false;
+        chart.data.datasets.forEach((dataset) => {
+            // @ts-ignore
+            if (!utils.isNil(dataset.originalData) && dataset.data !== dataset.originalData) {
+                // @ts-ignore
+                dataset.data = dataset.originalData;
+                updated = true;
+            }
+        });
+        return updated;
+    }
+    static getTargetResolution(chart, options) {
+        const xScale = chart.scales['x-axis-0'];
+        if (utils.isNil(xScale)) {
+            return null;
+        }
+        const start = moment(xScale.getValueForPixel(xScale.left));
+        const end = moment(xScale.getValueForPixel(xScale.left + 1));
+        const targetResolution = end.diff(start);
+        return targetResolution * options.desiredDataPointDistance;
+    }
+    static updateMipMap(chart, options, rangeChanged) {
+        let updated = false;
+        chart.data.datasets.forEach((dataset) => {
+            const mipMap = dataset.mipMap;
+            if (utils.isNil(mipMap)) {
+                return;
+            }
+            const mipMalLevel = mipMap.getMipMapIndexForResolution(options.targetResolution);
+            if (mipMalLevel === dataset.currentMipMapLevel && !rangeChanged) {
+                // skip update if mip map level and data range did not change
+                return;
+            }
+            updated = true;
+            dataset.currentMipMapLevel = mipMalLevel;
+            let newData = mipMap.getMipMapLevel(mipMalLevel);
+            if (options.cullData) {
+                newData = data_culling.cullData(newData, options.scaleRange);
+            }
+            // @ts-ignore
+            dataset.data = newData;
+        });
+        return updated;
+    }
+    beforeInit(chart) {
+        const options = ResponsiveDownsamplePlugin.getPluginOptions(chart);
+        if (!options.enabled) {
+            return;
+        }
+        ResponsiveDownsamplePlugin.createDataMipMap(chart, options);
+        options.needsUpdate = true;
+    }
+    beforeDatasetsUpdate(chart) {
+        const options = ResponsiveDownsamplePlugin.getPluginOptions(chart);
+        if (!options.enabled) {
+            // restore original data and remove state from options
+            options.needsUpdate = ResponsiveDownsamplePlugin.restoreOriginalData(chart);
+            delete options.targetResolution;
+            delete options.scaleRange;
+            return;
+        }
+        // only update mip map if data set was reloaded externally
+        if (ResponsiveDownsamplePlugin.hasDataChanged(chart)) {
+            ResponsiveDownsamplePlugin.createDataMipMap(chart, options);
+            options.needsUpdate = true;
+        }
+    }
+    beforeRender(chart) {
+        const options = ResponsiveDownsamplePlugin.getPluginOptions(chart);
+        if (!options.enabled) {
+            // update chart if data was restored from original data
+            if (options.needsUpdate) {
+                options.needsUpdate = false;
+                chart.update(0);
+                return false;
+            }
+            return;
+        }
+        const targetResolution = ResponsiveDownsamplePlugin.getTargetResolution(chart, options);
+        const xScale = chart.scales['x-axis-0'];
+        const scaleRange = data_culling.getScaleRange(xScale);
+        const rangeChanged = !data_culling.rangeIsEqual(options.scaleRange, scaleRange);
+        if (options.needsUpdate ||
+            options.targetResolution !== targetResolution ||
+            rangeChanged) {
+            options.targetResolution = targetResolution;
+            options.scaleRange = scaleRange;
+            options.needsUpdate = false;
+            if (ResponsiveDownsamplePlugin.updateMipMap(chart, options, rangeChanged)) {
+                utils.changePointRadius(chart, options);
+                // update chart and cancel current render
+                chart.update(0);
+                return false;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"responsive_downsample_plugin.js","sourceRoot":"","sources":["../../../../../../src/nameserver-history-viewer/utils/chartjs-downsample/responsive_downsample_plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * This plugin is adapted from: https://github.com/3dcl/chartjs-plugin-responsive-downsample\r\n * for controlling the radius of point.\r\n *\r\n * MIT License\r\n * Copyright (c) 2018 3D Content Logistics\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nimport * as moment_module from 'moment';\r\nconst moment = (window && (window as any).moment) ? (window as any).moment : moment_module;\r\nimport { Chart, ChartData, ChartDataSets, ChartPoint } from 'chart.js';\r\nimport { IChartPlugin, TimeScale } from './chartjs_ext';\r\nimport * as utils from './utils';\r\n\r\nimport { DataMipmap } from './data_mipmap';\r\nimport { LTTBDataMipmap } from './lttb_data_mipmap';\r\nimport * as data_culling from './data_culling';\r\n\r\ninterface MipMapDataSets extends ChartDataSets {\r\n  originalData?: ChartPoint[];\r\n  currentMipMapLevel?: number;\r\n  mipMap?: DataMipmap;\r\n}\r\n\r\nexport interface ResponsiveDownsamplePluginOptions {\r\n  /**\r\n   * Enable/disable plugin\r\n   */\r\n  enabled?: boolean;\r\n  /**\r\n   * The aggregation algorithm to thin out data. Default: LTTB\r\n   */\r\n  aggregationAlgorithm?: 'AVG' | 'LTTB';\r\n  /**\r\n   * Desired minimal distance between data points in pixels. Default: 1 pixel\r\n   */\r\n  desiredDataPointDistance?: number;\r\n  /**\r\n   * Minimal number of data points. Limits\r\n   */\r\n  minNumPoints?: number;\r\n  /**\r\n   * Cull data to displayed range of x scale\r\n   */\r\n  cullData?: boolean;\r\n  /**\r\n   * Flag is set by plugin to trigger reload of data\r\n   */\r\n  needsUpdate?: boolean;\r\n  /**\r\n   * Current target resolution(Set by plugin)\r\n   */\r\n  targetResolution?: number;\r\n  /**\r\n   * Scale range of x axis\r\n   */\r\n  scaleRange?: data_culling.Range;\r\n  /**\r\n   * Draw points only if the points number less than the limitation\r\n   */\r\n  maxNumPointsToDraw?: number;\r\n}\r\n\r\n// Using dynamic flag to fix the issue of ng-packagr #696: Lambda not supported\r\n// @dynamic\r\n/**\r\n * Chart js Plugin for downsampling data\r\n */\r\nexport class ResponsiveDownsamplePlugin implements IChartPlugin {\r\n  static getPluginOptions(chart: any): ResponsiveDownsamplePluginOptions {\r\n    const options: ResponsiveDownsamplePluginOptions = chart.options.responsiveDownsample || {};\r\n    utils.defaultsDeep(options, {\r\n      enabled: false,\r\n      aggregationAlgorithm: 'LTTB',\r\n      desiredDataPointDistance: 1,\r\n      minNumPoints: 100,\r\n      maxNumPointsToDraw: 100,\r\n      cullData: true\r\n    });\r\n\r\n    if (options.enabled) {\r\n      chart.options.responsiveDownsample = options;\r\n    }\r\n\r\n    return options;\r\n  }\r\n\r\n  static hasDataChanged(chart: Chart): boolean {\r\n    return !utils.isNil(\r\n      utils.findInArray(\r\n        chart.data.datasets as MipMapDataSets[],\r\n        (dataset) => {\r\n          return utils.isNil(dataset.mipMap);\r\n        }\r\n      )\r\n    );\r\n  }\r\n\r\n  static createDataMipMap(chart: Chart, options: ResponsiveDownsamplePluginOptions): void {\r\n    chart.data.datasets.forEach((dataset: MipMapDataSets) => {\r\n      // @ts-ignore\r\n      const data = !utils.isNil(dataset.originalData) ? dataset.originalData : dataset.data as ChartPoint[];\r\n\r\n      const mipMap = (options.aggregationAlgorithm === 'LTTB')\r\n        ? new LTTBDataMipmap(data, options.minNumPoints)\r\n        : new DataMipmap(data, options.minNumPoints);\r\n\r\n      dataset.originalData = data;\r\n      dataset.mipMap = mipMap;\r\n      // @ts-ignore\r\n      dataset.data = mipMap.getMipMapLevel(mipMap.getNumLevel() - 1); // set last level for first render pass\r\n    });\r\n  }\r\n\r\n  static restoreOriginalData(chart: Chart): boolean {\r\n    let updated = false;\r\n\r\n    chart.data.datasets.forEach((dataset: MipMapDataSets) => {\r\n      // @ts-ignore\r\n      if (!utils.isNil(dataset.originalData) && dataset.data !== dataset.originalData) {\r\n        // @ts-ignore\r\n        dataset.data = dataset.originalData;\r\n        updated = true;\r\n      }\r\n    });\r\n\r\n    return updated;\r\n  }\r\n\r\n  static getTargetResolution(chart: Chart, options: ResponsiveDownsamplePluginOptions): number {\r\n    const xScale: TimeScale = (chart as any).scales['x-axis-0'];\r\n\r\n    if (utils.isNil(xScale)) {\r\n      return null;\r\n    }\r\n\r\n    const start = moment(xScale.getValueForPixel(xScale.left) as any);\r\n    const end = moment(xScale.getValueForPixel(xScale.left + 1) as any);\r\n    const targetResolution = end.diff(start);\r\n\r\n    return targetResolution * options.desiredDataPointDistance;\r\n  }\r\n\r\n  static updateMipMap(chart: Chart, options: ResponsiveDownsamplePluginOptions, rangeChanged: boolean): boolean {\r\n    let updated = false;\r\n\r\n    chart.data.datasets.forEach((dataset: MipMapDataSets) => {\r\n      const mipMap = dataset.mipMap;\r\n      if (utils.isNil(mipMap)) {\r\n        return;\r\n      }\r\n\r\n      const mipMalLevel = mipMap.getMipMapIndexForResolution(options.targetResolution);\r\n      if (mipMalLevel === dataset.currentMipMapLevel && !rangeChanged) {\r\n        // skip update if mip map level and data range did not change\r\n        return;\r\n      }\r\n      updated = true;\r\n      dataset.currentMipMapLevel = mipMalLevel;\r\n\r\n      let newData = mipMap.getMipMapLevel(mipMalLevel);\r\n      if (options.cullData) {\r\n        newData = data_culling.cullData(newData, options.scaleRange);\r\n      }\r\n\r\n      // @ts-ignore\r\n      dataset.data = newData;\r\n    });\r\n\r\n    return updated;\r\n  }\r\n\r\n  beforeInit(chart: Chart): void {\r\n    const options = ResponsiveDownsamplePlugin.getPluginOptions(chart);\r\n    if (!options.enabled) { return; }\r\n\r\n    ResponsiveDownsamplePlugin.createDataMipMap(chart, options);\r\n    options.needsUpdate = true;\r\n  }\r\n\r\n  beforeDatasetsUpdate(chart: Chart): void {\r\n    const options = ResponsiveDownsamplePlugin.getPluginOptions(chart);\r\n    if (!options.enabled) {\r\n      // restore original data and remove state from options\r\n      options.needsUpdate = ResponsiveDownsamplePlugin.restoreOriginalData(chart);\r\n      delete options.targetResolution;\r\n      delete options.scaleRange;\r\n      return;\r\n    }\r\n\r\n    // only update mip map if data set was reloaded externally\r\n    if (ResponsiveDownsamplePlugin.hasDataChanged(chart)) {\r\n      ResponsiveDownsamplePlugin.createDataMipMap(chart, options);\r\n      options.needsUpdate = true;\r\n    }\r\n  }\r\n\r\n  beforeRender(chart: Chart): boolean {\r\n    const options = ResponsiveDownsamplePlugin.getPluginOptions(chart);\r\n    if (!options.enabled) {\r\n      // update chart if data was restored from original data\r\n      if (options.needsUpdate) {\r\n        options.needsUpdate = false;\r\n        chart.update(0);\r\n\r\n        return false;\r\n      }\r\n      return;\r\n    }\r\n\r\n    const targetResolution = ResponsiveDownsamplePlugin.getTargetResolution(chart, options);\r\n    const xScale: TimeScale = (chart as any).scales['x-axis-0'];\r\n    const scaleRange = data_culling.getScaleRange(xScale);\r\n    const rangeChanged = !data_culling.rangeIsEqual(options.scaleRange, scaleRange);\r\n\r\n    if (options.needsUpdate ||\r\n      options.targetResolution !== targetResolution ||\r\n      rangeChanged\r\n    ) {\r\n      options.targetResolution = targetResolution;\r\n      options.scaleRange = scaleRange;\r\n      options.needsUpdate = false;\r\n\r\n      if (ResponsiveDownsamplePlugin.updateMipMap(chart, options, rangeChanged)) {\r\n        utils.changePointRadius(chart, options);\r\n        // update chart and cancel current render\r\n        chart.update(0);\r\n\r\n        return false;\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/src/nameserver-history-viewer/utils/chartjs-downsample/utils.mjs

@@ -0,0 +1,114 @@
+/**
+ * This plugin is adapted from: https://github.com/3dcl/chartjs-plugin-responsive-downsample
+ * for controlling the radius of point.
+ *
+ * MIT License
+ * Copyright (c) 2018 3D Content Logistics
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * Check if a value is null or undefined
+ */
+export function isNil(value) {
+    return (typeof value === 'undefined') || value === null;
+}
+/**
+ * Clamp a number to a range
+ * @param value
+ * @param min
+ * @param max
+ */
+export function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+/**
+ * Recursively assign default values to an object if object is missing the keys.
+ * @param object The destination object to assign default values to
+ * @param defaults The default values for the object
+ * @return The destination object
+ */
+export function defaultsDeep(object, defaults) {
+    for (const key in defaults) {
+        if (defaults.hasOwnProperty(key)) {
+            const value = object[key];
+            if (typeof value === 'undefined') {
+                object[key] = defaults[key];
+            }
+            else if (value !== null && typeof value === 'object') {
+                object[key] = defaultsDeep(value, defaults[key]);
+            }
+        }
+    }
+    return object;
+}
+/**
+ * Finds the first element in an array for that the comaperator functions returns true
+ *
+ * @export
+ * @param array An array
+ * @param compareFunction Comperator function returning true for the element seeked
+ * @returns The found element or undefined
+ */
+export function findInArray(array, compareFunction) {
+    if (isNil(array)) {
+        return undefined;
+    }
+    for (let i = 0; i < array.length; i++) {
+        if (compareFunction(array[i]) === true) {
+            return array[i];
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds the first index in an array for that the comaperator function for an element returns true
+ *
+ * @export
+ * @param array An array of elements
+ * @param compareFunction Comperator function returning true for the element seeked
+ * @returns Index of the matched element or -1 if no element was found
+ */
+export function findIndexInArray(array, compareFunction) {
+    if (isNil(array)) {
+        return undefined;
+    }
+    for (let i = 0; i < array.length; i++) {
+        if (compareFunction(array[i]) === true) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * If points number is less than minNumPoints, show radius for all points.
+ */
+export function changePointRadius(chart, options) {
+    if (chart && chart.data && chart.data.datasets && options) {
+        let pointRadiusChangeFlag = false;
+        const maxNumPointsToDraw = options.maxNumPointsToDraw == null ? 100 : options.maxNumPointsToDraw;
+        for (const dataset of chart.data.datasets) {
+            if (dataset.data.length < maxNumPointsToDraw) {
+                pointRadiusChangeFlag = true;
+                break;
+            }
+        }
+        chart.options.elements.point.radius = pointRadiusChangeFlag ? 2 : 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../src/nameserver-history-viewer/utils/chartjs-downsample/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * This plugin is adapted from: https://github.com/3dcl/chartjs-plugin-responsive-downsample\r\n * for controlling the radius of point.\r\n *\r\n * MIT License\r\n * Copyright (c) 2018 3D Content Logistics\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\n\r\n/**\r\n * Check if a value is null or undefined\r\n */\r\nexport function isNil(value: any): value is null | undefined {\r\n    return (typeof value === 'undefined') || value === null;\r\n}\r\n\r\n/**\r\n * Clamp a number to a range\r\n * @param value\r\n * @param min\r\n * @param max\r\n */\r\nexport function clamp(value: number, min: number, max: number): number {\r\n    return Math.min(Math.max(value, min), max);\r\n}\r\n\r\n/**\r\n * Recursively assign default values to an object if object is missing the keys.\r\n * @param object The destination object to assign default values to\r\n * @param defaults The default values for the object\r\n * @return The destination object\r\n */\r\nexport function defaultsDeep<T>(object: T, defaults: Partial<T>): T {\r\n    for (const key in defaults) {\r\n      if (defaults.hasOwnProperty(key)) {\r\n        const value = object[key];\r\n\r\n        if (typeof value === 'undefined') {\r\n          object[key] = defaults[key];\r\n        } else if (value !== null && typeof value === 'object') {\r\n          object[key] = defaultsDeep(value, defaults[key]);\r\n        }\r\n      }\r\n    }\r\n\r\n    return object;\r\n}\r\n\r\n\r\n/**\r\n * Finds the first element in an array for that the comaperator functions returns true\r\n *\r\n * @export\r\n * @param array An array\r\n * @param compareFunction Comperator function returning true for the element seeked\r\n * @returns The found element or undefined\r\n */\r\nexport function findInArray<T>(array: Array<T>, compareFunction: (element: T) => boolean): T {\r\n    if (isNil(array)) {\r\n      return undefined;\r\n    }\r\n    for (let i = 0; i < array.length; i++) {\r\n        if (compareFunction(array[i]) === true) {\r\n            return array[i];\r\n        }\r\n    }\r\n    return undefined;\r\n}\r\n\r\n\r\n/**\r\n * Finds the first index in an array for that the comaperator function for an element returns true\r\n *\r\n * @export\r\n * @param array An array of elements\r\n * @param compareFunction Comperator function returning true for the element seeked\r\n * @returns Index of the matched element or -1 if no element was found\r\n */\r\nexport function findIndexInArray<T>(array: Array<T>, compareFunction: (element: T) => boolean): number {\r\n    if (isNil(array)) {\r\n      return undefined;\r\n    }\r\n    for (let i = 0; i < array.length; i++) {\r\n        if (compareFunction(array[i]) === true) {\r\n            return i;\r\n        }\r\n    }\r\n    return -1;\r\n}\r\n\r\n/**\r\n * If points number is less than minNumPoints, show radius for all points.\r\n */\r\nexport function changePointRadius(chart, options): void {\r\n  if (chart && chart.data && chart.data.datasets && options) {\r\n    let pointRadiusChangeFlag = false;\r\n    const maxNumPointsToDraw = options.maxNumPointsToDraw == null ? 100 : options.maxNumPointsToDraw;\r\n    for (const dataset of chart.data.datasets) {\r\n      if (dataset.data.length < maxNumPointsToDraw) {\r\n        pointRadiusChangeFlag = true;\r\n        break;\r\n      }\r\n    }\r\n    chart.options.elements.point.radius = pointRadiusChangeFlag ? 2 : 0;\r\n  }\r\n}\r\n"]}