tsichart-core 1.0.0

package/dist/LineChart.d.ts

@@ -0,0 +1,163 @@
+import { T as TemporalXAxisComponent } from './TemporalXAxisComponent-CyiM5EH0.js';
+import { C as ChartComponentData } from './ChartComponentData-D5wuQmmZ.js';
+import './ChartVisualizationComponent-DBjiqR1n.js';
+import './ChartComponent-DTcc6aED.js';
+import './Enums-ChUuTtHV.js';
+import './Component-Rp30sSAW.js';
+import './Interfaces-BKRQ685G.js';
+import './EllipsisMenu.js';
+
+declare class LineChartData extends ChartComponentData {
+    timeMap: any;
+    get yExtents(): Array<any>;
+    private _yExtents;
+    setYExtents(idx: number, value: [number, number]): void;
+    resetYExtents(): void;
+    setTimeMap(): void;
+    constructor();
+    mergeDataToDisplayStateAndTimeArrays(data: any, aggregateExpressionOptions?: any): void;
+}
+
+declare class LineChart extends TemporalXAxisComponent {
+    private targetElement;
+    private focus;
+    private horizontalValueBox;
+    private verticalValueBox;
+    private horizontalValueBar;
+    private contextMenu;
+    private brushContextMenu;
+    private setDisplayStateFromData;
+    private minBrushWidth;
+    private strokeOpacity;
+    private nonFocusStrokeOpactiy;
+    chartComponentData: LineChartData;
+    private surpressBrushTimeSet;
+    private hasStackedButton;
+    private stackedButton;
+    private visibleAggCount;
+    private swimLaneLabelGroup;
+    private horizontalLabelOffset;
+    private tooltip;
+    private height;
+    private xLowerBound;
+    private xUpperBound;
+    private y;
+    private yMap;
+    private line;
+    private areaPath;
+    private envelope;
+    private voronoi;
+    private possibleTimesArray;
+    private colorMap;
+    private markers;
+    private seriesLabelsMarker;
+    private markerGuidMap;
+    private isDroppingMarker;
+    private activeMarker;
+    private brush;
+    private brushElem;
+    brushStartTime: Date;
+    brushEndTime: Date;
+    private brushStartPosition;
+    private brushEndPosition;
+    private hasBrush;
+    private isClearingBrush;
+    private previousAggregateData;
+    private previousIncludeDots;
+    private voronoiDiagram;
+    private voronoiRegion;
+    private mx;
+    private my;
+    private focusedAggKey;
+    private focusedSplitby;
+    private plotComponents;
+    private isFirstMarkerDrop;
+    private xOffset;
+    private swimlaneYExtents;
+    private swimLaneContents;
+    private originalSwimLanes;
+    private originalSwimLaneOptions;
+    constructor(renderTarget: Element);
+    LineChart(): void;
+    getBrushPositions(): {
+        leftPos: any;
+        rightPos: any;
+    };
+    private resetValueElementsFocus;
+    private hideFocusElements;
+    private voronoiMouseout;
+    private createMarkerInstructions;
+    private destroyMarkerInstructions;
+    triggerLineFocus: (aggKey: string, splitBy: string) => void;
+    private getMouseoverFunction;
+    private getMouseoutFunction;
+    private focusOnlyHoveredSeries;
+    private discreteEventsMouseover;
+    private discreteEventsMouseout;
+    private mismatchingChartType;
+    private categoricalMouseover;
+    private categoricalMouseout;
+    private setHorizontalValuePosAndText;
+    private setVerticalValueAndPosition;
+    private voronoiMouseover;
+    private getYExtent;
+    private getFilteredValues;
+    private getFilteredAndSticky;
+    stickyOrUnstickySeries: (aggKey: any, splitBy: any) => void;
+    unstickySeries: (aggKey: any, splitby?: any) => void;
+    private stickySeries;
+    private getHandleHeight;
+    private getXPosition;
+    setBrushStartTime(startTime: any): void;
+    setBrushEndTime(endTime: any): void;
+    setBrush(): void;
+    private findClosestValidTime;
+    private getMarkerMarginLeft;
+    exportMarkers(): void;
+    private createOnMarkerChange;
+    private renderMarker;
+    private sortMarkers;
+    private getAllLinesTransitionsComplete;
+    private importMarkers;
+    private createSeriesLabelsMarker;
+    private renderSeriesLabelsMarker;
+    private renderAllMarkers;
+    private focusOnEllipsis;
+    private filteredValueExist;
+    addMarker: () => void;
+    private voronoiExists;
+    private voronoiMousemove;
+    private voronoiContextMenu;
+    private voronoiClick;
+    private getValueOfVisible;
+    private brushBrush;
+    private brushEnd;
+    private focusMarkerLabel;
+    labelMouseout: () => void;
+    labelMouseover: (aggregateKey: string, splitBy?: string) => void;
+    private drawBrushRange;
+    private getSVGLeftOffset;
+    updateBrushRange(): void;
+    deleteBrushRange(): void;
+    getYExtents(): any[];
+    private nextStackedState;
+    private clearBrush;
+    private getVisibleNumerics;
+    private getSwimlaneOffsets;
+    private setSwimLaneYExtents;
+    private getEventsCollapsedSwimlaneHeight;
+    private createYOffsets;
+    private heightNonNumeric;
+    private getGroupYExtent;
+    private getAggAxisType;
+    private adjustSwimLanes;
+    private overwriteSwimLanes;
+    private getHorizontalMarkersWithYScales;
+    private getAdditionalOffsetFromHorizontalMargin;
+    private drawHorizontalMarkers;
+    private createSwimlaneLabels;
+    render(data: any, options: any, aggregateExpressionOptions: any): void;
+    private createPlot;
+}
+
+export { LineChart as default };

package/dist/LineChart.js

@@ -0,0 +1,18 @@
+export { L as default } from './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';

package/dist/ModelAutocomplete-TRD16egq.js

@@ -0,0 +1,100 @@
+import { _ as __extends } from './_tslib-5_9pMg1F.js';
+import * as d3 from 'd3';
+import 'awesomplete';
+import { a as ChartOptions, C as Component } from './Component-CofgyEw0.js';
+import { U as Utils } from './Utils-C_j8IgZh.js';
+
+var ModelAutocomplete = /** @class */ (function (_super) {
+    __extends(ModelAutocomplete, _super);
+    function ModelAutocomplete(renderTarget) {
+        var _this = _super.call(this, renderTarget) || this;
+        _this.chartOptions = new ChartOptions(); // TODO handle onkeyup and oninput in chart options
+        return _this;
+    }
+    ModelAutocomplete.prototype.render = function (environmentFqdn, getToken, chartOptions) {
+        var _this = this;
+        this.chartOptions.setOptions(chartOptions);
+        var targetElement = d3.select(this.renderTarget);
+        targetElement.html("");
+        var wrapper = targetElement
+            .append("div")
+            .attr("class", "tsi-modelAutocompleteWrapper");
+        _super.prototype.themify.call(this, wrapper, this.chartOptions.theme);
+        var inputWrapper = wrapper.append("div").attr("class", "tsi-search");
+        inputWrapper.append("i").classed("tsi-search-icon", true);
+        var input = inputWrapper
+            .append("input")
+            .attr("class", "tsi-searchInput")
+            .attr("aria-label", this.getString("Search Time Series Instances"))
+            .attr("aria-describedby", "tsi-search-desc")
+            .attr("role", "combobox")
+            .attr("aria-owns", "tsi-search-results")
+            .attr("aria-expanded", "false")
+            .attr("aria-haspopup", "listbox")
+            .attr("placeholder", this.getString("Search Time Series Instances") + "...");
+        var clear = inputWrapper
+            .append("div")
+            .attr("class", "tsi-clear")
+            .attr("tabindex", "0")
+            .attr("role", "button")
+            .attr("aria-label", "Clear Search")
+            .on("click keydown", function (event) {
+            if (Utils.isKeyDownAndNotEnter(event)) {
+                return;
+            }
+            input.node().value = "";
+            noSuggest = true;
+            input.dispatch("input");
+            self.ap.close();
+            d3.select(this).classed("tsi-shown", false);
+        });
+        inputWrapper
+            .append("span")
+            .attr("id", "tsi-search-desc")
+            .style("display", "none")
+            .text(this.getString("Search suggestion instruction"));
+        inputWrapper
+            .append("div")
+            .attr("class", "tsi-search-results-info")
+            .attr("aria-live", "assertive");
+        var Awesomplete = window.Awesomplete;
+        this.ap = new Awesomplete(input.node(), { minChars: 1 });
+        var noSuggest = false;
+        var justAwesompleted = false;
+        input.node().addEventListener("awesomplete-selectcomplete", function (event) {
+            noSuggest = true;
+            input.dispatch("input");
+            _this.ap.close();
+            justAwesompleted = true;
+        });
+        input.on("keydown", function (event) {
+            _this.chartOptions.onKeydown(event, _this.ap);
+        });
+        input.node().addEventListener("keyup", function (event) {
+            if (justAwesompleted) {
+                justAwesompleted = false;
+                return;
+            }
+            var key = event.which || event.keyCode;
+            if (key === 13) {
+                noSuggest = true;
+                input.dispatch("input");
+            }
+        });
+        var searchText;
+        var self = this;
+        input.on("input", function (event) {
+            searchText = this.value;
+            if (searchText.replace(/ /g, "") && !noSuggest) ;
+            else {
+                self.ap.close();
+            }
+            self.chartOptions.onInput(searchText, noSuggest ? { which: 13 } : event);
+            noSuggest = false;
+            clear.classed("tsi-shown", searchText.length);
+        });
+    };
+    return ModelAutocomplete;
+}(Component));
+
+export { ModelAutocomplete as M };

package/dist/ModelAutocomplete.d.ts

@@ -0,0 +1,12 @@
+import { C as Component } from './Component-Rp30sSAW.js';
+import './Enums-ChUuTtHV.js';
+import './Interfaces-BKRQ685G.js';
+
+declare class ModelAutocomplete extends Component {
+    chartOptions: any;
+    ap: any;
+    constructor(renderTarget: Element);
+    render(environmentFqdn: string, getToken: any, chartOptions: any): void;
+}
+
+export { ModelAutocomplete as default };

package/dist/ModelAutocomplete.js

@@ -0,0 +1,7 @@
+export { M as default } from './ModelAutocomplete-TRD16egq.js';
+import './_tslib-5_9pMg1F.js';
+import 'd3';
+import 'awesomplete';
+import './Component-CofgyEw0.js';
+import './Utils-C_j8IgZh.js';
+import 'moment-timezone';

package/dist/ModelSearch-WEa7Ud20.js

@@ -0,0 +1,189 @@
+import { _ as __extends, a as __assign } from './_tslib-5_9pMg1F.js';
+import * as d3 from 'd3';
+import { U as Utils } from './Utils-C_j8IgZh.js';
+import { C as Component } from './Component-CofgyEw0.js';
+import 'awesomplete';
+import { H as Hierarchy } from './Hierarchy-QkWLHkxo.js';
+import { M as ModelAutocomplete } from './ModelAutocomplete-TRD16egq.js';
+
+var ModelSearch = /** @class */ (function (_super) {
+    __extends(ModelSearch, _super);
+    function ModelSearch(renderTarget) {
+        var _this = _super.call(this, renderTarget) || this;
+        _this.usedContinuationTokens = {};
+        _this.currentResultIndex = -1;
+        _this.stripHits = function (str) {
+            return str
+                .split("<hit>")
+                .map(function (h) {
+                return h
+                    .split("</hit>")
+                    .map(function (h2) { return Utils.strip(h2); })
+                    .join("</hit>");
+            })
+                .join("<hit>");
+        };
+        d3.select("html").on("click." + Utils.guid(), function (event) {
+            if (_this.clickedInstance &&
+                event.target != _this.clickedInstance &&
+                _this.contextMenu) {
+                _this.closeContextMenu();
+                _this.clickedInstance = null;
+            }
+        });
+        return _this;
+    }
+    ModelSearch.prototype.ModelSearch = function () { };
+    ModelSearch.prototype.render = function (environmentFqdn, getToken, hierarchyData, chartOptions) {
+        var _this = this;
+        this.chartOptions.setOptions(chartOptions);
+        var self = this;
+        var continuationToken, searchText;
+        var targetElement = d3.select(this.renderTarget);
+        targetElement.html("");
+        this.wrapper = targetElement
+            .append("div")
+            .attr("class", "tsi-modelSearchWrapper");
+        _super.prototype.themify.call(this, this.wrapper, this.chartOptions.theme);
+        var inputWrapper = this.wrapper
+            .append("div")
+            .attr("class", "tsi-modelSearchInputWrapper");
+        var autocompleteOnInput = function (st, event) {
+            self.usedContinuationTokens = {};
+            // blow results away if no text
+            if (st.length === 0) {
+                searchText = st;
+                self.instanceResults.html("");
+                self.currentResultIndex = -1;
+                hierarchyElement.node().style.display = "block";
+                showMore.node().style.display = "none";
+                noResults.style("display", "none");
+            }
+            else if (event.which === 13 || event.keyCode === 13) {
+                hierarchyElement.node().style.display = "none";
+                self.instanceResults.html("");
+                self.currentResultIndex = -1;
+                noResults.style("display", "none");
+                searchInstances();
+                searchText = st;
+            }
+        };
+        var modelAutocomplete = new ModelAutocomplete(inputWrapper.node());
+        modelAutocomplete.render(environmentFqdn, getToken, __assign({ onInput: autocompleteOnInput, onKeydown: function (event, ap) {
+                _this.handleKeydown(event, ap);
+            } }, chartOptions));
+        modelAutocomplete.ap;
+        var results = this.wrapper
+            .append("div")
+            .attr("class", "tsi-modelSearchResults")
+            .on("scroll", function () {
+            self.closeContextMenu();
+            var that = this;
+            if (that.scrollTop + that.clientHeight + 150 >
+                self.instanceResults.node().clientHeight &&
+                searchText.length !== 0) {
+                searchInstances(searchText, continuationToken);
+            }
+        });
+        var noResults = results
+            .append("div")
+            .text(this.getString("No results"))
+            .classed("tsi-noResults", true)
+            .style("display", "none");
+        var instanceResultsWrapper = results
+            .append("div")
+            .attr("class", "tsi-modelSearchInstancesWrapper");
+        this.instanceResults = instanceResultsWrapper
+            .append("div")
+            .attr("class", "tsi-modelSearchInstances");
+        var showMore = instanceResultsWrapper
+            .append("div")
+            .attr("class", "tsi-showMore")
+            .text(this.getString("Show more") + "...")
+            .on("click", function () { return searchInstances(searchText, continuationToken); })
+            .style("display", "none");
+        var hierarchyElement = this.wrapper
+            .append("div")
+            .attr("class", "tsi-hierarchyWrapper");
+        var hierarchy = new Hierarchy(hierarchyElement.node());
+        hierarchy.render(hierarchyData, __assign(__assign({}, this.chartOptions), { withContextMenu: true }));
+        var searchInstances = function (searchText, ct) {
+            if (ct === void 0) { ct = null; }
+            var self = _this;
+            if (ct === "END")
+                return;
+            if (ct === null || !self.usedContinuationTokens[ct]) {
+                self.usedContinuationTokens[ct] = true;
+            }
+        };
+        getToken().then(function (token) {
+        });
+        // get types
+        getToken().then(function (token) {
+        });
+    };
+    ModelSearch.prototype.handleKeydown = function (event, ap) {
+        if (!ap.isOpened) {
+            var results = this.instanceResults.selectAll(".tsi-modelResultWrapper");
+            if (results.size()) {
+                if (event.keyCode === 40 &&
+                    this.currentResultIndex < results.nodes().length - 1) {
+                    this.currentResultIndex++;
+                    results.nodes()[this.currentResultIndex].focus();
+                }
+                else if (event.keyCode === 38) {
+                    this.currentResultIndex--;
+                    if (this.currentResultIndex <= -1) {
+                        this.currentResultIndex = -1;
+                        ap.input.focus();
+                    }
+                    else {
+                        results.nodes()[this.currentResultIndex].focus();
+                    }
+                }
+            }
+        }
+    };
+    ModelSearch.prototype.closeContextMenu = function () {
+        if (this.contextMenu) {
+            this.contextMenu.remove();
+        }
+        d3.selectAll(".tsi-resultSelected").classed("tsi-resultSelected", false);
+    };
+    ModelSearch.prototype.getInstanceHtml = function (i) {
+        var _this = this;
+        return "<div class=\"tsi-modelResult\">\n                    <div class=\"tsi-modelPK\">\n                        ".concat(i.highlights.name
+            ? this.stripHits(i.highlights.name)
+            : this.stripHits(i.highlights.timeSeriesIds
+                ? i.highlights.timeSeriesIds.join(" ")
+                : i.highlights.timeSeriesId.join(" ")), "\n                    </div>\n                    <div class=\"tsi-modelHighlights\">\n                        ").concat(this.stripHits(i.highlights.description &&
+            i.highlights.description.length
+            ? i.highlights.description
+            : this.getString("No description")), "\n                        <br/><table>\n                        ").concat(i.highlights.name
+            ? "<tr><td>" +
+                this.getString("Time Series ID") +
+                "</td><td>" +
+                this.stripHits(i.highlights.timeSeriesIds
+                    ? i.highlights.timeSeriesIds.join(" ")
+                    : i.highlights.timeSeriesId.join(" ")) +
+                "</td></tr>"
+            : "", "                        \n                        ").concat(i.highlights.instanceFieldNames
+            .map(function (ifn, idx) {
+            var val = i.highlights.instanceFieldValues[idx];
+            if (ifn.indexOf("<hit>") !== -1 ||
+                val.indexOf("<hit>") !== -1) {
+                return val.length === 0
+                    ? ""
+                    : "<tr><td>" +
+                        _this.stripHits(ifn) +
+                        "</td><td>" +
+                        _this.stripHits(val) +
+                        "</tr>";
+            }
+        })
+            .join(""), "\n                        </table>\n                    </div>\n                </div>");
+    };
+    return ModelSearch;
+}(Component));
+
+export { ModelSearch as M };

package/dist/ModelSearch.d.ts

@@ -0,0 +1,23 @@
+import { C as Component } from './Component-Rp30sSAW.js';
+import './Enums-ChUuTtHV.js';
+import './Interfaces-BKRQ685G.js';
+
+declare class ModelSearch extends Component {
+    private hierarchies;
+    private clickedInstance;
+    private wrapper;
+    private types;
+    private instanceResults;
+    private usedContinuationTokens;
+    private contextMenu;
+    private currentResultIndex;
+    constructor(renderTarget: Element);
+    ModelSearch(): void;
+    render(environmentFqdn: string, getToken: any, hierarchyData: any, chartOptions: any): void;
+    handleKeydown(event: any, ap: any): void;
+    private closeContextMenu;
+    private stripHits;
+    private getInstanceHtml;
+}
+
+export { ModelSearch as default };

package/dist/ModelSearch.js

@@ -0,0 +1,9 @@
+export { M as default } from './ModelSearch-WEa7Ud20.js';
+import './_tslib-5_9pMg1F.js';
+import 'd3';
+import './Utils-C_j8IgZh.js';
+import 'moment-timezone';
+import './Component-CofgyEw0.js';
+import 'awesomplete';
+import './Hierarchy-QkWLHkxo.js';
+import './ModelAutocomplete-TRD16egq.js';