chartgpu-angular 18.0.0 → 20.0.0

package/lib/chartgpu-angular.component.d.ts

@@ -1,103 +0,0 @@
-import { DestroyRef, ElementRef, OnDestroy } from '@angular/core';
-import { type ChartGPUInstance, type OHLCDataPoint } from 'chartgpu';
-import type { ChartgpuAppendDataOptions, ChartgpuCartesianSeriesData, ChartgpuChartHandle, ChartgpuClickEvent, ChartgpuDataAppendEvent, ChartgpuOptions, ChartgpuReadyEvent, ChartgpuResizeEvent, ChartgpuStyle, ChartgpuZoomChangeEvent, ChartgpuZoomRangeChangeEvent } from './chartgpu-angular.types';
-import * as i0 from "@angular/core";
-export declare class ChartGpuAngularComponent implements ChartgpuChartHandle, OnDestroy {
-    private readonly destroyRef;
-    readonly options: import("@angular/core").InputSignal<import("chartgpu").ChartGPUOptions>;
-    readonly gpuContext: import("@angular/core").InputSignal<Readonly<{
-        readonly device: GPUDevice;
-        readonly adapter: GPUAdapter;
-        readonly pipelineCache?: import("chartgpu").PipelineCache;
-    }>>;
-    readonly theme: import("@angular/core").InputSignal<import("chartgpu").ThemeConfig | "light" | "dark">;
-    readonly className: import("@angular/core").InputSignal<string>;
-    readonly style: import("@angular/core").InputSignal<ChartgpuStyle>;
-    readonly ready: import("@angular/core").OutputEmitterRef<ChartgpuReadyEvent>;
-    readonly chartReady: import("@angular/core").OutputEmitterRef<ChartGPUInstance>;
-    readonly chartDispose: import("@angular/core").OutputEmitterRef<void>;
-    readonly resize: import("@angular/core").OutputEmitterRef<ChartgpuResizeEvent>;
-    readonly click: import("@angular/core").OutputEmitterRef<ChartgpuClickEvent>;
-    readonly chartClick: import("@angular/core").OutputEmitterRef<Readonly<{
-        readonly seriesIndex: number;
-        readonly dataIndex: number;
-        readonly value: readonly [number, number];
-        readonly seriesName: string;
-        readonly event: PointerEvent;
-    }>>;
-    readonly mouseOver: import("@angular/core").OutputEmitterRef<Readonly<{
-        readonly seriesIndex: number;
-        readonly dataIndex: number;
-        readonly value: readonly [number, number];
-        readonly seriesName: string;
-        readonly event: PointerEvent;
-    }>>;
-    readonly mouseOut: import("@angular/core").OutputEmitterRef<Readonly<{
-        readonly seriesIndex: number;
-        readonly dataIndex: number;
-        readonly value: readonly [number, number];
-        readonly seriesName: string;
-        readonly event: PointerEvent;
-    }>>;
-    readonly crosshairMove: import("@angular/core").OutputEmitterRef<Readonly<{
-        readonly x: number;
-        readonly source?: unknown;
-    }>>;
-    readonly dataAppend: import("@angular/core").OutputEmitterRef<ChartgpuDataAppendEvent>;
-    readonly zoomChange: import("@angular/core").OutputEmitterRef<ChartgpuZoomChangeEvent>;
-    readonly zoomRangeChange: import("@angular/core").OutputEmitterRef<ChartgpuZoomRangeChangeEvent>;
-    readonly deviceLost: import("@angular/core").OutputEmitterRef<Readonly<{
-        readonly reason: GPUDeviceLostReason;
-        readonly message: string;
-    }>>;
-    readonly chartError: import("@angular/core").OutputEmitterRef<Error>;
-    readonly host: import("@angular/core").Signal<ElementRef<HTMLDivElement>>;
-    readonly canvasHost: import("@angular/core").Signal<ElementRef<HTMLDivElement>>;
-    private readonly chartInstance;
-    readonly initializationError: import("@angular/core").WritableSignal<Error>;
-    private chartContainer?;
-    private createdWithOptions?;
-    private resizeTimeout?;
-    private resizeObserver?;
-    private removeChartListeners?;
-    private destroying;
-    constructor(destroyRef: DestroyRef);
-    protected emitClick(event: MouseEvent): void;
-    ngOnDestroy(): void;
-    getChart(): ChartGPUInstance | null;
-    getContainer(): HTMLDivElement | null;
-    appendData(seriesIndex: number, newPoints: ChartgpuCartesianSeriesData | OHLCDataPoint[], options?: ChartgpuAppendDataOptions): void;
-    renderFrame(): boolean;
-    needsRender(): boolean;
-    getRenderMode(): 'auto' | 'external';
-    setRenderMode(mode: 'auto' | 'external'): void;
-    setOption(options: ChartgpuOptions): void;
-    setZoomRange(start: number, end: number, source?: unknown): void;
-    setInteractionX(x: number | null, source?: unknown): void;
-    getInteractionX(): number | null;
-    hitTest(event: PointerEvent | MouseEvent): Readonly<{
-        readonly isInGrid: boolean;
-        readonly canvasX: number;
-        readonly canvasY: number;
-        readonly gridX: number;
-        readonly gridY: number;
-        readonly match: Readonly<{
-            readonly kind: "pie" | "candlestick" | "ohlc" | "errorBar" | "impulse" | "pointCloud3d" | "surface3d" | "cartesian";
-            readonly seriesIndex: number;
-            readonly dataIndex: number;
-            readonly value: readonly [number, number] | readonly [number, number, number];
-            readonly valueChannel?: number;
-            readonly i?: number;
-            readonly j?: number;
-            readonly height?: number;
-        }>;
-    }>;
-    private getEffectiveOptions;
-    private listenToChart;
-    private emitZoomRange;
-    private observeResize;
-    private reportError;
-    private disposeChart;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ChartGpuAngularComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ChartGpuAngularComponent, "lib-chartgpu-angular", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "gpuContext": { "alias": "gpuContext"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; }, { "ready": "ready"; "chartReady": "chartReady"; "chartDispose": "chartDispose"; "resize": "resize"; "click": "click"; "chartClick": "chartClick"; "mouseOver": "mouseOver"; "mouseOut": "mouseOut"; "crosshairMove": "crosshairMove"; "dataAppend": "dataAppend"; "zoomChange": "zoomChange"; "zoomRangeChange": "zoomRangeChange"; "deviceLost": "deviceLost"; "chartError": "chartError"; }, never, never, true, never>;
-}

package/lib/chartgpu-angular.types.d.ts

@@ -1,89 +0,0 @@
-import type { ChartGPUOptions } from 'chartgpu';
-import type { AnimationConfig, AnnotationConfig, AxisConfig, ChartGPUCreateContext, ChartGPUCrosshairMovePayload, ChartGPUEventPayload, ChartGPUHitTestResult, ChartGPUInstance, ChartGPUDeviceLostPayload, ChartSyncOptions, DataZoomConfig, DataPoint, OHLCDataPoint, PipelineCache, RenderMode, SeriesConfig, SeriesType, ThemeConfig, TooltipConfig } from 'chartgpu';
-export type ChartgpuOptions = ChartGPUOptions;
-export type ChartgpuSeriesType = SeriesType;
-export type ChartgpuSeriesData = Extract<SeriesConfig, {
-    type: 'line';
-}>['data'];
-export type ChartgpuSeriesOptions = SeriesConfig;
-export type ChartgpuAxisOptions = AxisConfig;
-export type ChartgpuZoomOptions = DataZoomConfig;
-export type ChartgpuTooltipOptions = TooltipConfig;
-export type ChartgpuAnimationOptions = AnimationConfig | boolean;
-export type ChartgpuThemeOptions = ThemeConfig | 'light' | 'dark';
-export type ChartgpuAnnotationOptions = AnnotationConfig;
-export type ChartgpuThreeDOptions = Pick<ChartGPUOptions, 'coordinateSystem' | 'camera' | 'interaction3d' | 'axes3d'>;
-export type ChartgpuStreamingOptions = Pick<ChartGPUOptions, 'autoScroll'>;
-export type ChartgpuInteractionOptions = Pick<ChartGPUOptions, 'dataZoom' | 'tooltip'>;
-export type ChartgpuChartInstance = ChartGPUInstance;
-export type ChartgpuGPUContext = ChartGPUCreateContext;
-export type ChartgpuStyle = Record<string, string | number | null | undefined>;
-export type ChartgpuZoomRange = NonNullable<ReturnType<ChartGPUInstance['getZoomRange']>>;
-export type ChartgpuClickParams = ChartGPUEventPayload;
-export type ChartgpuMouseOverParams = ChartGPUEventPayload;
-export type ChartgpuCrosshairMoveParams = ChartGPUCrosshairMovePayload;
-export type ChartgpuHitTestResult = ChartGPUHitTestResult;
-export type ChartgpuRenderMode = RenderMode;
-export type ChartgpuSyncOptions = ChartSyncOptions;
-export type ChartgpuXYArraysData = Readonly<{
-    x: ArrayLike<number>;
-    y: ArrayLike<number>;
-    size?: ArrayLike<number>;
-}>;
-export type ChartgpuInterleavedXYData = ArrayBufferView;
-export type ChartgpuCartesianSeriesData = ReadonlyArray<DataPoint | null> | ChartgpuXYArraysData | ChartgpuInterleavedXYData;
-export type ChartgpuAppendDataOptions = Readonly<{
-    maxPoints?: number;
-}>;
-export interface ChartgpuDataAppendEvent {
-    seriesIndex: number;
-    count: number;
-    xExtent: {
-        min: number;
-        max: number;
-    };
-}
-export interface ChartgpuReadyEvent {
-    container: HTMLDivElement;
-}
-export interface ChartgpuResizeEvent {
-    width: number;
-    height: number;
-    container: HTMLDivElement;
-}
-export interface ChartgpuClickEvent {
-    x: number;
-    y: number;
-}
-export interface ChartgpuZoomChangeEvent {
-    range: {
-        start: number;
-        end: number;
-    };
-}
-export interface ChartgpuZoomRangeChangeEvent {
-    start: number;
-    end: number;
-}
-export interface ChartgpuGPUContextState {
-    adapter: ChartGPUCreateContext['adapter'] | null;
-    device: ChartGPUCreateContext['device'] | null;
-    pipelineCache: PipelineCache | null;
-    error: Error | null;
-    isReady: boolean;
-}
-export interface ChartgpuChartHandle {
-    getChart(): ChartGPUInstance | null;
-    getContainer(): HTMLDivElement | null;
-    appendData(seriesIndex: number, newPoints: ChartgpuCartesianSeriesData | OHLCDataPoint[], options?: ChartgpuAppendDataOptions): void;
-    renderFrame(): boolean;
-    needsRender(): boolean;
-    getRenderMode(): RenderMode;
-    setRenderMode(mode: RenderMode): void;
-    setOption(options: ChartgpuOptions): void;
-    setZoomRange(start: number, end: number, source?: unknown): void;
-    setInteractionX(x: number | null, source?: unknown): void;
-    getInteractionX(): number | null;
-    hitTest(event: PointerEvent | MouseEvent): ChartGPUHitTestResult | null;
-}
-export type { ChartGPUCreateContext, ChartGPUCrosshairMovePayload, ChartGPUDeviceLostPayload, ChartGPUEventPayload, ChartGPUHitTestResult, ChartGPUInstance, ChartSyncOptions, DataPoint, OHLCDataPoint, PipelineCache, RenderMode, };

package/lib/connect-charts.directive.d.ts

@@ -1,16 +0,0 @@
-import type { ChartGPUInstance } from 'chartgpu';
-import * as i0 from "@angular/core";
-export declare class ChartgpuConnectChartsDirective {
-    readonly charts: import("@angular/core").InputSignal<readonly ChartGPUInstance[]>;
-    readonly syncOptions: import("@angular/core").InputSignal<Readonly<{
-        readonly syncCrosshair?: boolean;
-        readonly syncZoom?: boolean;
-    }>>;
-    readonly connectionError: import("@angular/core").OutputEmitterRef<Error>;
-    private readonly ids;
-    private nextId;
-    private signature;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<ChartgpuConnectChartsDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ChartgpuConnectChartsDirective, "[libChartgpuConnectCharts]", never, { "charts": { "alias": "libChartgpuConnectCharts"; "required": false; "isSignal": true; }; "syncOptions": { "alias": "syncOptions"; "required": false; "isSignal": true; }; }, { "connectionError": "connectionError"; }, never, never, true, never>;
-}

package/lib/gpu-context.provider.d.ts

@@ -1 +0,0 @@
-export declare function provideChartGpuContext(): import("@angular/core").EnvironmentProviders;

package/lib/gpu-context.service.d.ts

@@ -1,20 +0,0 @@
-import type { ChartgpuGPUContextState } from './chartgpu-angular.types';
-import * as i0 from "@angular/core";
-/**
- * Creates one shared WebGPU context and pipeline cache for charts in a dashboard.
- * The device is intentionally not destroyed with the service so charts can share it
- * for the lifetime of the application.
- */
-export declare class ChartgpuGPUContextService {
-    readonly state: import("@angular/core").WritableSignal<ChartgpuGPUContextState>;
-    readonly context: import("@angular/core").Signal<Readonly<{
-        readonly device: GPUDevice;
-        readonly adapter: GPUAdapter;
-        readonly pipelineCache?: import("chartgpu").PipelineCache;
-    }>>;
-    private initialization?;
-    initialize(): Promise<ChartgpuGPUContextState>;
-    private createContext;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ChartgpuGPUContextService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ChartgpuGPUContextService>;
-}

package/public-api.d.ts

@@ -1,5 +0,0 @@
-export * from './lib/chartgpu-angular.component';
-export * from './lib/chartgpu-angular.types';
-export * from './lib/connect-charts.directive';
-export * from './lib/gpu-context.provider';
-export * from './lib/gpu-context.service';