scichart-engine 0.4.1

package/dist/core/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Core module exports
+ */
+export { createChart, type Chart, type ChartOptions, type ExportOptions } from './Chart';
+export { Series } from './Series';
+export { EventEmitter } from './EventEmitter';
+export { OverlayRenderer } from './OverlayRenderer';
+export { InteractionManager } from './InteractionManager';
+export * from './annotations';

package/dist/core/series/Series.d.ts

@@ -0,0 +1,52 @@
+import { SeriesOptions, SeriesData, SeriesStyle, SeriesUpdateData, Bounds, SeriesType, HeatmapOptions, HeatmapData, HeatmapStyle } from '../../types';
+
+export declare class Series {
+    private id;
+    private type;
+    private yAxisId?;
+    private data;
+    private style;
+    private visible;
+    private name?;
+    private stackId?;
+    private cycle?;
+    private maxPoints?;
+    bullishCount: number;
+    bearishCount: number;
+    private heatmapData?;
+    private heatmapStyle?;
+    private lastAppendCount;
+    private cachedBounds;
+    private boundsNeedsUpdate;
+    private _needsBufferUpdate;
+    private smoothedData;
+    private smoothingNeedsUpdate;
+    constructor(options: SeriesOptions | HeatmapOptions);
+    getId: () => string;
+    getName: () => string;
+    getType: () => SeriesType;
+    getYAxisId: () => string | undefined;
+    getStackId: () => string | undefined;
+    getVisible: () => boolean;
+    isVisible: () => boolean;
+    getStyle: () => SeriesStyle;
+    getHeatmapData: () => HeatmapData | undefined;
+    getHeatmapStyle: () => HeatmapStyle | undefined;
+    getCycle: () => number | undefined;
+    getPointCount: () => number;
+    getLastAppendCount: () => number;
+    resetLastAppendCount: () => void;
+    hasErrorData: () => boolean;
+    getYError: (i: number) => [number, number] | null;
+    getXError: (i: number) => [number, number] | null;
+    getData(): SeriesData;
+    getBounds(): Bounds | null;
+    updateData(update: SeriesUpdateData): void;
+    setStyle(style: Partial<SeriesStyle>): void;
+    setType(type: SeriesType): void;
+    setVisible(visible: boolean): void;
+    get needsBufferUpdate(): boolean;
+    set needsBufferUpdate(val: boolean);
+    setMaxPoints(maxPoints: number | undefined): void;
+    destroy(): void;
+}

package/dist/core/series/SeriesBounds.d.ts

@@ -0,0 +1,3 @@
+import { SeriesData, Bounds, SeriesType, HeatmapData } from '../../types';
+
+export declare function calculateSeriesBounds(type: SeriesType, data: SeriesData, heatmapData?: HeatmapData): Bounds;

package/dist/core/series/SeriesDataUtils.d.ts

@@ -0,0 +1,7 @@
+import { SeriesData } from '../../types';
+
+export declare function ensureTypedArray(data: Float32Array | Float64Array | number[] | undefined): Float32Array | Float64Array;
+export declare function appendTypedArray(existing: Float32Array | Float64Array, newData: Float32Array | Float64Array): Float32Array | Float64Array;
+export declare function applySmoothing(data: SeriesData, windowSize: number): SeriesData;
+export declare function getYError(data: SeriesData, i: number): [number, number] | null;
+export declare function getXError(data: SeriesData, i: number): [number, number] | null;

package/dist/core/series/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Series Barrel Export
+ */
+export * from './Series';
+export * from './SeriesBounds';
+export * from './SeriesDataUtils';

package/dist/core/tooltip/TooltipManager.d.ts

@@ -0,0 +1,203 @@
+import { PlotArea, Bounds } from '../../types';
+import { Scale } from '../../scales';
+import { Series } from '../Series';
+import { TooltipData, TooltipOptions, TooltipTheme, TooltipTemplate, ShowTooltipOptions, TooltipEventMap } from './types';
+import { ChartTheme } from '../../theme';
+
+export interface TooltipManagerConfig {
+    /** Canvas 2D context for rendering */
+    overlayCtx: CanvasRenderingContext2D;
+    /** Chart theme (for auto-selecting tooltip theme) */
+    chartTheme: ChartTheme;
+    /** Function to get current plot area */
+    getPlotArea: () => PlotArea;
+    /** Function to get all series */
+    getSeries: () => Series[];
+    /** Function to convert pixel X to data X */
+    pixelToDataX: (px: number) => number;
+    /** Function to convert pixel Y to data Y */
+    pixelToDataY: (py: number) => number;
+    /** Function to get X scale */
+    getXScale: () => Scale;
+    /** Function to get Y scales */
+    getYScales: () => Map<string, Scale>;
+    /** Function to get view bounds */
+    getViewBounds: () => Bounds;
+    /** Initial options */
+    options?: TooltipOptions;
+}
+export declare class TooltipManager {
+    private ctx;
+    private getPlotArea;
+    private getSeries;
+    private pixelToDataX;
+    private pixelToDataY;
+    private getXScale;
+    private getYScales;
+    private options;
+    private theme;
+    private positioner;
+    private renderer;
+    private templates;
+    private events;
+    private activeTooltips;
+    private tooltipIdCounter;
+    private showTimeoutId;
+    private hideTimeoutId;
+    private lastCursorX;
+    private lastCursorY;
+    private hoveredSeriesId;
+    private hoveredDataIndex;
+    private cachedNearestResult;
+    private snapMode;
+    private largeDatasetThreshold;
+    private lastKnownDataSize;
+    private hysteresisRatio;
+    constructor(config: TooltipManagerConfig);
+    /**
+     * Register built-in templates
+     */
+    private registerBuiltinTemplates;
+    /**
+     * Configure tooltip options
+     */
+    configure(options: TooltipOptions): void;
+    /**
+     * Get current options
+     */
+    getOptions(): TooltipOptions;
+    /**
+     * Enable/disable tooltips
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if tooltips are enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Set tooltip theme
+     */
+    setTheme(theme: TooltipTheme | string): void;
+    /**
+     * Update theme based on chart theme
+     */
+    updateChartTheme(chartTheme: ChartTheme): void;
+    /**
+     * Get current theme
+     */
+    getTheme(): TooltipTheme;
+    /**
+     * Register a custom template
+     */
+    registerTemplate<T extends TooltipData>(template: TooltipTemplate<T>): void;
+    /**
+     * Get a template by ID
+     */
+    getTemplate(id: string): TooltipTemplate<TooltipData> | undefined;
+    /**
+     * Handle cursor movement - main entry point for hover detection
+     * Optimized with hysteresis to prevent jumping between nearby points
+     */
+    handleCursorMove(pixelX: number, pixelY: number): void;
+    /**
+     * Handle cursor leave
+     */
+    handleCursorLeave(): void;
+    /**
+     * Get total number of data points across all visible series
+     */
+    private getTotalDataPoints;
+    /**
+     * Determine the effective snap mode based on configuration and data size
+     */
+    private getEffectiveSnapMode;
+    /**
+     * Perform tooltip update with hysteresis to prevent jumping.
+     * The tooltip "sticks" to the current point unless the cursor is
+     * significantly closer to a new point.
+     */
+    private performTooltipUpdateWithHysteresis;
+    /**
+     * Handle heatmap and crosshair tooltip types (fallback)
+     */
+    private performFallbackTooltipUpdate;
+    /**
+     * Find data point by X coordinate only (O(log n) - fastest method)
+     * Best for very large datasets where precision is less important than speed
+     */
+    private findDataPointByXOnly;
+    /**
+     * Optimized nearest data point finder
+     */
+    private findNearestDataPointOptimized;
+    /**
+     * Find heatmap cell under cursor
+     */
+    private findHeatmapCell;
+    /**
+     * Binary search for closest value
+     */
+    private binarySearchClosest;
+    /**
+     * Build crosshair tooltip data
+     */
+    private buildCrosshairTooltip;
+    /**
+     * Schedule showing a tooltip
+     */
+    private scheduleShow;
+    /**
+     * Schedule hiding tooltips
+     */
+    private scheduleHide;
+    private clearShowTimeout;
+    private clearHideTimeout;
+    /**
+     * Show a tooltip with the given data
+     */
+    private showTooltip;
+    /**
+     * Update tooltip position
+     */
+    private updateTooltipPosition;
+    /**
+     * Get template ID for a tooltip type
+     */
+    private getTemplateIdForType;
+    /**
+     * Show a tooltip programmatically
+     */
+    show(data: TooltipData, options?: ShowTooltipOptions): string;
+    /**
+     * Hide a specific tooltip
+     */
+    hide(tooltipId: string): void;
+    /**
+     * Hide all tooltips immediately
+     */
+    hideAll(): void;
+    /**
+     * Render all active tooltips
+     */
+    render(): void;
+    /**
+     * Check if any tooltip is currently visible
+     */
+    hasActiveTooltip(): boolean;
+    /**
+     * Subscribe to tooltip events
+     */
+    on<K extends keyof TooltipEventMap>(event: K, handler: (data: TooltipEventMap[K]) => void): void;
+    /**
+     * Unsubscribe from tooltip events
+     */
+    off<K extends keyof TooltipEventMap>(event: K, handler: (data: TooltipEventMap[K]) => void): void;
+    /**
+     * Destroy the tooltip manager
+     */
+    destroy(): void;
+}
+/**
+ * Create a tooltip manager
+ */
+export declare function createTooltipManager(config: TooltipManagerConfig): TooltipManager;

package/dist/core/tooltip/TooltipPositioner.d.ts

@@ -0,0 +1,83 @@
+import { PlotArea } from '../../types';
+import { TooltipPosition, TooltipMeasurement, TooltipPlacement } from './types';
+
+export interface PositionerConfig {
+    /** Offset from target point */
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** Preferred placement */
+    preferredPosition: TooltipPlacement;
+    /** Keep within plot area */
+    constrainToPlotArea: boolean;
+    /** Keep within container */
+    constrainToContainer: boolean;
+    /** Flip if not enough space */
+    autoFlip: boolean;
+    /** Show arrow pointing to target */
+    showArrow: boolean;
+    /** Arrow size */
+    arrowSize: number;
+}
+export declare const DEFAULT_POSITIONER_CONFIG: PositionerConfig;
+/**
+ * TooltipPositioner calculates optimal tooltip positions
+ */
+export declare class TooltipPositioner {
+    private config;
+    private containerWidth;
+    private containerHeight;
+    private plotArea;
+    constructor(config?: Partial<PositionerConfig>);
+    /**
+     * Update container dimensions
+     */
+    setContainerSize(width: number, height: number): void;
+    /**
+     * Update plot area bounds
+     */
+    setPlotArea(plotArea: PlotArea): void;
+    /**
+     * Update configuration
+     */
+    configure(config: Partial<PositionerConfig>): void;
+    /**
+     * Calculate optimal tooltip position
+     *
+     * @param targetX - Target X coordinate (where tooltip points to)
+     * @param targetY - Target Y coordinate
+     * @param measurement - Tooltip dimensions
+     * @returns Calculated position with arrow configuration
+     */
+    calculatePosition(targetX: number, targetY: number, measurement: TooltipMeasurement): TooltipPosition;
+    /**
+     * Determine best position based on available space
+     */
+    private determinePosition;
+    /**
+     * Calculate tooltip coordinates for a given position
+     */
+    private calculateCoordinates;
+    /**
+     * Get the opposite position for flipping
+     */
+    private flipPosition;
+    /**
+     * Check if tooltip fits within bounds
+     */
+    private fitsInBounds;
+    /**
+     * Constrain position to stay within bounds
+     */
+    private constrainToBounds;
+    /**
+     * Get the bounds to constrain tooltip within
+     */
+    private getConstraintBounds;
+    /**
+     * Calculate position for crosshair tooltip (follows cursor vertically)
+     */
+    calculateCrosshairPosition(cursorX: number, cursorY: number, measurement: TooltipMeasurement): TooltipPosition;
+}
+export declare function createTooltipPositioner(config?: Partial<PositionerConfig>): TooltipPositioner;

package/dist/core/tooltip/TooltipRenderer.d.ts

@@ -0,0 +1,64 @@
+import { TooltipData, TooltipPosition, TooltipTheme, TooltipTemplate } from './types';
+
+/**
+ * TooltipRenderer handles all Canvas 2D rendering for tooltips
+ */
+export declare class TooltipRenderer {
+    private ctx;
+    private theme;
+    constructor(ctx: CanvasRenderingContext2D, theme: TooltipTheme);
+    /**
+     * Update the theme
+     */
+    setTheme(theme: TooltipTheme): void;
+    /**
+     * Render a tooltip with the given template
+     */
+    render<T extends TooltipData>(data: T, position: TooltipPosition, template: TooltipTemplate<T>): void;
+    /**
+     * Draw tooltip background with all effects
+     */
+    private drawBackground;
+    /**
+     * Draw arrow pointing to target
+     */
+    private drawArrow;
+    /**
+     * Draw a rounded rectangle path
+     */
+    private roundRect;
+    /**
+     * Draw a horizontal separator line
+     */
+    drawSeparator(x: number, y: number, width: number): void;
+    /**
+     * Draw a series color indicator (small circle or square)
+     */
+    drawSeriesIndicator(x: number, y: number, color: string): void;
+    /**
+     * Measure text width
+     */
+    measureText(text: string, fontSize: number, fontWeight?: number | string): number;
+    /**
+     * Draw text with theme styling
+     */
+    drawText(text: string, x: number, y: number, options?: {
+        fontSize?: number;
+        fontWeight?: number | string;
+        color?: string;
+        align?: CanvasTextAlign;
+        baseline?: CanvasTextBaseline;
+    }): void;
+    /**
+     * Draw a label-value pair
+     */
+    drawLabelValue(x: number, y: number, label: string, value: string, maxWidth: number): void;
+    /**
+     * Get theme for external use
+     */
+    getTheme(): TooltipTheme;
+}
+/**
+ * Create a tooltip renderer
+ */
+export declare function createTooltipRenderer(ctx: CanvasRenderingContext2D, theme: TooltipTheme): TooltipRenderer;

package/dist/core/tooltip/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tooltip System - High-performance, customizable tooltips for SciChart Engine
+ *
+ * This module provides a comprehensive tooltip system with:
+ * - Multiple tooltip types (datapoint, crosshair, heatmap, etc.)
+ * - Customizable templates
+ * - Beautiful predefined themes
+ * - Smooth animations
+ * - Optimal performance
+ *
+ * @module tooltip
+ */
+export type { TooltipType, TooltipData, DataPointTooltip, CrosshairTooltip, CrosshairSeriesValue, RangeTooltip, RangeStatistics, AnnotationTooltip, HeatmapTooltip, AxisTooltip, ArrowPosition, TooltipPlacement, TooltipPosition, TooltipMeasurement, TooltipTheme, TooltipShadow, TooltipOptions, DataPointTooltipOptions, CrosshairTooltipOptions, RangeTooltipOptions, AnnotationTooltipOptions, HeatmapTooltipOptions, TooltipFormatter, TooltipFormattedContent, TooltipLine, TooltipTemplate, TooltipEventMap, TooltipShowEvent, TooltipHideEvent, TooltipVisibilityEvent, TooltipUpdateEvent, TooltipMoveEvent, ShowTooltipOptions } from './types';
+export { TOOLTIP_DARK_THEME, TOOLTIP_LIGHT_THEME, TOOLTIP_GLASS_THEME, TOOLTIP_MIDNIGHT_THEME, TOOLTIP_ELECTROCHEM_THEME, TOOLTIP_NEON_THEME, TOOLTIP_MINIMAL_THEME, DEFAULT_TOOLTIP_THEME, TOOLTIP_THEMES, getTooltipTheme, createTooltipTheme, getTooltipThemeForChartTheme, type TooltipThemeName } from './themes';
+export { TooltipPositioner, createTooltipPositioner, DEFAULT_POSITIONER_CONFIG, type PositionerConfig } from './TooltipPositioner';
+export { TooltipRenderer, createTooltipRenderer } from './TooltipRenderer';
+export { TooltipManager, createTooltipManager, type TooltipManagerConfig } from './TooltipManager';
+export { DefaultTooltipTemplate, MinimalTooltipTemplate, CrosshairTooltipTemplate, HeatmapTooltipTemplate, ScientificTooltipTemplate, defaultTooltipTemplate, minimalTooltipTemplate, crosshairTooltipTemplate, heatmapTooltipTemplate, scientificTooltipTemplate, BUILTIN_TEMPLATES, getBuiltinTemplate, getDefaultTemplateForType, type BuiltinTemplateId } from './templates';

package/dist/core/tooltip/templates/AnnotationTemplate.d.ts

@@ -0,0 +1,18 @@
+import { AnnotationTooltip, TooltipTemplate, TooltipMeasurement, TooltipPosition, TooltipTheme, TooltipType } from '../types';
+
+export declare class AnnotationTooltipTemplate implements TooltipTemplate<AnnotationTooltip> {
+    readonly id = "annotation";
+    readonly name = "Annotation Info";
+    readonly supportedTypes: TooltipType[];
+    private cachedKey;
+    private cachedMeasurement;
+    /**
+     * Measure tooltip dimensions
+     */
+    measure(ctx: CanvasRenderingContext2D, data: AnnotationTooltip, theme: TooltipTheme): TooltipMeasurement;
+    /**
+     * Render the tooltip
+     */
+    render(ctx: CanvasRenderingContext2D, data: AnnotationTooltip, position: TooltipPosition, theme: TooltipTheme): void;
+}
+export declare const annotationTooltipTemplate: AnnotationTooltipTemplate;

package/dist/core/tooltip/templates/CrosshairTemplate.d.ts

@@ -0,0 +1,30 @@
+import { CrosshairTooltip, TooltipTemplate, TooltipMeasurement, TooltipPosition, TooltipTheme, TooltipType } from '../types';
+
+/**
+ * Crosshair Multi-Series Template
+ *
+ * Visual layout:
+ * ┌──────────────────────────────────╮
+ * │  ⌖ X = 0.234                     │
+ * ├──────────────────────────────────┤
+ * │  ● Forward:   45.67 µA           │
+ * │  ● Reverse:  -32.10 µA           │
+ * │  ○ Baseline:   0.05 µA           │
+ * ╰──────────────────────────────────╯
+ */
+export declare class CrosshairTooltipTemplate implements TooltipTemplate<CrosshairTooltip> {
+    readonly id = "crosshair";
+    readonly name = "Multi-Series Crosshair";
+    readonly supportedTypes: TooltipType[];
+    private cachedKey;
+    private cachedMeasurement;
+    /**
+     * Measure tooltip dimensions
+     */
+    measure(ctx: CanvasRenderingContext2D, data: CrosshairTooltip, theme: TooltipTheme): TooltipMeasurement;
+    /**
+     * Render the tooltip
+     */
+    render(ctx: CanvasRenderingContext2D, data: CrosshairTooltip, position: TooltipPosition, theme: TooltipTheme): void;
+}
+export declare const crosshairTooltipTemplate: CrosshairTooltipTemplate;

package/dist/core/tooltip/templates/DefaultTemplate.d.ts

@@ -0,0 +1,30 @@
+import { DataPointTooltip, TooltipTemplate, TooltipMeasurement, TooltipPosition, TooltipTheme, TooltipType } from '../types';
+
+/**
+ * Default Data Point Template
+ *
+ * Visual layout:
+ * ┌──────────────────────────┐
+ * │  ● Series Name           │
+ * │  ─────────────────────── │
+ * │  X:   0.500              │
+ * │  Y:   1.234              │
+ * │  ± Error: 0.05           │
+ * └──────────────────────────┘
+ */
+export declare class DefaultTooltipTemplate implements TooltipTemplate<DataPointTooltip> {
+    readonly id = "default";
+    readonly name = "Default Data Point";
+    readonly supportedTypes: TooltipType[];
+    private cachedKey;
+    private cachedMeasurement;
+    /**
+     * Measure tooltip dimensions
+     */
+    measure(ctx: CanvasRenderingContext2D, data: DataPointTooltip, theme: TooltipTheme): TooltipMeasurement;
+    /**
+     * Render the tooltip
+     */
+    render(ctx: CanvasRenderingContext2D, data: DataPointTooltip, position: TooltipPosition, theme: TooltipTheme): void;
+}
+export declare const defaultTooltipTemplate: DefaultTooltipTemplate;

package/dist/core/tooltip/templates/HeatmapTemplate.d.ts

@@ -0,0 +1,34 @@
+import { HeatmapTooltip, TooltipTemplate, TooltipMeasurement, TooltipPosition, TooltipTheme, TooltipType } from '../types';
+
+/**
+ * Heatmap Template
+ *
+ * Visual layout:
+ * ┌────────────────────────────╮
+ * │  Grid [45, 128]            │
+ * │  ──────────────────────────│
+ * │  ████ Value: 0.847         │
+ * │       Min: 0.0 Max: 1.0    │
+ * │                            │
+ * │  X: 100.0 Hz               │
+ * │  Y: 2.50 s                 │
+ * ╰────────────────────────────╯
+ */
+export declare class HeatmapTooltipTemplate implements TooltipTemplate<HeatmapTooltip> {
+    readonly id = "heatmap";
+    readonly name = "Heatmap Value";
+    readonly supportedTypes: TooltipType[];
+    private readonly swatchSize;
+    private readonly swatchGap;
+    private cachedKey;
+    private cachedMeasurement;
+    /**
+     * Measure tooltip dimensions
+     */
+    measure(ctx: CanvasRenderingContext2D, data: HeatmapTooltip, theme: TooltipTheme): TooltipMeasurement;
+    /**
+     * Render the tooltip
+     */
+    render(ctx: CanvasRenderingContext2D, data: HeatmapTooltip, position: TooltipPosition, theme: TooltipTheme): void;
+}
+export declare const heatmapTooltipTemplate: HeatmapTooltipTemplate;

package/dist/core/tooltip/templates/MinimalTemplate.d.ts

@@ -0,0 +1,26 @@
+import { DataPointTooltip, TooltipTemplate, TooltipMeasurement, TooltipPosition, TooltipTheme, TooltipType } from '../types';
+
+/**
+ * Minimal Template
+ *
+ * Visual layout:
+ * ┌───────────────────╮
+ * │ 0.500 ▪ 1.23µA    │
+ * ╰───────────────────╯
+ */
+export declare class MinimalTooltipTemplate implements TooltipTemplate<DataPointTooltip> {
+    readonly id = "minimal";
+    readonly name = "Minimal";
+    readonly supportedTypes: TooltipType[];
+    private cachedKey;
+    private cachedMeasurement;
+    /**
+     * Measure tooltip dimensions
+     */
+    measure(ctx: CanvasRenderingContext2D, data: DataPointTooltip, theme: TooltipTheme): TooltipMeasurement;
+    /**
+     * Render the tooltip
+     */
+    render(ctx: CanvasRenderingContext2D, data: DataPointTooltip, position: TooltipPosition, theme: TooltipTheme): void;
+}
+export declare const minimalTooltipTemplate: MinimalTooltipTemplate;

package/dist/core/tooltip/templates/RangeTemplate.d.ts

@@ -0,0 +1,18 @@
+import { RangeTooltip, TooltipTemplate, TooltipMeasurement, TooltipPosition, TooltipTheme, TooltipType } from '../types';
+
+export declare class RangeTooltipTemplate implements TooltipTemplate<RangeTooltip> {
+    readonly id = "range";
+    readonly name = "Range Statistics";
+    readonly supportedTypes: TooltipType[];
+    private cachedKey;
+    private cachedMeasurement;
+    /**
+     * Measure tooltip dimensions
+     */
+    measure(ctx: CanvasRenderingContext2D, data: RangeTooltip, theme: TooltipTheme): TooltipMeasurement;
+    /**
+     * Render the tooltip
+     */
+    render(ctx: CanvasRenderingContext2D, data: RangeTooltip, position: TooltipPosition, theme: TooltipTheme): void;
+}
+export declare const rangeTooltipTemplate: RangeTooltipTemplate;

package/dist/core/tooltip/templates/ScientificTemplate.d.ts

@@ -0,0 +1,34 @@
+import { DataPointTooltip, TooltipTemplate, TooltipMeasurement, TooltipPosition, TooltipTheme, TooltipType } from '../types';
+
+/**
+ * Format with SI prefix (for future use)
+ */
+/**
+ * Scientific Template
+ *
+ * Visual layout:
+ * ┌────────────────────────────────────────╮
+ * │  📍 Series Name                        │
+ * │  ───────────────────────────────────── │
+ * │  X:  1.234×10³                         │
+ * │  Y:  5.678×10⁻² ± 0.001                │
+ * │  ───────────────────────────────────── │
+ * │  Index: 1523  │  Cycle: 3              │
+ * ╰────────────────────────────────────────╯
+ */
+export declare class ScientificTooltipTemplate implements TooltipTemplate<DataPointTooltip> {
+    readonly id = "scientific";
+    readonly name = "Scientific Notation";
+    readonly supportedTypes: TooltipType[];
+    private cachedKey;
+    private cachedMeasurement;
+    /**
+     * Measure tooltip dimensions
+     */
+    measure(ctx: CanvasRenderingContext2D, data: DataPointTooltip, theme: TooltipTheme): TooltipMeasurement;
+    /**
+     * Render the tooltip
+     */
+    render(ctx: CanvasRenderingContext2D, data: DataPointTooltip, position: TooltipPosition, theme: TooltipTheme): void;
+}
+export declare const scientificTooltipTemplate: ScientificTooltipTemplate;