chartgpu 0.1.0

package/dist/core/GPUContext.d.ts

@@ -0,0 +1,210 @@
+/**
+ * GPUContext - WebGPU device and adapter management
+ *
+ * Handles WebGPU initialization, adapter selection, and device creation
+ * following WebGPU best practices for resource management and error handling.
+ *
+ * This module provides both functional and class-based APIs for maximum flexibility.
+ */
+/**
+ * Represents the state of a GPU context.
+ * All properties are readonly to ensure immutability.
+ */
+export interface GPUContextState {
+    readonly adapter: GPUAdapter | null;
+    readonly device: GPUDevice | null;
+    readonly initialized: boolean;
+    readonly canvas: HTMLCanvasElement | null;
+    readonly canvasContext: GPUCanvasContext | null;
+    readonly preferredFormat: GPUTextureFormat | null;
+}
+/**
+ * Creates a new GPUContext state with initial values.
+ *
+ * @param canvas - Optional HTMLCanvasElement to configure for WebGPU rendering
+ * @returns A new GPUContextState instance
+ */
+export declare function createGPUContext(canvas?: HTMLCanvasElement): GPUContextState;
+/**
+ * Initializes the WebGPU context by requesting an adapter and device.
+ * Returns a new state object with initialized values.
+ *
+ * @param context - The GPU context state to initialize
+ * @returns A new GPUContextState with initialized adapter and device
+ * @throws {Error} If WebGPU is not available in the browser
+ * @throws {Error} If adapter request fails
+ * @throws {Error} If device request fails
+ * @throws {Error} If already initialized
+ */
+export declare function initializeGPUContext(context: GPUContextState): Promise<GPUContextState>;
+/**
+ * Gets the current texture from the canvas context.
+ *
+ * @param context - The GPU context state
+ * @returns The current canvas texture
+ * @throws {Error} If canvas is not configured or context is not initialized
+ *
+ * @example
+ * ```typescript
+ * const texture = getCanvasTexture(context);
+ * // Use texture in render pass
+ * ```
+ */
+export declare function getCanvasTexture(context: GPUContextState): GPUTexture;
+/**
+ * Clears the canvas to a solid color.
+ * Creates a command encoder, begins a render pass with the specified clear color,
+ * ends the pass, and submits it to the queue.
+ *
+ * @param context - The GPU context state
+ * @param r - Red component (0.0 to 1.0)
+ * @param g - Green component (0.0 to 1.0)
+ * @param b - Blue component (0.0 to 1.0)
+ * @param a - Alpha component (0.0 to 1.0)
+ * @throws {Error} If canvas is not configured or context is not initialized
+ * @throws {Error} If device is not available
+ *
+ * @example
+ * ```typescript
+ * // Clear to dark purple (#1a1a2e)
+ * clearScreen(context, 0x1a / 255, 0x1a / 255, 0x2e / 255, 1.0);
+ * ```
+ */
+export declare function clearScreen(context: GPUContextState, r: number, g: number, b: number, a: number): void;
+/**
+ * Destroys the WebGPU device and cleans up resources.
+ * Returns a new state object with reset values.
+ * After calling this, the context must be reinitialized before use.
+ *
+ * @param context - The GPU context state to destroy
+ * @returns A new GPUContextState with reset values
+ */
+export declare function destroyGPUContext(context: GPUContextState): GPUContextState;
+/**
+ * Convenience function that creates and initializes a GPU context in one step.
+ *
+ * @param canvas - Optional HTMLCanvasElement to configure for WebGPU rendering
+ * @returns A fully initialized GPUContextState
+ * @throws {Error} If initialization fails
+ *
+ * @example
+ * ```typescript
+ * const context = await createGPUContextAsync();
+ * const device = context.device;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const canvas = document.querySelector('canvas');
+ * const context = await createGPUContextAsync(canvas);
+ * const texture = getCanvasTexture(context);
+ * ```
+ */
+export declare function createGPUContextAsync(canvas?: HTMLCanvasElement): Promise<GPUContextState>;
+/**
+ * GPUContext class wrapper for backward compatibility.
+ *
+ * This class provides a class-based API that internally uses the functional implementation.
+ * Use the functional API directly for better type safety and immutability.
+ */
+export declare class GPUContext {
+    private _state;
+    /**
+     * Gets the WebGPU adapter, or null if not initialized.
+     */
+    get adapter(): GPUAdapter | null;
+    /**
+     * Gets the WebGPU device, or null if not initialized.
+     */
+    get device(): GPUDevice | null;
+    /**
+     * Checks if the context has been initialized.
+     */
+    get initialized(): boolean;
+    /**
+     * Gets the canvas element, or null if not provided.
+     */
+    get canvas(): HTMLCanvasElement | null;
+    /**
+     * Gets the WebGPU canvas context, or null if canvas is not configured.
+     */
+    get canvasContext(): GPUCanvasContext | null;
+    /**
+     * Gets the preferred canvas format, or null if canvas is not configured.
+     */
+    get preferredFormat(): GPUTextureFormat | null;
+    /**
+     * Creates a new GPUContext instance.
+     *
+     * @param canvas - Optional HTMLCanvasElement to configure for WebGPU rendering
+     */
+    constructor(canvas?: HTMLCanvasElement);
+    /**
+     * Initializes the WebGPU context by requesting an adapter and device.
+     *
+     * @throws {Error} If WebGPU is not available in the browser
+     * @throws {Error} If adapter request fails
+     * @throws {Error} If device request fails
+     * @throws {Error} If already initialized
+     */
+    initialize(): Promise<void>;
+    /**
+     * Static factory method to create and initialize a GPUContext instance.
+     *
+     * @param canvas - Optional HTMLCanvasElement to configure for WebGPU rendering
+     * @returns A fully initialized GPUContext instance
+     * @throws {Error} If initialization fails
+     *
+     * @example
+     * ```typescript
+     * const context = await GPUContext.create();
+     * const device = context.device;
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const canvas = document.querySelector('canvas');
+     * const context = await GPUContext.create(canvas);
+     * const texture = context.getCanvasTexture();
+     * ```
+     */
+    static create(canvas?: HTMLCanvasElement): Promise<GPUContext>;
+    /**
+     * Gets the current texture from the canvas context.
+     *
+     * @returns The current canvas texture
+     * @throws {Error} If canvas is not configured or context is not initialized
+     *
+     * @example
+     * ```typescript
+     * const texture = context.getCanvasTexture();
+     * // Use texture in render pass
+     * ```
+     */
+    getCanvasTexture(): GPUTexture;
+    /**
+     * Clears the canvas to a solid color.
+     * Creates a command encoder, begins a render pass with the specified clear color,
+     * ends the pass, and submits it to the queue.
+     *
+     * @param r - Red component (0.0 to 1.0)
+     * @param g - Green component (0.0 to 1.0)
+     * @param b - Blue component (0.0 to 1.0)
+     * @param a - Alpha component (0.0 to 1.0)
+     * @throws {Error} If canvas is not configured or context is not initialized
+     * @throws {Error} If device is not available
+     *
+     * @example
+     * ```typescript
+     * // Clear to dark purple (#1a1a2e)
+     * context.clearScreen(0x1a / 255, 0x1a / 255, 0x2e / 255, 1.0);
+     * ```
+     */
+    clearScreen(r: number, g: number, b: number, a: number): void;
+    /**
+     * Destroys the WebGPU device and cleans up resources.
+     * After calling destroy(), the context must be reinitialized before use.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=GPUContext.d.ts.map

package/dist/core/GPUContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUContext.d.ts","sourceRoot":"","sources":["../../src/core/GPUContext.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAChD,QAAQ,CAAC,eAAe,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACnD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,eAAe,CAS5E;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,eAAe,CAAC,CAuG1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,GAAG,UAAU,CAUrE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,eAAe,EACxB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,IAAI,CAqCN;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,eAAe,CAiB3E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,CAAC,EAAE,iBAAiB,GACzB,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED;;;;;GAKG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAkB;IAEhC;;OAEG;IACH,IAAI,OAAO,IAAI,UAAU,GAAG,IAAI,CAE/B;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,SAAS,GAAG,IAAI,CAE7B;IAED;;OAEG;IACH,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,iBAAiB,GAAG,IAAI,CAErC;IAED;;OAEG;IACH,IAAI,aAAa,IAAI,gBAAgB,GAAG,IAAI,CAE3C;IAED;;OAEG;IACH,IAAI,eAAe,IAAI,gBAAgB,GAAG,IAAI,CAE7C;IAED;;;;OAIG;gBACS,MAAM,CAAC,EAAE,iBAAiB;IAItC;;;;;;;OAOG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;;;;;;;;;;;;;;;;;;OAmBG;WACU,MAAM,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC;IAMpE;;;;;;;;;;;OAWG;IACH,gBAAgB,IAAI,UAAU;IAI9B;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAI7D;;;OAGG;IACH,OAAO,IAAI,IAAI;CAGhB"}

package/dist/core/RenderScheduler.d.ts

@@ -0,0 +1,132 @@
+/**
+ * RenderScheduler - 60fps render loop management
+ *
+ * Manages a requestAnimationFrame-based render loop that runs at 60fps,
+ * providing delta time tracking and frame scheduling control.
+ *
+ * This module provides both functional and class-based APIs for maximum flexibility.
+ * The functional API is preferred for better type safety and immutability.
+ */
+/**
+ * Callback function type for render frames.
+ * Receives delta time in milliseconds since the last frame.
+ */
+export type RenderCallback = (deltaTime: number) => void;
+/**
+ * Represents the state of a render scheduler.
+ * All properties are readonly to ensure immutability.
+ */
+export interface RenderSchedulerState {
+    readonly id: symbol;
+    readonly running: boolean;
+}
+/**
+ * Creates a new RenderScheduler state with initial values.
+ *
+ * @returns A new RenderSchedulerState instance
+ */
+export declare function createRenderScheduler(): RenderSchedulerState;
+/**
+ * Starts the render loop.
+ *
+ * Begins a requestAnimationFrame loop that calls the provided callback
+ * every frame with the delta time in milliseconds since the last frame.
+ * Returns a new state object with running set to true.
+ *
+ * @param state - The scheduler state to start
+ * @param callback - Function to call each frame with delta time
+ * @returns A new RenderSchedulerState with running set to true
+ * @throws {Error} If callback is not provided
+ * @throws {Error} If scheduler is already running
+ * @throws {Error} If state is invalid
+ */
+export declare function startRenderScheduler(state: RenderSchedulerState, callback: RenderCallback): RenderSchedulerState;
+/**
+ * Stops the render loop.
+ *
+ * Cancels any pending requestAnimationFrame calls and stops the loop.
+ * Returns a new state object with running set to false.
+ * The scheduler can be restarted by calling startRenderScheduler() again.
+ *
+ * @param state - The scheduler state to stop
+ * @returns A new RenderSchedulerState with running set to false
+ * @throws {Error} If state is invalid
+ */
+export declare function stopRenderScheduler(state: RenderSchedulerState): RenderSchedulerState;
+/**
+ * Marks the current frame as dirty, indicating it needs to be rendered.
+ *
+ * This function is prepared for future optimization where frames can be
+ * skipped if nothing has changed. Currently, all frames render regardless
+ * of the dirty flag.
+ *
+ * @param state - The scheduler state
+ * @throws {Error} If state is invalid
+ */
+export declare function requestRender(state: RenderSchedulerState): void;
+/**
+ * Destroys the render scheduler and cleans up resources.
+ * Stops the loop if running and removes internal state from the map.
+ * Returns a new state object with reset values.
+ * After calling this, the scheduler must be recreated before use.
+ *
+ * **Important:** Always call this function when done with a scheduler to prevent memory leaks.
+ * The internal state map will retain entries until explicitly destroyed.
+ *
+ * @param state - The scheduler state to destroy
+ * @returns A new RenderSchedulerState with reset values
+ */
+export declare function destroyRenderScheduler(state: RenderSchedulerState): RenderSchedulerState;
+/**
+ * Convenience function that creates a scheduler and starts it in one step.
+ *
+ * @param callback - Function to call each frame with delta time
+ * @returns A RenderSchedulerState with the loop running
+ * @throws {Error} If callback is not provided
+ *
+ * @example
+ * ```typescript
+ * const scheduler = createRenderSchedulerAsync((deltaTime) => {
+ *   renderFrame(deltaTime);
+ * });
+ * ```
+ */
+export declare function createRenderSchedulerAsync(callback: RenderCallback): RenderSchedulerState;
+/**
+ * RenderScheduler class wrapper for backward compatibility.
+ *
+ * This class provides a class-based API that internally uses the functional implementation.
+ * Use the functional API directly for better type safety and immutability.
+ */
+export declare class RenderScheduler {
+    private _state;
+    /**
+     * Checks if the scheduler is currently running.
+     */
+    get running(): boolean;
+    /**
+     * Creates a new RenderScheduler instance.
+     */
+    constructor();
+    /**
+     * Starts the render loop.
+     *
+     * @param callback - Function to call each frame with delta time
+     * @throws {Error} If callback is not provided or scheduler already running
+     */
+    start(callback: RenderCallback): void;
+    /**
+     * Stops the render loop.
+     */
+    stop(): void;
+    /**
+     * Marks the current frame as dirty, indicating it needs to be rendered.
+     */
+    requestRender(): void;
+    /**
+     * Destroys the render scheduler and cleans up resources.
+     * After calling destroy(), the scheduler must be recreated before use.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=RenderScheduler.d.ts.map

package/dist/core/RenderScheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderScheduler.d.ts","sourceRoot":"","sources":["../../src/core/RenderScheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAmBD;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,oBAAoB,CAgB5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,oBAAoB,EAC3B,QAAQ,EAAE,cAAc,GACvB,oBAAoB,CAyDtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,CAkBrF;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAQ/D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,CAmBxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,cAAc,GAAG,oBAAoB,CAGzF;AAED;;;;;GAKG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAuB;IAErC;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;;IAKH;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIrC;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,aAAa,IAAI,IAAI;IAIrB;;;OAGG;IACH,OAAO,IAAI,IAAI;CAGhB"}

package/dist/core/createAnimationController.d.ts

@@ -0,0 +1,15 @@
+import type { EasingFunction } from '../utils/easing';
+export type AnimationId = symbol;
+export interface AnimationController {
+    animate(from: number, to: number, duration: number, easing: EasingFunction, onUpdate: (value: number) => void, onComplete?: () => void): AnimationId;
+    animate(from: ReadonlyArray<number>, to: ReadonlyArray<number>, duration: number, easing: EasingFunction, onUpdate: (value: ReadonlyArray<number>) => void, onComplete?: () => void): AnimationId;
+    cancel(animationId: AnimationId): void;
+    cancelAll(): void;
+    /**
+     * Progresses all active animations to `timestamp` (ms).
+     * Intended to be called once per frame by the caller (e.g. a render loop).
+     */
+    update(timestamp: number): void;
+}
+export declare function createAnimationController(): AnimationController;
+//# sourceMappingURL=createAnimationController.d.ts.map

package/dist/core/createAnimationController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAnimationController.d.ts","sourceRoot":"","sources":["../../src/core/createAnimationController.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC,MAAM,WAAW,mBAAmB;IAClC,OAAO,CACL,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EACjC,UAAU,CAAC,EAAE,MAAM,IAAI,GACtB,WAAW,CAAC;IACf,OAAO,CACL,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,EAAE,EAAE,aAAa,CAAC,MAAM,CAAC,EACzB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,IAAI,EAChD,UAAU,CAAC,EAAE,MAAM,IAAI,GACtB,WAAW,CAAC;IAEf,MAAM,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IACvC,SAAS,IAAI,IAAI,CAAC;IAElB;;;OAGG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAiCD,wBAAgB,yBAAyB,IAAI,mBAAmB,CAoH/D"}

package/dist/core/createRenderCoordinator.d.ts

@@ -0,0 +1,71 @@
+import type { ResolvedChartGPUOptions } from '../config/OptionResolver';
+import type { DataPoint } from '../config/types';
+export interface GPUContextLike {
+    readonly device: GPUDevice | null;
+    readonly canvas: HTMLCanvasElement | null;
+    readonly canvasContext: GPUCanvasContext | null;
+    readonly preferredFormat: GPUTextureFormat | null;
+    readonly initialized: boolean;
+}
+export interface RenderCoordinator {
+    setOptions(resolvedOptions: ResolvedChartGPUOptions): void;
+    /**
+     * Appends new points to a cartesian series’ runtime data without requiring a full `setOptions(...)`
+     * resolver pass.
+     *
+     * Appends are coalesced and flushed once per render frame.
+     */
+    appendData(seriesIndex: number, newPoints: ReadonlyArray<DataPoint>): void;
+    /**
+     * Gets the current “interaction x” in domain units (or `null` when inactive).
+     *
+     * This is derived from pointer movement inside the plot grid and can also be driven
+     * externally via `setInteractionX(...)` (e.g. chart sync).
+     */
+    getInteractionX(): number | null;
+    /**
+     * Drives the chart’s crosshair + tooltip from a domain-space x value.
+     *
+     * Passing `null` clears the interaction (hides crosshair/tooltip).
+     */
+    setInteractionX(x: number | null, source?: unknown): void;
+    /**
+     * Subscribes to interaction x changes (domain units).
+     *
+     * Returns an unsubscribe function.
+     */
+    onInteractionXChange(callback: (x: number | null, source?: unknown) => void): () => void;
+    /**
+     * Returns the current percent-space zoom window (or `null` when zoom is disabled).
+     */
+    getZoomRange(): Readonly<{
+        start: number;
+        end: number;
+    }> | null;
+    /**
+     * Sets the percent-space zoom window.
+     *
+     * No-op when zoom is disabled.
+     */
+    setZoomRange(start: number, end: number): void;
+    /**
+     * Subscribes to zoom window changes (percent space).
+     *
+     * Returns an unsubscribe function.
+     */
+    onZoomRangeChange(cb: (range: Readonly<{
+        start: number;
+        end: number;
+    }>) => void): () => void;
+    render(): void;
+    dispose(): void;
+}
+export type RenderCoordinatorCallbacks = Readonly<{
+    /**
+     * Optional hook for render-on-demand systems (like `ChartGPU`) to re-render when
+     * interaction state changes (e.g. crosshair on pointer move).
+     */
+    readonly onRequestRender?: () => void;
+}>;
+export declare function createRenderCoordinator(gpuContext: GPUContextLike, options: ResolvedChartGPUOptions, callbacks?: RenderCoordinatorCallbacks): RenderCoordinator;
+//# sourceMappingURL=createRenderCoordinator.d.ts.map

package/dist/core/createRenderCoordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRenderCoordinator.d.ts","sourceRoot":"","sources":["../../src/core/createRenderCoordinator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,uBAAuB,EAExB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAmB,SAAS,EAAwC,MAAM,iBAAiB,CAAC;AAuCxG,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAChD,QAAQ,CAAC,eAAe,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAClD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,eAAe,EAAE,uBAAuB,GAAG,IAAI,CAAC;IAC3D;;;;;OAKG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;IAC3E;;;;;OAKG;IACH,eAAe,IAAI,MAAM,GAAG,IAAI,CAAC;IACjC;;;;OAIG;IACH,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1D;;;;OAIG;IACH,oBAAoB,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACzF;;OAEG;IACH,YAAY,IAAI,QAAQ,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;IAChE;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAC7F,MAAM,IAAI,IAAI,CAAC;IACf,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC;IAChD;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;CACvC,CAAC,CAAC;AA0mBH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,cAAc,EAC1B,OAAO,EAAE,uBAAuB,EAChC,SAAS,CAAC,EAAE,0BAA0B,GACrC,iBAAiB,CA+4DnB"}

package/dist/data/createDataStore.d.ts

@@ -0,0 +1,33 @@
+import type { DataPoint } from '../config/types';
+export interface DataStore {
+    setSeries(index: number, data: ReadonlyArray<DataPoint>): void;
+    /**
+     * Appends new points to an existing series without re-uploading the entire buffer when possible.
+     *
+     * - Reuses the same geometric growth policy as `setSeries`.
+     * - When no reallocation is needed, writes only the appended byte range via `queue.writeBuffer(...)`.
+     * - Maintains `pointCount` and a CPU-side combined data array so `getSeriesData(...)` remains correct.
+     *
+     * Throws if the series has not been set yet.
+     */
+    appendSeries(index: number, newPoints: ReadonlyArray<DataPoint>): void;
+    removeSeries(index: number): void;
+    getSeriesBuffer(index: number): GPUBuffer;
+    /**
+     * Returns the number of points last set for the given series index.
+     *
+     * Throws if the series has not been set yet.
+     */
+    getSeriesPointCount(index: number): number;
+    /**
+     * Returns the last CPU-side data set for the given series index.
+     *
+     * This is intended for internal metadata/hit-testing paths that need the same
+     * input array that was packed into the GPU buffer (without re-threading it
+     * through other state). Throws if the series has not been set yet.
+     */
+    getSeriesData(index: number): ReadonlyArray<DataPoint>;
+    dispose(): void;
+}
+export declare function createDataStore(device: GPUDevice): DataStore;
+//# sourceMappingURL=createDataStore.d.ts.map

package/dist/data/createDataStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDataStore.d.ts","sourceRoot":"","sources":["../../src/data/createDataStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,iBAAiB,CAAC;AAEjE,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;IAC/D;;;;;;;;OAQG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;IACvE,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C;;;;OAIG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3C;;;;;;OAMG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;IACvD,OAAO,IAAI,IAAI,CAAC;CACjB;AAyED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAmN5D"}

package/dist/data/createStreamBuffer.d.ts

@@ -0,0 +1,20 @@
+export interface StreamBuffer {
+    /**
+     * Writes a new vertex payload into the streaming buffer.
+     *
+     * Notes:
+     * - `data` is interpreted as interleaved `vec2<f32>` vertices: `[x0, y0, x1, y1, ...]`.
+     * - Uses double buffering (alternates GPU buffers each write) to avoid writing into the same
+     *   buffer the GPU might still be reading from the prior frame.
+     * - Uses a per-buffer CPU mirror (Uint32 bit patterns) to compute partial updates.
+     */
+    write(data: Float32Array): void;
+    /** Returns the GPUBuffer that contains the most recently written data. */
+    getBuffer(): GPUBuffer;
+    /** Returns the vertex count for the most recently written data. */
+    getVertexCount(): number;
+    /** Destroys GPU resources (best-effort). Safe to call multiple times. */
+    dispose(): void;
+}
+export declare function createStreamBuffer(device: GPUDevice, maxSize: number): StreamBuffer;
+//# sourceMappingURL=createStreamBuffer.d.ts.map

package/dist/data/createStreamBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStreamBuffer.d.ts","sourceRoot":"","sources":["../../src/data/createStreamBuffer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B;;;;;;;;OAQG;IACH,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAChC,0EAA0E;IAC1E,SAAS,IAAI,SAAS,CAAC;IACvB,mEAAmE;IACnE,cAAc,IAAI,MAAM,CAAC;IACzB,yEAAyE;IACzE,OAAO,IAAI,IAAI,CAAC;CACjB;AAoBD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,CAiKnF"}

package/dist/data/lttbSample.d.ts

@@ -0,0 +1,5 @@
+import type { DataPoint } from '../config/types';
+export declare function lttbSample(data: Float32Array, targetPoints: number): Float32Array;
+export declare function lttbSample(data: DataPoint[], targetPoints: number): DataPoint[];
+export declare function lttbSample(data: ReadonlyArray<DataPoint>, targetPoints: number): ReadonlyArray<DataPoint>;
+//# sourceMappingURL=lttbSample.d.ts.map

package/dist/data/lttbSample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lttbSample.d.ts","sourceRoot":"","sources":["../../src/data/lttbSample.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,iBAAiB,CAAC;AA6KjE,wBAAgB,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,YAAY,CAAC;AACnF,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;AACjF,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC"}

package/dist/data/sampleSeries.d.ts

@@ -0,0 +1,3 @@
+import type { DataPoint, SeriesSampling } from '../config/types';
+export declare function sampleSeriesDataPoints(data: ReadonlyArray<DataPoint>, sampling: SeriesSampling, samplingThreshold: number): ReadonlyArray<DataPoint>;
+//# sourceMappingURL=sampleSeries.d.ts.map

package/dist/data/sampleSeries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampleSeries.d.ts","sourceRoot":"","sources":["../../src/data/sampleSeries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAkB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AA+GjF,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,EAC9B,QAAQ,EAAE,cAAc,EACxB,iBAAiB,EAAE,MAAM,GACxB,aAAa,CAAC,SAAS,CAAC,CAsB1B"}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ChartGPU - A GPU-accelerated charting library built with WebGPU
+ */
+export declare const version = "1.0.0";
+export { ChartGPU } from './ChartGPU';
+export { createChartGPU as createChart } from './ChartGPU';
+export type { ChartGPUInstance } from './ChartGPU';
+export type { ChartGPUEventName, ChartGPUEventPayload, ChartGPUCrosshairMovePayload, ChartGPUEventCallback, ChartGPUCrosshairMoveCallback, } from './ChartGPU';
+export type { AreaStyleConfig, AnimationConfig, BarItemStyleConfig, AxisConfig, AxisType, ChartGPUOptions, DataZoomConfig, DataPoint, GridConfig, LineStyleConfig, AreaSeriesConfig, LineSeriesConfig, BarSeriesConfig, PieCenter, PieDataItem, PieItemStyleConfig, PieRadius, PieSeriesConfig, ScatterSeriesConfig, ScatterSymbol, ScatterPointTuple, SeriesConfig, SeriesSampling, SeriesType, TooltipParams, } from './config/types';
+export { defaultOptions } from './config/defaults';
+export { OptionResolver, resolveOptions } from './config/OptionResolver';
+export type { ResolvedChartGPUOptions, ResolvedAreaSeriesConfig, ResolvedAreaStyleConfig, ResolvedGridConfig, ResolvedLineSeriesConfig, ResolvedLineStyleConfig, ResolvedSeriesConfig, } from './config/OptionResolver';
+export type { ThemeConfig } from './themes/types';
+export { darkTheme, lightTheme, getTheme } from './themes';
+export type { ThemeName } from './themes';
+export { createLinearScale, createCategoryScale } from './utils/scales';
+export type { LinearScale, CategoryScale } from './utils/scales';
+export { connectCharts } from './interaction/createChartSync';
+export type { GPUContextState } from './core/GPUContext';
+export { createGPUContext, createGPUContextAsync, initializeGPUContext, getCanvasTexture, clearScreen, destroyGPUContext, } from './core/GPUContext';
+export { GPUContext } from './core/GPUContext';
+export type { RenderSchedulerState, RenderCallback } from './core/RenderScheduler';
+export { createRenderScheduler, createRenderSchedulerAsync, startRenderScheduler, stopRenderScheduler, requestRender, destroyRenderScheduler, } from './core/RenderScheduler';
+export { RenderScheduler } from './core/RenderScheduler';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,OAAO,UAAU,CAAC;AAG/B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,cAAc,IAAI,WAAW,EAAE,MAAM,YAAY,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,4BAA4B,EAC5B,qBAAqB,EACrB,6BAA6B,GAC9B,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,UAAU,EACV,QAAQ,EACR,eAAe,EACf,cAAc,EACd,SAAS,EACT,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,SAAS,EACT,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,eAAe,EACf,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,UAAU,EACV,aAAa,GACd,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzE,YAAY,EACV,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,EACvB,kBAAkB,EAClB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AAGjC,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC3D,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAG1C,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGjE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAG9D,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,EACX,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/C,YAAY,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACnF,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAC1B,oBAAoB,EACpB,mBAAmB,EACnB,aAAa,EACb,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC"}