tsichart-core 1.0.0

package/dist/HierarchyNavigation.d.ts

@@ -0,0 +1,34 @@
+import { C as Component } from './Component-Rp30sSAW.js';
+import './Enums-ChUuTtHV.js';
+import './Interfaces-BKRQ685G.js';
+
+declare class HierarchyNavigation extends Component {
+    private searchFunction;
+    private hierarchyElem;
+    private path;
+    selectedIds: Array<string>;
+    searchEnabled: boolean;
+    private searchWrapperElem;
+    private hierarchyNavWrapper;
+    ap: any;
+    constructor(renderTarget: Element);
+    render(searchF: Function, hierarchyNavOptions: any, preselectedIds: Array<string>): Promise<void>;
+    private createHierarchyNavWrapper;
+    private createResultsWrapper;
+    private createHierarchyElem;
+    private requestPayload;
+    private renderTree;
+    private renderSearchBox;
+    private pathSearchAndRenderResult;
+    private renderSearchResult;
+    private filterTree;
+    private fillDataRecursively;
+    private createHierarchyItemElem;
+    private getAriaLabel;
+    private hierarchyNodeIdentifier;
+    private instanceNodeIdentifier;
+    private instanceNodeStringToDisplay;
+    private instanceNodeString;
+}
+
+export { HierarchyNavigation as default };

package/dist/HierarchyNavigation.js

@@ -0,0 +1,6 @@
+export { H as default } from './HierarchyNavigation-CR6YUilh.js';
+import './_tslib-5_9pMg1F.js';
+import 'd3';
+import './Utils-C_j8IgZh.js';
+import 'moment-timezone';
+import './Component-CofgyEw0.js';

package/dist/HistoryPlayback-BmA-54lT.d.ts

@@ -0,0 +1,68 @@
+import * as d3 from 'd3';
+import { C as Component } from './Component-Rp30sSAW.js';
+import TsqExpression from './TsqExpression.js';
+import PlaybackControls from './PlaybackControls.js';
+
+declare class TsqRange {
+    from: Date;
+    to: Date;
+    private bucketSizeMs;
+    static NeatIntervals: string[];
+    static NeatIntervalsMs: number[];
+    constructor(from: Date, to: Date);
+    setNeatBucketSizeByNumerOfBuckets(targetNumberOfBuckets: number): void;
+    setNeatBucketSizeByRoughBucketSize(roughBucketSizeMillis: number): void;
+    alignWithServerEpoch(): void;
+    get fromMillis(): number;
+    get toMillis(): number;
+    get bucketSizeMillis(): number;
+    get bucketSizeStr(): string;
+    static millisToLargestUnit(interval: number): {
+        value: number;
+        unit: string;
+    };
+}
+
+type d3Selection = d3.Selection<d3.BaseType, unknown, null, undefined>;
+interface GraphicInfo {
+    graphic: any;
+    width: number;
+    height: number;
+}
+declare abstract class HistoryPlayback extends Component {
+    protected targetElement: d3Selection;
+    protected tsqExpressions: Array<TsqExpression>;
+    protected componentContainer: d3Selection;
+    protected component: d3Selection;
+    protected playbackControlsContainer: d3Selection;
+    protected playbackControls: PlaybackControls;
+    protected graphicOriginalWidth: number;
+    protected graphicOriginalHeight: number;
+    protected currentCancelTrigger: Function;
+    protected availabilityInterval: number;
+    protected environmentFqdn: string;
+    protected availability: TsqRange;
+    protected getAuthToken: () => Promise<string>;
+    protected playbackRate: number;
+    protected graphic: any;
+    readonly numberOfBuckets = 1000;
+    readonly defaultPlaybackRate = 3000;
+    readonly fetchAvailabilityFrequency = 30000;
+    readonly playbackSliderHeight = 88;
+    readonly previewApiFlag = "?api-version=2018-11-01-preview";
+    constructor(renderTarget: Element);
+    protected abstract loadResources(): Promise<any>;
+    protected abstract draw(): any;
+    protected abstract updateDataMarkers(data: Array<any>): void;
+    protected abstract getDataPoints(data: Array<any>): void;
+    protected onGraphicLoaded(): void;
+    protected renderBase(environmentFqdn: string, getToken: () => Promise<string>, data: Array<TsqExpression>, chartOptions: any): void;
+    pauseAvailabilityUpdates(): void;
+    private onSelecTimestamp;
+    private calcQueryWindow;
+    protected drawBase(): void;
+    private updateAvailability;
+}
+
+export { HistoryPlayback as H };
+export type { GraphicInfo as G };

package/dist/HistoryPlayback-SjeQbAPq.js

@@ -0,0 +1,175 @@
+import { _ as __extends } from './_tslib-5_9pMg1F.js';
+import { C as Component } from './Component-CofgyEw0.js';
+import { U as Utils } from './Utils-C_j8IgZh.js';
+
+var TsqRange = /** @class */ (function () {
+    function TsqRange(from, to) {
+        this.from = from;
+        this.to = to;
+    }
+    TsqRange.prototype.setNeatBucketSizeByNumerOfBuckets = function (targetNumberOfBuckets) {
+        var timeRangeMs = Math.max(this.to.valueOf() - this.from.valueOf(), 1);
+        var roughBucketsize = Math.ceil(timeRangeMs / targetNumberOfBuckets);
+        this.setNeatBucketSizeByRoughBucketSize(roughBucketsize);
+    };
+    TsqRange.prototype.setNeatBucketSizeByRoughBucketSize = function (roughBucketSizeMillis) {
+        var neatIntervalIndex = 1;
+        for (; neatIntervalIndex < TsqRange.NeatIntervalsMs.length; neatIntervalIndex++) {
+            if (TsqRange.NeatIntervalsMs[neatIntervalIndex] > roughBucketSizeMillis) {
+                break;
+            }
+        }
+        this.bucketSizeMs = TsqRange.NeatIntervalsMs[neatIntervalIndex - 1];
+    };
+    TsqRange.prototype.alignWithServerEpoch = function () {
+        var fromMs = Utils.adjustStartMillisToAbsoluteZero(this.from.valueOf(), this.bucketSizeMs);
+        var toMs = Utils.roundToMillis(this.to.valueOf(), this.bucketSizeMs);
+        this.from = new Date(fromMs);
+        this.to = new Date(toMs);
+    };
+    Object.defineProperty(TsqRange.prototype, "fromMillis", {
+        get: function () {
+            return this.from.valueOf();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TsqRange.prototype, "toMillis", {
+        get: function () {
+            return this.to.valueOf();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TsqRange.prototype, "bucketSizeMillis", {
+        get: function () {
+            return this.bucketSizeMs;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TsqRange.prototype, "bucketSizeStr", {
+        get: function () {
+            var bucketSize = TsqRange.millisToLargestUnit(this.bucketSizeMs);
+            return "".concat(bucketSize.value).concat(bucketSize.unit);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TsqRange.millisToLargestUnit = function (interval) {
+        var value, unit;
+        if (interval < 1000) {
+            value = interval;
+            unit = 'ms';
+        }
+        else if (interval < 1000 * 60) {
+            value = Math.ceil(interval / 1000);
+            unit = 's';
+        }
+        else if (interval < 1000 * 60 * 60) {
+            value = Math.ceil(interval / (1000 * 60));
+            unit = 'm';
+        }
+        else if (interval < 1000 * 60 * 60 * 24) {
+            value = Math.ceil(interval / (1000 * 60 * 60));
+            unit = 'h';
+        }
+        else {
+            value = Math.ceil(interval / (1000 * 60 * 60 * 24));
+            unit = 'd';
+        }
+        return { value: value, unit: unit };
+    };
+    // List of interval values that would divide a time range neatly
+    TsqRange.NeatIntervals = [
+        '1ms', '2ms', '4ms', '5ms', '8ms', '10ms', '20ms', '25ms', '40ms', '50ms', '100ms', '125ms', '200ms', '250ms', '500ms',
+        '1s', '2s', '3s', '4s', '5s', '6s', '10s', '12s', '15s', '20s', '30s',
+        '1m', '2m', '3m', '4m', '5m', '6m', '10m', '12m', '15m', '20m', '30m',
+        '1h', '2h', '3h', '4h', '6h', '8h', '12h',
+        '1d', '2d', '3d', '4d', '5d', '6d', '7d'
+    ];
+    TsqRange.NeatIntervalsMs = [
+        1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 125, 200, 250, 500,
+        1000, 2000, 3000, 4000, 5000, 6000, 10000, 12000, 15000, 20000, 30000,
+        60000, 120000, 180000, 240000, 300000, 360000, 600000, 720000, 900000, 1200000, 1800000,
+        3600000, 7200000, 10800000, 14400000, 21600000, 28800000, 43200000,
+        86400000, 172800000, 259200000, 345600000, 432000000, 518400000, 604800000
+    ];
+    return TsqRange;
+}());
+
+var HistoryPlayback = /** @class */ (function (_super) {
+    __extends(HistoryPlayback, _super);
+    function HistoryPlayback(renderTarget) {
+        var _this = _super.call(this, renderTarget) || this;
+        _this.numberOfBuckets = 1000;
+        _this.defaultPlaybackRate = 3000; // 3 seconds
+        _this.fetchAvailabilityFrequency = 30000; // 30 seconds
+        _this.playbackSliderHeight = 88;
+        _this.previewApiFlag = "?api-version=2018-11-01-preview";
+        _this.currentCancelTrigger = null;
+        return _this;
+    }
+    HistoryPlayback.prototype.onGraphicLoaded = function () { };
+    HistoryPlayback.prototype.renderBase = function (environmentFqdn, getToken, data, chartOptions) {
+        this.environmentFqdn = environmentFqdn;
+        this.getAuthToken = getToken;
+        this.tsqExpressions = data;
+        this.chartOptions.setOptions(chartOptions);
+        this.playbackRate =
+            this.chartOptions.updateInterval || this.defaultPlaybackRate;
+    };
+    HistoryPlayback.prototype.pauseAvailabilityUpdates = function () {
+        if (this.availabilityInterval) {
+            window.clearInterval(this.availabilityInterval);
+        }
+    };
+    HistoryPlayback.prototype.onSelecTimestamp = function (timeStamp) {
+        var queryWindow = this.calcQueryWindow(timeStamp);
+        this.tsqExpressions.map(function (tsqExpression) {
+            tsqExpression.searchSpan = {
+                from: queryWindow.fromMillis,
+                to: queryWindow.toMillis,
+                bucketSize: queryWindow.bucketSize,
+            };
+            return tsqExpression.toTsq();
+        });
+        this.getAuthToken().then(function (authToken) {
+        });
+    };
+    HistoryPlayback.prototype.calcQueryWindow = function (timeStamp) {
+        var timelineOffset = this.availability.fromMillis;
+        var queryToMillis = Math.ceil((timeStamp.valueOf() - timelineOffset) /
+            this.availability.bucketSizeMillis) *
+            this.availability.bucketSizeMillis +
+            timelineOffset;
+        return {
+            fromMillis: queryToMillis - this.availability.bucketSizeMillis,
+            toMillis: queryToMillis,
+            bucketSize: this.availability.bucketSizeStr,
+        };
+    };
+    HistoryPlayback.prototype.drawBase = function () {
+        this.playbackControlsContainer
+            .style("width", "".concat(this.renderTarget.clientWidth, "px"))
+            .style("height", "".concat(this.playbackSliderHeight, "px"));
+        this.playbackControls.render(this.availability.from, this.availability.to, this.onSelecTimestamp.bind(this), this.chartOptions, {
+            intervalMillis: this.playbackRate,
+            stepSizeMillis: this.availability.bucketSizeMillis,
+        });
+    };
+    HistoryPlayback.prototype.updateAvailability = function (from, to) {
+        this.availability = new TsqRange(from, to);
+        if (this.chartOptions.bucketSizeMillis &&
+            this.chartOptions.bucketSizeMillis > 0) {
+            this.availability.setNeatBucketSizeByRoughBucketSize(this.chartOptions.bucketSizeMillis);
+        }
+        else {
+            this.availability.setNeatBucketSizeByNumerOfBuckets(this.numberOfBuckets);
+        }
+        this.availability.alignWithServerEpoch();
+    };
+    return HistoryPlayback;
+}(Component));
+
+export { HistoryPlayback as H };

package/dist/Interfaces-BKRQ685G.d.ts

@@ -0,0 +1,6 @@
+interface HorizontalMarker {
+    color: string;
+    value: number;
+}
+
+export type { HorizontalMarker as H };