ag-charts-community/dist/types/src/chart/chart.d.ts

Advanced Charting / Charts supporting Javascript / Typescript / React / Angular / Vue

import type { DynamicContext } from 'ag-charts-core';
import { type ChartAnimationPhase, ChartUpdateType, Debug, type ModuleInstance, Padding } from 'ag-charts-core';
import type { AgChartInstance, AgChartOptions, AgDataTransaction, AgSelectionItem, AgSelectionItemIds, FormatterConfiguration } from 'ag-charts-types';
import type { UpdateOpts } from '../core/eventsHub';
import type { ChartRegistry } from '../module/moduleContext';
import type { ChartOptions } from '../module/optionsModule';
import { BBox } from '../scene/bbox';
import { TranslatableGroup } from '../scene/group';
import type { Scene } from '../scene/scene';
import type { TypedEvent } from '../util/observable';
import { Observable } from '../util/observable';
import { Background } from './background/background';
import { Caption } from './caption';
import { ChartAxes } from './chartAxes';
import type { ChartAxis } from './chartAxis';
import { ChartHighlight } from './chartHighlight';
import type { ChartMode } from './chartMode';
import type { ChartService, ChartServiceEvent, ChartServiceEventType } from './chartService';
import type { ChartType } from './chartType';
import { DataSet } from './data/dataSet';
import { type SyncStatus } from './interaction/syncManager';
import { Keyboard } from './keyboard';
import { type LayoutContext } from './layout/layoutManager';
import { ModulesManager } from './modulesManager';
import { ChartOverlays } from './overlay/chartOverlays';
import { SeriesArea } from './series-area/seriesArea';
import { Series, type UnknownSeries } from './series/series';
import { SeriesAreaManager } from './series/seriesAreaManager';
import { SeriesLayerManager } from './series/seriesLayerManager';
import type { DatumIndexType, ISeries, ISeriesProperties } from './series/seriesTypes';
import { Tooltip, type TooltipContent } from './tooltip/tooltip';
import { Touch } from './touch';
export type TransferableResources = {
    container?: HTMLElement;
    styleContainer?: HTMLElement;
    scene: Scene;
};
export declare abstract class Chart extends Observable implements ModuleInstance, ChartService {
    static readonly className: string;
    private static readonly chartsInstances;
    static getInstance(element: HTMLElement): Chart | undefined;
    readonly id: string;
    className?: string;
    readonly seriesRoot: TranslatableGroup<unknown>;
    readonly annotationRoot: TranslatableGroup<unknown>;
    readonly selectionRoot: TranslatableGroup<unknown>;
    private readonly titleGroup;
    readonly tooltip: Tooltip;
    readonly overlays: ChartOverlays;
    readonly highlight: ChartHighlight;
    readonly background: Background<any>;
    readonly seriesArea: SeriesArea;
    foreground?: Background<any>;
    protected readonly debug: Debug.DebugLogger;
    private extraDebugStats;
    container?: HTMLElement;
    data: DataSet;
    loading: boolean | undefined;
    width?: number;
    height?: number;
    minWidth?: number;
    minHeight?: number;
    overrideDevicePixelRatio?: number;
    /** NOTE: This is exposed for use by Integrated charts only. */
    get canvasElement(): HTMLCanvasElement;
    private _lastAutoSize?;
    private _firstAutoSize;
    private readonly _autoSizeNotify;
    private _requiredRange;
    private _requiredRangeDirection;
    download(fileName?: string, fileFormat?: string): void;
    getCanvasDataURL(fileFormat?: string): string;
    toSVG(): string | undefined;
    private readonly chartCaptions;
    readonly padding: Padding;
    get seriesAreaBoundingBox(): BBox;
    readonly keyboard: Keyboard;
    readonly touch: Touch;
    mode: ChartMode;
    withinStudio: boolean | undefined;
    styleNonce: string | undefined;
    readonly title: Caption;
    readonly subtitle: Caption;
    readonly footnote: Caption;
    formatter: FormatterConfiguration<any> | undefined;
    suppressFieldDotNotation: boolean;
    loadGoogleFonts: boolean;
    dataIdKey: string | undefined;
    context?: unknown;
    destroyed: boolean;
    private readonly cleanup;
    chartAnimationPhase: ChartAnimationPhase;
    readonly modulesManager: ModulesManager;
    readonly ctx: DynamicContext<ChartRegistry>;
    protected readonly seriesLayerManager: SeriesLayerManager;
    protected readonly seriesAreaManager: SeriesAreaManager;
    private readonly processors;
    queuedUserOptions: AgChartOptions[];
    queuedChartOptions: ChartOptions[];
    chartOptions: ChartOptions;
    private firstApply;
    /**
     * Public API for this Chart instance. NOTE: This is initialized after construction by the
     * wrapping class that implements AgChartInstance.
     */
    publicApi?: AgChartInstance;
    syncStatus: SyncStatus;
    getOptions(): import("ag-charts-types").AgCartesianChartOptions<any, unknown> | import("ag-charts-types").AgPolarChartOptions<any, unknown> | import("ag-charts-types").AgTopologyChartOptions<any, unknown> | import("ag-charts-types").AgStandaloneChartOptions<any, unknown>;
    getChartOptions(): ChartOptions<AgChartOptions>;
    isDataTransactionSupported(): boolean;
    protected createDataSet(data: unknown[]): DataSet;
    constructor(options: ChartOptions, resources?: TransferableResources);
    overrideFocusVisible(visible: boolean | undefined): void;
    private readonly fireEventWrapper;
    protected fireEvent<TEvent extends TypedEvent>(event: TEvent): void;
    hasListener(type: ChartServiceEventType): boolean;
    callListener(event: ChartServiceEvent): void;
    private initSeriesAreaDependencies;
    getModuleContext(): DynamicContext<ChartRegistry>;
    abstract getChartType(): ChartType;
    getTooltipContent(series: ISeries<DatumIndexType, any, any>, datumIndex: DatumIndexType, removeMeDatum: unknown, purpose: 'aria-label' | 'tooltip'): TooltipContent[];
    protected getCaptionText(): string;
    protected getAriaLabel(): string;
    private refreshSeriesUserVisibility;
    getSelection(): Iterable<AgSelectionItem<unknown>> | undefined;
    setSelection(items: Iterable<AgSelectionItemIds>): void;
    clearSelection(): void;
    resetAnimations(): void;
    skipAnimations(): void;
    detachAndClear(): void;
    destroy(opts?: {
        keepTransferableResources: boolean;
    }): TransferableResources | undefined;
    requestFactoryUpdate(cb: (chart: Chart) => Promise<void> | void): void;
    private clearCallbackCache;
    private apiUpdate;
    private pendingLocaleText?;
    private _pendingFactoryUpdatesCount;
    private _performUpdateSkipAnimations;
    private readonly _performUpdateNotify;
    private performUpdateType;
    private runningUpdateType;
    private currentProcessingUpdateType;
    private updateShortcutCount;
    private readonly seriesToUpdate;
    private readonly updateMutex;
    private clearCallbackCacheOnUpdate;
    private updateRequestors;
    private readonly performUpdateTrigger;
    update(type?: ChartUpdateType, opts?: UpdateOpts): void;
    private readonly _performUpdateSplits;
    private _previousSplit;
    private updateSplits;
    private tryPerformUpdate;
    private performUpdate;
    private updateThemeClassName;
    private updateDOM;
    private updateAriaLabels;
    private checkUpdateShortcut;
    private checkFirstAutoSize;
    axes: ChartAxes;
    createChartAxes(): ChartAxes;
    series: Series<DatumIndexType, any, any, any>[];
    protected onAxisChange(newValue: ChartAxis[], oldValue?: ChartAxis[]): void;
    protected onSeriesChange(newValue: UnknownSeries[], oldValue?: UnknownSeries[]): void;
    protected destroySeries(allSeries: UnknownSeries[]): void;
    private addSeriesListeners;
    protected assignSeriesToAxes(): void;
    protected assignAxesToSeries(): void;
    private parentResize;
    private resize;
    updateData(): void;
    private _cachedData;
    processData(): Promise<void>;
    processDomains(): Promise<void>;
    processRanges(): void;
    private updateLegends;
    private setCategoryLegendData;
    private processLayout;
    protected abstract performLayout(ctx: LayoutContext): Promise<void> | void;
    protected seriesRect?: BBox;
    protected animationRect?: BBox;
    protected getDebugColors(): {
        background?: string;
        foreground?: string;
    } | undefined;
    protected preSeriesUpdate(): void;
    protected updateSeries(seriesToUpdate: ISeries<DatumIndexType, unknown, ISeriesProperties>[]): Promise<void>;
    private readonly onSeriesNodeClick;
    private readonly onSeriesNodeDoubleClick;
    private readonly onSeriesVisibilityChange;
    private readonly seriesGroupingChanged;
    waitForUpdate(timeoutMs?: number, failOnTimeout?: boolean): Promise<void>;
    private filterMiniChartSeries;
    applyOptions(newChartOptions: ChartOptions): void;
    private applyInitialState;
    private maybeResetAnimations;
    private shouldForceNodeDataRefresh;
    private shouldClearLegendData;
    private applyMiniChartOptions;
    private applyModules;
    private initSeriesDeclarationOrder;
    private applySeries;
    private applyAxes;
    private createSeries;
    private applySeriesOptionModules;
    private applySeriesValues;
    private createAxes;
    private applyAxisModules;
    private registerListeners;
    applyTransaction(transaction: AgDataTransaction): Promise<void>;
    onSyncActiveClear(): void;
    private needsViewportSupport;
    hasViewportSupport(): boolean;
    hasPgUpPgDownSupport(): boolean;
}