tsichart-core 1.0.0

package/dist/UXClient-DydSPZwM.js

@@ -0,0 +1,230 @@
+import { L as LineChart } from './LineChart-CExEyjZa.js';
+import { A as AvailabilityChart } from './AvailabilityChart-i_efwXCX.js';
+import { P as PieChart } from './PieChart-B1ZXk13Q.js';
+import { S as ScatterPlot } from './ScatterPlot-DrPoHNDJ.js';
+import { G as GroupedBarChart } from './GroupedBarChart-BspwM8r2.js';
+import { G as Grid } from './Grid-DfFAkeeV.js';
+import { S as Slider } from './Slider-BtSdC4fj.js';
+import { H as Hierarchy } from './Hierarchy-QkWLHkxo.js';
+import AggregateExpression from './AggregateExpression.js';
+import { H as Heatmap } from './Heatmap-D8ET8Ue8.js';
+import { E as EventsTable } from './EventsTable-a0XLbsMF.js';
+import { M as ModelSearch } from './ModelSearch-WEa7Ud20.js';
+import { D as DateTimePicker } from './DateTimePicker-BH6qiVfQ.js';
+import { T as TimezonePicker } from './TimezonePicker-ClfP1lBL.js';
+import { U as Utils } from './Utils-C_j8IgZh.js';
+import { E as EllipsisMenu } from './EllipsisMenu-30FNqoIv.js';
+import TsqExpression from './TsqExpression.js';
+import { M as ModelAutocomplete } from './ModelAutocomplete-TRD16egq.js';
+import { H as HierarchyNavigation } from './HierarchyNavigation-CR6YUilh.js';
+import { S as SingleDateTimePicker } from './SingleDateTimePicker-7anflEq8.js';
+import { D as DateTimeButtonSingle } from './DateTimeButtonSingle-C6cTx5VO.js';
+import { D as DateTimeButtonRange } from './DateTimeButtonRange-DpgfhHQt.js';
+import { P as ProcessGraphic } from './ProcessGraphic-CixT-zZl.js';
+import { P as PlaybackControls } from './PlaybackControls-Dwt6dif9.js';
+import { C as ColorPicker } from './ColorPicker-CH__K8xm.js';
+import { G as GeoProcessGraphic } from './GeoProcessGraphic-AVAzyF7k.js';
+
+var UXClient = /** @class */ (function () {
+    function UXClient() {
+        // Public facing components have class constructors exposed as public UXClient members.
+        // This allows for typings to be bundled while maintaining 'new Component()' syntax
+        this.DateTimePicker = DateTimePicker;
+        this.PieChart = PieChart;
+        this.ScatterPlot = ScatterPlot;
+        this.BarChart = GroupedBarChart;
+        this.LineChart = LineChart;
+        this.AvailabilityChart = AvailabilityChart;
+        this.Grid = Grid;
+        this.Slider = Slider;
+        this.Hierarchy = Hierarchy;
+        this.AggregateExpression = AggregateExpression;
+        this.TsqExpression = TsqExpression;
+        this.Heatmap = Heatmap;
+        this.EventsTable = EventsTable;
+        this.ModelSearch = ModelSearch;
+        this.ModelAutocomplete = ModelAutocomplete;
+        this.HierarchyNavigation = HierarchyNavigation;
+        this.TimezonePicker = TimezonePicker;
+        this.EllipsisMenu = EllipsisMenu;
+        this.SingleDateTimePicker = SingleDateTimePicker;
+        this.DateTimeButtonSingle = DateTimeButtonSingle;
+        this.DateTimeButtonRange = DateTimeButtonRange;
+        this.ProcessGraphic = ProcessGraphic;
+        this.PlaybackControls = PlaybackControls;
+        this.ColorPicker = ColorPicker;
+        this.GeoProcessGraphic = GeoProcessGraphic;
+    }
+    UXClient.prototype.UXClient = function () {
+    };
+    UXClient.prototype.transformTsxToEventsArray = function (events, options) {
+        var timezoneOffset = options.timezoneOffset ? options.timezoneOffset : 0;
+        var rows = [];
+        var eventSourceProperties = {};
+        var nameToStrippedPropName = {};
+        var valueToStrippedValueMap = {};
+        var _loop_1 = function () {
+            if (events[eventIdx].hasOwnProperty('schema')) {
+                eventSourceProperties[events[eventIdx].schema.rid] = {};
+                eventSourceProperties[events[eventIdx].schema.rid].propertyNames = events[eventIdx].schema.properties.reduce(function (prev, curr) {
+                    prev.push({ name: curr.name, type: curr.type });
+                    return prev;
+                }, []);
+                eventSourceProperties[events[eventIdx].schema.rid].eventSourceName = events[eventIdx].schema['$esn'];
+                eventSourceId = events[eventIdx].schema.rid;
+            }
+            else {
+                eventSourceId = events[eventIdx].schemaRid;
+            }
+            timeStamp = (new Date((new Date(events[eventIdx]['$ts'])).valueOf() - timezoneOffset)).toISOString().slice(0, -1).replace('T', ' ');
+            event = { 'timestamp ($ts)': timeStamp };
+            // lts logic
+            lts = events[eventIdx]['$lts'] ? events[eventIdx]['$lts'] : null;
+            if (lts) {
+                event['LocalTimestamp_DateTime'] = {
+                    value: lts.replace('T', ' '),
+                    name: 'LocalTimestamp',
+                    type: 'DateTime'
+                };
+            }
+            event["EventSourceName_String"] = {
+                value: eventSourceProperties[eventSourceId].eventSourceName,
+                name: 'EventSourceName',
+                type: 'String'
+            };
+            for (var propIdx in eventSourceProperties[eventSourceId].propertyNames) {
+                name = eventSourceProperties[eventSourceId].propertyNames[propIdx].name;
+                if (!nameToStrippedPropName.hasOwnProperty(name))
+                    nameToStrippedPropName[name] = Utils.stripForConcat(name);
+                strippedName = nameToStrippedPropName[name];
+                type = eventSourceProperties[eventSourceId].propertyNames[propIdx].type;
+                columnNameAndType = strippedName + "_" + type;
+                if (!valueToStrippedValueMap.hasOwnProperty(String(events[eventIdx].values[propIdx])))
+                    valueToStrippedValueMap[String(events[eventIdx].values[propIdx])] = Utils.stripForConcat(String(events[eventIdx].values[propIdx]));
+                eventObject = {
+                    value: valueToStrippedValueMap[String(events[eventIdx].values[propIdx])],
+                    name: strippedName,
+                    type: type
+                };
+                event[columnNameAndType] = eventObject;
+            }
+            if (events[eventIdx].hasOwnProperty('$op')) {
+                var defaultType_1 = 'String';
+                var otherProps_1 = JSON.parse(events[eventIdx]['$op']);
+                Object.keys(otherProps_1).forEach(function (propNameRaw) {
+                    var strippedNameOP = Utils.stripForConcat(propNameRaw);
+                    var columnNameAndTypeOP = strippedNameOP + '_String';
+                    event[columnNameAndTypeOP] = {
+                        value: otherProps_1[propNameRaw],
+                        name: strippedNameOP,
+                        type: defaultType_1
+                    };
+                });
+            }
+            rows.push(event);
+        };
+        var eventSourceId, timeStamp, event, lts, name, strippedName, type, columnNameAndType, eventObject;
+        for (var eventIdx in events) {
+            _loop_1();
+        }
+        return rows;
+    };
+    UXClient.prototype.toISONoMillis = function (dateTime) {
+        return dateTime.toISOString().slice(0, -5) + "Z";
+    };
+    //specifiedRange gives the subset of availability buckets to be returned. If not included, will return all buckets
+    UXClient.prototype.transformAvailabilityForVisualization = function (availabilityTsx) {
+        var _this = this;
+        var from = new Date(availabilityTsx.range.from);
+        var to = new Date(availabilityTsx.range.to);
+        var rawBucketSize = Utils.parseTimeInput(availabilityTsx.intervalSize);
+        var buckets = {};
+        var startBucket = Math.round(Math.floor(from.valueOf() / rawBucketSize) * rawBucketSize);
+        var firstKey = this.toISONoMillis(new Date(startBucket));
+        var firstCount = availabilityTsx.distribution[firstKey] ? availabilityTsx.distribution[firstKey] : 0;
+        // reset first key if greater than the availability range from
+        if (startBucket < (new Date(availabilityTsx.range.from)).valueOf())
+            firstKey = this.toISONoMillis(new Date(availabilityTsx.range.from));
+        buckets[firstKey] = { count: firstCount };
+        Object.keys(availabilityTsx.distribution).forEach(function (key) {
+            var formattedISO = _this.toISONoMillis(new Date(key));
+            buckets[formattedISO] = { count: availabilityTsx.distribution[key] };
+        });
+        //set end time value
+        var lastBucket = Math.round(Math.floor(to.valueOf() / rawBucketSize) * rawBucketSize);
+        // pad out if range is less than one bucket;
+        if (startBucket == lastBucket) {
+            for (var i = startBucket; i <= startBucket + rawBucketSize; i += (rawBucketSize / 60)) {
+                if (buckets[this.toISONoMillis(new Date(i))] == undefined)
+                    buckets[this.toISONoMillis(new Date(i))] = { count: 0 };
+            }
+            //reset startBucket to count 0 if not the start time
+            if (startBucket != from.valueOf()) {
+                buckets[this.toISONoMillis(new Date(startBucket))] = { count: 0 };
+            }
+        }
+        return [{ "availabilityCount": { "": buckets } }];
+    };
+    UXClient.prototype.transformAggregatesForVisualization = function (aggregates, options) {
+        var result = [];
+        aggregates.forEach(function (agg, i) {
+            var transformedAggregate = {};
+            var aggregatesObject = {};
+            transformedAggregate[options[i].alias] = aggregatesObject;
+            if (agg.hasOwnProperty('__tsiError__'))
+                transformedAggregate[''] = {};
+            else if (agg.hasOwnProperty('aggregate')) {
+                agg.dimension.forEach(function (d, j) {
+                    var dateTimeToValueObject = {};
+                    aggregatesObject[d] = dateTimeToValueObject;
+                    agg.aggregate.dimension.forEach(function (dt, k) {
+                        var measuresObject = {};
+                        dateTimeToValueObject[dt] = measuresObject;
+                        options[i].measureTypes.forEach(function (t, l) {
+                            if (agg.aggregate.measures[j][k] != null && agg.aggregate.measures[j][k] != undefined &&
+                                agg.aggregate.measures[j][k][l] != null && agg.aggregate.measures[j][k][l] != undefined)
+                                measuresObject[t] = agg.aggregate.measures[j][k][l];
+                            else
+                                measuresObject[t] = null;
+                        });
+                    });
+                });
+            }
+            else {
+                var dateTimeToValueObject = {};
+                aggregatesObject[''] = dateTimeToValueObject;
+                agg.dimension.forEach(function (dt, j) {
+                    var measuresObject = {};
+                    dateTimeToValueObject[dt] = measuresObject;
+                    options[i].measureTypes.forEach(function (t, l) {
+                        measuresObject[t] = agg.measures[j][l];
+                    });
+                });
+            }
+            result.push(transformedAggregate);
+        });
+        return result;
+    };
+    // exposed publicly to use for highlighting elements in the well on hover/focus
+    UXClient.prototype.createEntityKey = function (aggName, aggIndex) {
+        if (aggIndex === void 0) { aggIndex = 0; }
+        return Utils.createEntityKey(aggName, aggIndex);
+    };
+    UXClient.prototype.transformTsqResultsToEventsArray = function (results) {
+        var flattenedResults = [];
+        results.forEach(function (tsqr) {
+            tsqr.timestamps.forEach(function (ts, idx) {
+                var event = {};
+                event['timestamp ($ts)'] = ts;
+                tsqr.properties.forEach(function (p) {
+                    event["".concat(p.name, "_").concat(p.type)] = { name: p.name, type: p.type, value: p.values[idx] };
+                });
+                flattenedResults.push(event);
+            });
+        });
+        return flattenedResults.sort(function (a, b) { return (new Date(a['timestamp ($ts)'])).valueOf() < (new Date(b['timestamp ($ts)'])).valueOf() ? -1 : 1; });
+    };
+    return UXClient;
+}());
+
+export { UXClient as U };

package/dist/UXClient.d.ts

@@ -0,0 +1,74 @@
+import LineChart from './LineChart.js';
+import AvailabilityChart from './AvailabilityChart.js';
+import PieChart from './PieChart.js';
+import ScatterPlot from './ScatterPlot.js';
+import GroupedBarChart from './GroupedBarChart.js';
+import Grid from './Grid.js';
+import Slider from './Slider.js';
+import Hierarchy from './Hierarchy.js';
+import AggregateExpression from './AggregateExpression.js';
+import Heatmap from './Heatmap.js';
+import EventsTable from './EventsTable.js';
+import ModelSearch from './ModelSearch.js';
+import DateTimePicker from './DateTimePicker.js';
+import TimezonePicker from './TimezonePicker.js';
+import EllipsisMenu from './EllipsisMenu.js';
+import TsqExpression from './TsqExpression.js';
+import ModelAutocomplete from './ModelAutocomplete.js';
+import HierarchyNavigation from './HierarchyNavigation.js';
+import SingleDateTimePicker from './SingleDateTimePicker.js';
+import DateTimeButtonSingle from './DateTimeButtonSingle.js';
+import DateTimeButtonRange from './DateTimeButtonRange.js';
+import ProcessGraphic from './ProcessGraphic.js';
+import PlaybackControls from './PlaybackControls.js';
+import ColorPicker from './ColorPicker.js';
+import GeoProcessGraphic from './GeoProcessGraphic.js';
+import './TemporalXAxisComponent-CyiM5EH0.js';
+import './ChartVisualizationComponent-DBjiqR1n.js';
+import './ChartComponent-DTcc6aED.js';
+import './Enums-ChUuTtHV.js';
+import './Component-Rp30sSAW.js';
+import './Interfaces-BKRQ685G.js';
+import './ChartComponentData-D5wuQmmZ.js';
+import './GroupedBarChartData-C0YQydrP.js';
+import './ChartDataOptions-DBS28b1-.js';
+import './DateTimeButton-CMcCxc8x.js';
+import './HistoryPlayback-BmA-54lT.js';
+import 'd3';
+
+declare class UXClient {
+    UXClient(): void;
+    DateTimePicker: typeof DateTimePicker;
+    PieChart: typeof PieChart;
+    ScatterPlot: typeof ScatterPlot;
+    BarChart: typeof GroupedBarChart;
+    LineChart: typeof LineChart;
+    AvailabilityChart: typeof AvailabilityChart;
+    Grid: typeof Grid;
+    Slider: typeof Slider;
+    Hierarchy: typeof Hierarchy;
+    AggregateExpression: typeof AggregateExpression;
+    TsqExpression: typeof TsqExpression;
+    Heatmap: typeof Heatmap;
+    EventsTable: typeof EventsTable;
+    ModelSearch: typeof ModelSearch;
+    ModelAutocomplete: typeof ModelAutocomplete;
+    HierarchyNavigation: typeof HierarchyNavigation;
+    TimezonePicker: typeof TimezonePicker;
+    EllipsisMenu: typeof EllipsisMenu;
+    SingleDateTimePicker: typeof SingleDateTimePicker;
+    DateTimeButtonSingle: typeof DateTimeButtonSingle;
+    DateTimeButtonRange: typeof DateTimeButtonRange;
+    ProcessGraphic: typeof ProcessGraphic;
+    PlaybackControls: typeof PlaybackControls;
+    ColorPicker: typeof ColorPicker;
+    GeoProcessGraphic: typeof GeoProcessGraphic;
+    transformTsxToEventsArray(events: any, options: any): any[];
+    private toISONoMillis;
+    transformAvailabilityForVisualization(availabilityTsx: any): Array<any>;
+    transformAggregatesForVisualization(aggregates: Array<any>, options: any): Array<any>;
+    createEntityKey(aggName: string, aggIndex?: number): string;
+    transformTsqResultsToEventsArray(results: any): any[];
+}
+
+export { UXClient as default };

package/dist/UXClient.js

@@ -0,0 +1,47 @@
+export { U as default } from './UXClient-DydSPZwM.js';
+import './LineChart-CExEyjZa.js';
+import './_tslib-5_9pMg1F.js';
+import 'd3';
+import 'd3-voronoi';
+import './Utils-C_j8IgZh.js';
+import 'moment-timezone';
+import './Legend-DlSXQXHF.js';
+import './Component-CofgyEw0.js';
+import './TemporalXAxisComponent-DkyVvASs.js';
+import './ChartVisualizationComponent-CG7e5xlc.js';
+import './ChartComponent-DnKLTxWe.js';
+import './Grid-DfFAkeeV.js';
+import 'split.js';
+import './EllipsisMenu-30FNqoIv.js';
+import './ChartDataOptions-DRd8NHra.js';
+import './ContextMenu-DABSkTA2.js';
+import './Tooltip-Fa-0Xekn.js';
+import 'd3-interpolate-path';
+import './AvailabilityChart-i_efwXCX.js';
+import './DateTimePicker-BH6qiVfQ.js';
+import './pikaday-DMSzaLH6.js';
+import 'moment';
+import './TimezonePicker-ClfP1lBL.js';
+import './AggregateExpression.js';
+import './DateTimeButtonRange-DpgfhHQt.js';
+import './DateTimeButton-Ca1487GR.js';
+import './PieChart-B1ZXk13Q.js';
+import './GroupedBarChartData-BRCyDxbA.js';
+import './Slider-BtSdC4fj.js';
+import './ScatterPlot-DrPoHNDJ.js';
+import './GroupedBarChart-BspwM8r2.js';
+import './Hierarchy-QkWLHkxo.js';
+import './Heatmap-D8ET8Ue8.js';
+import './EventsTable-a0XLbsMF.js';
+import './ModelSearch-WEa7Ud20.js';
+import 'awesomplete';
+import './ModelAutocomplete-TRD16egq.js';
+import './TsqExpression.js';
+import './HierarchyNavigation-CR6YUilh.js';
+import './SingleDateTimePicker-7anflEq8.js';
+import './DateTimeButtonSingle-C6cTx5VO.js';
+import './ProcessGraphic-CixT-zZl.js';
+import './HistoryPlayback-SjeQbAPq.js';
+import './PlaybackControls-Dwt6dif9.js';
+import './ColorPicker-CH__K8xm.js';
+import './GeoProcessGraphic-AVAzyF7k.js';

package/dist/Utils-BsPLzJBC.d.ts

@@ -0,0 +1,104 @@
+import * as d3 from 'd3';
+import { Y as YAxisStates } from './Enums-ChUuTtHV.js';
+
+declare class Utils {
+    static guidForNullTSID: string;
+    static formatYAxisNumber(val: number): string;
+    static getStackStates(): typeof YAxisStates;
+    static parseTimeInput(inputString: string): number;
+    static findClosestTime(prevMillis: number, timeMap: any): number;
+    static getValueOfVisible(d: any, visibleMeasure: string): any;
+    static isStartAt(startAtString?: string, searchSpan?: any): boolean;
+    static parseShift(shiftString: string, startAtString?: any, searchSpan?: any): number;
+    static adjustStartMillisToAbsoluteZero(fromMillis: any, bucketSize: any): number;
+    static bucketSizeToTsqInterval(bucketSize: string): string;
+    static createEntityKey(aggName: string, aggIndex: number): string;
+    static getColorForValue(chartDataOptions: any, value: any): any;
+    static rollUpContiguous(data: any): any;
+    static formatOffsetMinutes(offset: any): string;
+    static getOffsetMinutes(offset: any, millis: number): any;
+    static offsetUTC(date: Date): Date;
+    static getMinutesToUTC(offset: any, millisInOffset: number): number;
+    static addOffsetGuess(timezoneName: any): string;
+    static timezoneAbbreviation(timezoneName: any): string;
+    static createTimezoneAbbreviation(offset: any): string;
+    static parseTimezoneName(timezoneRaw: any): any;
+    static convertTimezoneToLabel(timezone: any, locdLocal?: string): string;
+    static rangeTimeFormat(rangeMillis: number): string;
+    static subDateTimeFormat(is24HourTime: any, usesSeconds: any, usesMillis: any): string;
+    static timeFormat(usesSeconds?: boolean, usesMillis?: boolean, offset?: any, is24HourTime?: boolean, shiftMillis?: number, timeFormat?: string, locale?: string): (d: any) => string;
+    static splitTimeLabel(text: any): void;
+    static getUTCHours(d: Date, is24HourTime?: boolean): number;
+    static UTCTwelveHourFormat(d: Date): string;
+    static getAgVisible(displayState: any, aggI: string, splitBy: string): any;
+    static getAgVisibleMeasure(displayState: any, aggI: string, splitBy: string): any;
+    static createSeriesTypeIcon(seriesType: string, selection: any): void;
+    static strip(text: any): string;
+    static stripForConcat(text: any): any;
+    static setSeriesLabelSubtitleText(subtitle: any, isInFocus?: boolean): void;
+    static revertAllSubtitleText(markerValues: any, opacity?: number): void;
+    static generateColors(numColors: number, includeColors?: string[]): any[];
+    static convertFromLocal(date: Date): Date;
+    static adjustDateFromTimezoneOffset(date: Date): Date;
+    static offsetFromUTC(date: Date, offset?: number): Date;
+    static offsetToUTC(date: Date, offset?: number): Date;
+    static parseUserInputDateTime(timeText: any, offset: any): number;
+    static getBrighterColor(color: string): any;
+    static createSplitByColors(displayState: any, aggKey: string, ignoreIsOnlyAgg?: boolean): any[];
+    static colorSplitBy(displayState: any, splitByIndex: number, aggKey: string, ignoreIsOnlyAgg?: boolean): any;
+    static getTheme(theme: any): string;
+    static clearSelection(): void;
+    static mark(filter: any, text: any): any;
+    static hash(str: any): number;
+    static guid(): string;
+    static createValueFilter(aggregateKey: any, splitBy: any): (d: any, j: number) => boolean;
+    static downloadCSV(csvString: string, csvName?: string): void;
+    static sanitizeString(str: any, type: String): any;
+    static focusOnEllipsisButton(renderTarget: any): void;
+    static createDownloadEllipsisOption(csvStringGenerator: any, action?: () => void, downloadLabel?: string): {
+        iconClass: string;
+        label: string;
+        action: () => void;
+        description: string;
+    };
+    static createControlPanel(renderTarget: any, legendWidth: number, topChartMargin: number, chartOptions: any): d3.Selection<HTMLDivElement, unknown, null, undefined>;
+    static escapeQuotesCommasAndNewlines(stringToEscape: string): string;
+    static getNonNumericHeight(rawHeight: number): number;
+    static getControlPanelWidth(renderTarget: any, legendWidth: any, isLegendShown: any): number;
+    static getValueOrDefault(chartOptionsObj: any, propertyName: any, defaultValue?: any): any;
+    static safeNotNullOrUndefined(valueLambda: any): boolean;
+    static equalToEventTarget: (current: any, event: any) => boolean;
+    static getAggKeys(data: any): any;
+    static roundToMillis(rawTo: any, bucketSize: any): number;
+    static mergeSeriesForScatterPlot(chartData: any, scatterMeasures: any): {
+        [x: string]: {
+            "": {};
+        };
+    };
+    static getScatterPlotMeasureNames(chartData: any, scatterMeasures: any): {
+        X_MEASURE: string;
+        Y_MEASURE: string;
+        R_MEASURE: string;
+    };
+    static isKeyDownAndNotEnter: (e: any) => boolean;
+    static getMinWarmTime(warmStoreFrom: any, retentionString: any): Date;
+    static standardizeTSStrings(rawData: any): any[];
+    static cullValuesOutOfRange(availabilityDistribution: any, minDateString: string, maxDateString: string): any[];
+    static mergeAvailabilities(warmAvailability: any, coldAvailability: any, retentionString?: any): any;
+    static languageGuess(): string;
+    static getInstanceKey: (instance: any) => any;
+    static stripNullGuid: (str: any) => any;
+    static getTimeSeriesIdString: (instance: any) => any;
+    static getTimeSeriesIdToDisplay: (instance: any, emptyDisplayString: any) => any;
+    static getHighlightedTimeSeriesIdToDisplay: (instance: any) => any;
+    static instanceHasEmptyTSID: (instance: any) => boolean;
+    static appendFormattedElementsFromString: (targetElem: any, str: any, options?: {
+        additionalClassName?: string;
+        inSvg?: boolean;
+        splitByTag?: string;
+    }) => void;
+    static escapedTsidForExactSearch: (tsid: string) => string;
+    static memorySizeOf(obj: any): number;
+}
+
+export { Utils as U };