tsichart-core 2.1.4 → 2.1.6

package/dist/index.d.ts

@@ -126,6 +126,29 @@ declare class ChartOptions {
     }>;
     stringsInstance: Strings;
     private getInterpolationFunction;
+    /**
+     * Apply adaptive heuristics to adjust chart options based on data characteristics.
+     * This method is called by chart components after data is available to optimize UX.
+     *
+     * @param dataContext - Information about the data being visualized
+     * @param dataContext.seriesCount - Number of series/aggregates in the data
+     * @param dataContext.totalDataPoints - Total number of data points across all series
+     * @param dataContext.hasEnvelope - Whether data contains min/max envelope information
+     * @param dataContext.hasUniformInterval - Whether timestamps are uniformly spaced
+     * @param dataContext.chartType - Type of chart ('line', 'bar', 'scatter', etc.)
+     */
+    applyAdaptiveHeuristics(dataContext?: {
+        seriesCount?: number;
+        totalDataPoints?: number;
+        hasEnvelope?: boolean;
+        hasUniformInterval?: boolean;
+        chartType?: string;
+    }): void;
+    /**
+     * Derive 24-hour time format preference from locale.
+     * Used internally when is24HourTime is not explicitly set.
+     */
+    private deriveTimeFormatFromLocale;
     setOptions(chartOptionsObj: any): void;
     private mergeStrings;
     private mergeValue;
@@ -174,7 +197,7 @@ declare class ChartOptions {
         brushHandlesVisible: boolean;
         hideChartControlPanel: boolean;
         offset: any;
-        is24HourTime: () => boolean;
+        is24HourTime: boolean;
         includeTimezones: boolean;
         availabilityLeftMargin: number;
         onInstanceClick: (instance: any) => any;
@@ -511,6 +534,7 @@ declare class LineChart extends TemporalXAxisComponent {
     private swimLaneContents;
     private originalSwimLanes;
     private originalSwimLaneOptions;
+    private _playbackMarker;
     constructor(renderTarget: Element);
     LineChart(): void;
     getBrushPositions(): {
@@ -550,6 +574,14 @@ declare class LineChart extends TemporalXAxisComponent {
     exportMarkers(): void;
     private createOnMarkerChange;
     private renderMarker;
+    /**
+     * Moves or creates a persistent playback marker at the given time.
+     * Call this on each playback tick for smooth marker movement.
+     * @param millis The timestamp (in ms) to move the marker to.
+     * @param label Optional label for the marker.
+     */
+    updatePlaybackMarker(millis: number, label?: string): void;
+    removePlaybackMarker(): void;
     private sortMarkers;
     private getAllLinesTransitionsComplete;
     private importMarkers;
@@ -588,6 +620,11 @@ declare class LineChart extends TemporalXAxisComponent {
     private overwriteSwimLanes;
     private getHorizontalMarkersWithYScales;
     private getAdditionalOffsetFromHorizontalMargin;
+    /**
+     * Calculate data context for adaptive heuristics.
+     * Analyzes current data to determine series count, data point density, and other characteristics.
+     */
+    private calculateDataContext;
     private drawHorizontalMarkers;
     private createSwimlaneLabels;
     render(data: any, options: ILineChartOptions, aggregateExpressionOptions: any): void;
@@ -620,8 +657,6 @@ declare class AvailabilityChart extends ChartComponent {
     private rawAvailability;
     private maxBuckets;
     private bucketSize;
-    private dateTimePickerContainer;
-    private dateTimePicker;
     constructor(renderTarget: Element);
     private getMinZoomedRange;
     private zoom;
@@ -796,17 +831,14 @@ declare class GroupedBarChart extends ChartVisualizationComponent {
 }
 
 declare class Grid extends Component {
+    private static readonly KEYS;
     private gridComponent;
-    private rowLabelKey;
-    private colorKey;
-    private aggIndexKey;
     private chartComponentData;
-    private draw;
     private closeButton;
     private filteredTimestamps;
+    private timestampCache;
     private table;
     private tableHeaderRow;
-    private tableContentRows;
     usesSeconds: boolean;
     usesMillis: boolean;
     constructor(renderTarget: Element);
@@ -818,15 +850,17 @@ declare class Grid extends Component {
         action: () => void;
         description: string;
     };
-    Grid(): void;
     private cellClass;
-    focus: (rowIdx: any, colIdx: any) => void;
-    renderFromAggregates(data: any, options: any, aggregateExpressionOptions: any, chartComponentData: any): void;
+    focus: (rowIdx: number, colIdx: number) => void;
+    renderFromAggregates(data: any, options: any, aggregateExpressionOptions: any, chartComponentData: ChartComponentData): void;
     private getRowData;
     private convertSeriesToGridData;
     private getFormattedDate;
+    private getRowColor;
     private setFilteredTimestamps;
     private addHeaderCells;
+    private renderRowHeader;
+    private renderValueCells;
     private addValueCells;
     render(data: any, options: any, aggregateExpressionOptions: any, chartComponentData?: ChartComponentData): void;
     private arrowNavigate;
@@ -994,13 +1028,15 @@ declare class ModelSearch extends Component {
     private currentResultIndex;
     constructor(renderTarget: Element);
     ModelSearch(): void;
-    render(environmentFqdn: string, getToken: any, hierarchyData: any, chartOptions: any): void;
+    render(hierarchyData: any, chartOptions: any): void;
     handleKeydown(event: any, ap: any): void;
     private closeContextMenu;
     private stripHits;
     private getInstanceHtml;
 }
 
+type OnSetCallback$4 = (fromMillis: number, toMillis: number, offset: string, isRelative: boolean, quickTime: number) => void;
+type OnCancelCallback$1 = () => void;
 declare class DateTimePicker extends ChartComponent {
     private calendar;
     private calendarPicker;
@@ -1024,16 +1060,38 @@ declare class DateTimePicker extends ChartComponent {
     private endRange;
     private anchorDate;
     private offsetName;
+    private dateFormatter;
     private fromInput;
     private toInput;
     private quickTimeArray;
     constructor(renderTarget: Element);
+    /**
+     * Get the currently selected quick time value
+     * @returns The quick time in milliseconds, or -1 if not a quick time selection
+     * @private
+     */
     private getCurrentQuickTime;
-    getQuickTimeText(quickTimeMillis: any): any;
+    /**
+     * Get the display text for a quick time selection
+     * @param quickTimeMillis - The quick time value in milliseconds
+     * @returns The display text, or null if not found
+     */
+    getQuickTimeText(quickTimeMillis: number): string | null;
     private convertToCalendarDate;
     private setNewOffset;
     private onSaveOrCancel;
-    render(chartOptions: any, minMillis: number, maxMillis: number, fromMillis?: number, toMillis?: number, onSet?: any, onCancel?: any): void;
+    /**
+     * Render the date/time picker with range selection
+     *
+     * @param chartOptions - Configuration options
+     * @param minMillis - Minimum selectable time
+     * @param maxMillis - Maximum selectable time
+     * @param fromMillis - Start time of range (defaults to 24 hours before maxMillis)
+     * @param toMillis - End time of range (defaults to maxMillis)
+     * @param onSet - Callback when user saves selection
+     * @param onCancel - Callback when user cancels
+     */
+    render(chartOptions: any, minMillis: number, maxMillis: number, fromMillis?: number, toMillis?: number, onSet?: OnSetCallback$4, onCancel?: OnCancelCallback$1): void;
     private updateDisplayedDateTimes;
     private setFromQuickTimes;
     private buildQuickTimesPanel;
@@ -1043,6 +1101,11 @@ declare class DateTimePicker extends ChartComponent {
     private createTimezonePicker;
     private roundDay;
     private setTimeRange;
+    /**
+     * Create and configure the Pikaday calendar component
+     * Uses the DateFormatter utility to generate locale-specific month and weekday names
+     * @private
+     */
     private createCalendar;
     private setSelectedQuickTimes;
     private setFromDate;
@@ -2358,28 +2421,88 @@ declare class HierarchyNavigation extends Component {
                 return Pikaday;
             }));
 
-declare class SingleDateTimePicker extends ChartComponent {
+type OnSetCallback$3 = (fromMillis: number, toMillis?: number, offset?: string, isRelative?: boolean, quickTime?: number) => void;
+declare class DateTimeButton extends ChartComponent {
+    protected dateTimePicker: DateTimePicker;
+    protected minMillis: number;
+    protected maxMillis: number;
+    protected onSet: OnSetCallback$3;
+    protected dateTimeButton: d3.Selection<HTMLButtonElement, unknown, null, undefined>;
+    protected dateTimePickerContainer: d3.Selection<HTMLDivElement, unknown, null, undefined>;
+    constructor(renderTarget: Element);
+    protected buttonDateTimeFormat(millis: number): string;
+    protected initializeDateTimeButton(chartOptions: any, minMillis: number, maxMillis: number, onSet?: OnSetCallback$3): void;
+    private getTimezoneFromOffset;
+}
+
+type OnSetCallback$2 = (millis: number) => void;
+declare class SingleDateTimePicker extends DateTimeButton {
     private calendar;
     private calendarPicker;
     private timeControls;
-    private minMillis;
-    private maxMillis;
+    protected minMillis: number;
+    protected maxMillis: number;
     private millis;
     private minutes;
     private hours;
-    private onSet;
+    protected onSet: OnSetCallback$2 | null;
     private targetElement;
     private isValid;
     private offsetName;
     private date;
     private timeInput;
     private saveButton;
+    private dateFormatter;
     constructor(renderTarget: Element);
+    /**
+     * Get the currently selected time in milliseconds
+     * @returns The selected time in milliseconds since epoch
+     */
     getMillis(): number;
-    render(chartOptions: any, minMillis: number, maxMillis: number, millis?: number, onSet?: any): void;
+    /**
+     * Render the single date/time picker component
+     *
+     * @param chartOptions - Configuration options for the component
+     * @param minMillis - Minimum selectable time in milliseconds
+     * @param maxMillis - Maximum selectable time in milliseconds
+     * @param millis - Initially selected time (defaults to maxMillis if null)
+     * @param onSet - Callback function invoked when user saves a selection
+     */
+    render(chartOptions: any, minMillis: number, maxMillis: number, millis?: number, onSet?: OnSetCallback$2): void;
+    /**
+     * Set up keyboard event handlers for the component
+     * Handles arrow keys and escape key navigation
+     * @private
+     */
+    private _setupEventHandlers;
+    /**
+     * Create the DOM structure for the date/time picker
+     * Includes time controls, calendar container, save button, and error message container
+     * @private
+     */
+    private _createDOM;
+    /**
+     * Round a date to midnight (zero out hours, minutes, seconds, milliseconds)
+     * Takes timezone offset into account
+     *
+     * @param d - The date to round
+     * @returns A new date at midnight in the specified timezone
+     * @private
+     */
     private roundDay;
+    /**
+     * Update the calendar and time input to reflect a newly selected date
+     *
+     * @param d - The selected date
+     * @private
+     */
     private setSelectedDate;
-    private createCalendar;
+    /**
+     * Create and configure the Pikaday calendar component
+     * Uses the DateFormatter utility to generate locale-specific month and weekday names
+     * @private
+     */
+    private _createCalendar;
     private setDate;
     private setIsValid;
     private setMillis;
@@ -2393,22 +2516,10 @@ declare class SingleDateTimePicker extends ChartComponent {
     private createTimeString;
     private convertToLocal;
     private createTimePicker;
+    private _createTimePicker;
 }
 
-declare class DateTimeButton extends ChartComponent {
-    protected dateTimePicker: any;
-    private pickerIsVisible;
-    protected minMillis: number;
-    protected maxMillis: number;
-    protected onSet: any;
-    protected dateTimeButton: any;
-    protected dateTimePickerContainer: any;
-    constructor(renderTarget: Element);
-    protected buttonDateTimeFormat(millis: any): string;
-    render(chartOptions: any, minMillis: any, maxMillis: any, onSet?: any): void;
-    private getTimezoneFromOffset;
-}
-
+type OnSetCallback$1 = (millis: number) => void;
 declare class DateTimeButtonSingle extends DateTimeButton {
     private selectedMillis;
     private clickOutsideHandler;
@@ -2417,20 +2528,63 @@ declare class DateTimeButtonSingle extends DateTimeButton {
     private removeClickOutsideHandler;
     private setupClickOutsideHandler;
     private sDTPOnSet;
-    render(chartOptions: any, minMillis: number, maxMillis: number, selectedMillis?: number, onSet?: any): void;
+    render(chartOptions: any, minMillis: number, maxMillis: number, selectedMillis?: number, onSet?: OnSetCallback$1): void;
 }
 
+type OnSetCallback = (fromMillis: number, toMillis?: number, offset?: string, isRelative?: boolean, quickTime?: number) => void;
+type OnCancelCallback = () => void;
 declare class DateTimeButtonRange extends DateTimeButton {
     private onCancel;
     private fromMillis;
     private toMillis;
     private clickOutsideHandler;
     constructor(renderTarget: Element);
+    /**
+     * Set the button text to display the selected date/time range
+     *
+     * @param fromMillis - Start time in milliseconds
+     * @param toMillis - End time in milliseconds
+     * @param isRelative - Whether this is a relative time range (e.g., "Last 24 Hours")
+     * @param quickTime - Quick time selection in milliseconds (if applicable)
+     * @private
+     */
     private setButtonText;
+    /**
+     * Close the date/time picker and return focus to the button
+     * @private
+     */
     private onClose;
+    /**
+     * Remove the click outside event handler if it exists
+     * @private
+     */
     private removeClickOutsideHandler;
+    /**
+     * Set up click outside handler to close the picker when clicking outside
+     * Uses a small delay to prevent the opening click from immediately closing the picker
+     * @private
+     */
     private setupClickOutsideHandler;
-    render(chartOptions: any, minMillis: number, maxMillis: number, fromMillis?: number, toMillis?: number, onSet?: any, onCancel?: any): void;
+    /**
+     * Render the date/time button with range selection
+     *
+     * @param chartOptions - Configuration options for the component
+     * @param minMillis - Minimum selectable time in milliseconds
+     * @param maxMillis - Maximum selectable time in milliseconds
+     * @param fromMillis - Start time of the range (defaults to 24 hours before maxMillis)
+     * @param toMillis - End time of the range (defaults to maxMillis)
+     * @param onSet - Callback invoked when user saves a selection
+     * @param onCancel - Callback invoked when user cancels
+     */
+    render(chartOptions: any, minMillis: number, maxMillis: number, fromMillis?: number, toMillis?: number, onSet?: OnSetCallback, onCancel?: OnCancelCallback): void;
+    /**
+     * Open the date/time picker in modal mode
+     *
+     * @param minMillis - Minimum selectable time
+     * @param maxMillis - Maximum selectable time
+     * @private
+     */
+    private _openPicker;
 }
 
 interface IPlaybackSettings {
@@ -2449,6 +2603,8 @@ declare class PlaybackControls extends Component {
     private playbackInterval;
     private playButton;
     private handleElement;
+    private decreasePlaybackSpeedButton;
+    private increasePlaybackSpeedButton;
     private controlsContainer;
     private track;
     private trackXOffset;
@@ -2517,25 +2673,23 @@ declare abstract class HistoryPlayback extends Component {
     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;
+    protected renderBase(data: Array<TsqExpression>, chartOptions: any): void;
     pauseAvailabilityUpdates(): void;
     private onSelecTimestamp;
+    protected getMockDataForTimestamp(timeStamp: Date): Array<any>;
     private calcQueryWindow;
     protected drawBase(): void;
     private updateAvailability;
@@ -2544,7 +2698,14 @@ declare abstract class HistoryPlayback extends Component {
 declare class ProcessGraphic extends HistoryPlayback {
     private graphicSrc;
     constructor(renderTarget: Element);
-    render(environmentFqdn: string, getToken: () => Promise<string>, graphicSrc: string, data: Array<TsqExpression>, chartOptions: any): void;
+    render(graphicSrc: string, data: Array<TsqExpression>, chartOptions: any): void;
+    private externalOnSelectTimeStamp;
+    onReady: (() => void) | null;
+    private cleanup;
+    private initializeComponent;
+    private showErrorMessage;
+    private onSelectTimestamp;
+    setDataForTimestamp(data: Array<any>): void;
     protected loadResources(): Promise<GraphicInfo>;
     protected draw(): void;
     private getResizedImageDimensions;
@@ -2586,6 +2747,7 @@ declare class ColorPicker extends Component {
 }
 
 declare class GeoProcessGraphic extends HistoryPlayback {
+    private dataSource;
     private azureMapsSubscriptionKey;
     private zoom;
     private width;
@@ -2597,14 +2759,29 @@ declare class GeoProcessGraphic extends HistoryPlayback {
     private maxZoom;
     private minZoom;
     private duration;
+    private map;
+    private tilesetId;
+    private mapContainer;
     constructor(renderTarget: Element);
-    render(environmentFqdn: string, getToken: () => Promise<string>, data: Array<TsqExpression>, chartOptions: any): void;
+    render(data: Array<TsqExpression>, chartOptions: any): void;
+    protected renderBase(data: Array<TsqExpression>, chartOptions: any): void;
+    private initializeAvaibility;
+    private cleanup;
+    private initializeComponent;
     protected loadResources(): Promise<any>;
-    protected draw(): void;
+    private loadAzureMapsScript;
+    private initializeMap;
+    private initializeMapFeatures;
+    private applyMapStyle;
+    private createVehicleMarker;
+    private getMapStyleForTileset;
+    private createMarkerHtml;
+    private renderFallback;
+    protected draw(): Promise<any>;
     protected getDataPoints(results: Array<IGeoProcessGraphicLabelInfo>): void;
-    protected parseTsqResponse(response: any): {};
+    protected parseTsqResponse(response: any): any;
     protected updateDataMarkers(dataPoints: Array<any>): void;
-    protected createTable(dataPointArr: any, idx: any): HTMLDivElement;
+    private createPopupContent;
 }
 interface IGeoProcessGraphicLabelInfo {
 }