tsichart-core 1.0.0

package/dist/GroupedBarChart.js

@@ -0,0 +1,17 @@
+export { G as default } from './GroupedBarChart-BspwM8r2.js';
+import './_tslib-5_9pMg1F.js';
+import 'd3';
+import './Utils-C_j8IgZh.js';
+import 'moment-timezone';
+import './Legend-DlSXQXHF.js';
+import './Component-CofgyEw0.js';
+import './GroupedBarChartData-BRCyDxbA.js';
+import './Grid-DfFAkeeV.js';
+import './ContextMenu-DABSkTA2.js';
+import './Tooltip-Fa-0Xekn.js';
+import './ChartVisualizationComponent-CG7e5xlc.js';
+import './ChartComponent-DnKLTxWe.js';
+import 'split.js';
+import './EllipsisMenu-30FNqoIv.js';
+import './ChartDataOptions-DRd8NHra.js';
+import './Slider-BtSdC4fj.js';

package/dist/GroupedBarChartData-BRCyDxbA.js

@@ -0,0 +1,121 @@
+import { _ as __extends } from './_tslib-5_9pMg1F.js';
+import { U as Utils } from './Utils-C_j8IgZh.js';
+import { C as ChartComponentData } from './Grid-DfFAkeeV.js';
+import * as d3 from 'd3';
+
+var GroupedBarChartData = /** @class */ (function (_super) {
+    __extends(GroupedBarChartData, _super);
+    function GroupedBarChartData() {
+        var _this = _super.call(this) || this;
+        // allValues, aggsSeries, and allTimestampsArray span the entire time period of the aggregate expressions passed in
+        _this.valuesOfVisibleType = [];
+        _this.globalMax = -Number.MAX_VALUE;
+        _this.globalMin = Number.MAX_VALUE;
+        _this.stackMin = function (series) {
+            return Number(d3.min(series, function (d) { return d[0][0]; }));
+        };
+        _this.stackMax = function (series) {
+            return Number(d3.max(series, function (d) { return d[0][1]; }));
+        };
+        return _this;
+    }
+    GroupedBarChartData.prototype.mergeDataToDisplayStateAndTimeArrays = function (data, timestamp, aggregateExpressionOptions) {
+        if (aggregateExpressionOptions === void 0) { aggregateExpressionOptions = null; }
+        _super.prototype.mergeDataToDisplayStateAndTimeArrays.call(this, data, aggregateExpressionOptions);
+        this.timestamp = timestamp;
+        this.setValuesAtTimestamp();
+        this.setFilteredAggregates();
+    };
+    //setting the data related to the entire time range (aggsSeries, allValus, globalMax, globalMin)
+    GroupedBarChartData.prototype.setEntireRangeData = function (scaledToCurrentTime) {
+        var _this = this;
+        this.globalMax = -Number.MAX_VALUE;
+        this.globalMin = Number.MAX_VALUE;
+        this.aggsSeries = {};
+        this.valuesOfVisibleType = [];
+        Object.keys(this.displayState).forEach(function (aggKey, aggI) {
+            var currentTimeSeries;
+            _this.allTimestampsArray.forEach(function (ts) {
+                if (_this.displayState[aggKey].visible) {
+                    var localSplitByNames = [];
+                    var stackedAggregateObject = Object.keys(_this.displayState[aggKey].splitBys).reverse().reduce(function (sAO, splitByName) {
+                        var splitBy = _this.displayState[aggKey].splitBys[splitByName];
+                        localSplitByNames.push(splitByName);
+                        var value;
+                        if (_this.data[aggI][_this.displayState[aggKey].name][splitByName][ts])
+                            value = _this.data[aggI][_this.displayState[aggKey].name][splitByName][ts][splitBy.visibleType];
+                        else
+                            value = Number.MIN_VALUE;
+                        if (!splitBy.visible) {
+                            if (value > 0)
+                                value = Number.MIN_VALUE;
+                            else
+                                value = -Number.MIN_VALUE;
+                        }
+                        sAO[splitByName] = value;
+                        if ((!scaledToCurrentTime || ts == _this.timestamp) && splitBy.visible) {
+                            _this.valuesOfVisibleType.push(value);
+                        }
+                        return sAO;
+                    }, {});
+                    var series = d3.stack()
+                        .keys(localSplitByNames)
+                        .offset(d3.stackOffsetDiverging)([stackedAggregateObject]);
+                    series.reverse();
+                    if (ts == _this.timestamp)
+                        currentTimeSeries = series;
+                    if ((ts == _this.timestamp || !scaledToCurrentTime) && series != undefined) {
+                        _this.globalMax = Math.max(_this.stackMax(series), _this.globalMax);
+                        _this.globalMin = Math.min(_this.stackMin(series), _this.globalMin);
+                    }
+                }
+            });
+            _this.aggsSeries[aggKey] = currentTimeSeries;
+        });
+    };
+    GroupedBarChartData.prototype.setValuesAtTimestamp = function () {
+        var _this = this;
+        var aggregateCounterMap = {};
+        this.valuesAtTimestamp = {};
+        this.data.forEach(function (aggregate, aggI) {
+            var aggName = Object.keys(aggregate)[0];
+            var aggKey;
+            if (aggregateCounterMap[aggName]) {
+                aggKey = Utils.createEntityKey(aggName, aggregateCounterMap[aggName]);
+                aggregateCounterMap[aggName] += 1;
+            }
+            else {
+                aggKey = Utils.createEntityKey(aggName, 0);
+                aggregateCounterMap[aggName] = 1;
+            }
+            _this.valuesAtTimestamp[aggKey] = {};
+            _this.valuesAtTimestamp[aggKey].splitBys = Object.keys(aggregate[aggName])
+                .reduce(function (aggSplitBys, splitBy, splitByI) {
+                aggSplitBys[splitBy] = {};
+                aggSplitBys[splitBy].measurements = aggregate[aggName][splitBy][_this.timestamp];
+                return aggSplitBys;
+            }, {});
+        });
+    };
+    GroupedBarChartData.prototype.getValueContainerData = function (aggKey) {
+        var _this = this;
+        return Object.keys(this.displayState[aggKey].splitBys).map(function (splitBy) {
+            var measureType = _this.displayState[aggKey].splitBys[splitBy].visibleType;
+            var val;
+            if (_this.valuesAtTimestamp[aggKey].splitBys[splitBy].measurements &&
+                _this.valuesAtTimestamp[aggKey].splitBys[splitBy].measurements[measureType])
+                val = _this.valuesAtTimestamp[aggKey].splitBys[splitBy].measurements[measureType];
+            else
+                val = null;
+            return {
+                measureType: measureType,
+                aggKey: aggKey,
+                splitBy: splitBy,
+                val: val
+            };
+        });
+    };
+    return GroupedBarChartData;
+}(ChartComponentData));
+
+export { GroupedBarChartData as G };

package/dist/GroupedBarChartData-C0YQydrP.d.ts

@@ -0,0 +1,20 @@
+import { C as ChartComponentData } from './ChartComponentData-D5wuQmmZ.js';
+
+declare class GroupedBarChartData extends ChartComponentData {
+    timestamp: any;
+    valuesAtTimestamp: any;
+    valuesOfVisibleType: Array<any>;
+    aggsSeries: any;
+    globalMax: number;
+    globalMin: number;
+    stackedAggregateObject: any;
+    constructor();
+    mergeDataToDisplayStateAndTimeArrays(data: any, timestamp: any, aggregateExpressionOptions?: any): void;
+    private stackMin;
+    private stackMax;
+    setEntireRangeData(scaledToCurrentTime: any): void;
+    setValuesAtTimestamp(): void;
+    getValueContainerData(aggKey: any): Array<any>;
+}
+
+export { GroupedBarChartData as G };