chartgpu 0.2.2 → 0.2.4

package/dist/core/renderCoordinator/utils/boundsComputation.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Bounds computation utilities for the RenderCoordinator.
+ *
+ * These pure functions compute xMin/xMax/yMin/yMax bounds from data arrays
+ * and aggregate bounds across series. They handle edge cases like empty data,
+ * NaN/Infinity values, and zero-span domains.
+ *
+ * @module boundsComputation
+ */
+import type { DataPoint, OHLCDataPoint } from '../../../config/types';
+import type { ResolvedChartGPUOptions } from '../../../config/OptionResolver';
+/**
+ * Bounds type for min/max x and y values.
+ */
+export type Bounds = Readonly<{
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}>;
+/**
+ * Computes xMin/xMax/yMin/yMax bounds from cartesian data array.
+ * Skips non-finite values. Returns null if no finite points found.
+ * Ensures xMin !== xMax and yMin !== yMax for scale derivation.
+ *
+ * @param data - Array of data points (tuple or object format)
+ * @returns Bounds object or null if no finite points
+ */
+export declare const computeRawBoundsFromData: (data: ReadonlyArray<DataPoint>) => Bounds | null;
+/**
+ * Extends existing bounds with new cartesian data points.
+ * If bounds is null and points are valid, seeds bounds from points.
+ *
+ * @param bounds - Existing bounds or null
+ * @param points - New points to extend bounds with
+ * @returns Updated bounds or null if no finite points
+ */
+export declare const extendBoundsWithDataPoints: (bounds: Bounds | null, points: ReadonlyArray<DataPoint>) => Bounds | null;
+/**
+ * Extends bounds with OHLC candlestick data using low/high values.
+ * If bounds is null, initializes bounds from OHLC points.
+ *
+ * @param bounds - Existing bounds or null
+ * @param points - OHLC points (timestamp, open, high, low, close)
+ * @returns Updated bounds or original bounds if no finite points
+ */
+export declare const extendBoundsWithOHLCDataPoints: (bounds: Bounds | null, points: ReadonlyArray<OHLCDataPoint>) => Bounds | null;
+/**
+ * Aggregates bounds across all series, handling pie/candlestick special cases.
+ * Prefers precomputed rawBounds from OptionResolver when available to avoid O(n) scans.
+ *
+ * @param series - Resolved series configurations
+ * @param runtimeRawBoundsByIndex - Optional runtime bounds (used for streaming appends)
+ * @returns Global bounds across all series, defaults to (0,1) x (0,1) if no finite data
+ */
+export declare const computeGlobalBounds: (series: ResolvedChartGPUOptions["series"], runtimeRawBoundsByIndex?: ReadonlyArray<Bounds | null> | null) => Bounds;
+/**
+ * Ensures min ≤ max, handles infinities with defaults (0,1), handles zero-span domains.
+ * Returns a usable domain for scale derivation.
+ *
+ * @param minCandidate - Candidate minimum value
+ * @param maxCandidate - Candidate maximum value
+ * @returns Normalized domain with min ≤ max, both finite
+ */
+export declare const normalizeDomain: (minCandidate: number, maxCandidate: number) => {
+    readonly min: number;
+    readonly max: number;
+};
+//# sourceMappingURL=boundsComputation.d.ts.map

package/dist/core/renderCoordinator/utils/boundsComputation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundsComputation.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/utils/boundsComputation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAI9E;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE1F;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,GAAI,MAAM,aAAa,CAAC,SAAS,CAAC,KAAG,MAAM,GAAG,IAwBlF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,GAAI,QAAQ,MAAM,GAAG,IAAI,EAAE,QAAQ,aAAa,CAAC,SAAS,CAAC,KAAG,MAAM,GAAG,IA8B7G,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,GAAI,QAAQ,MAAM,GAAG,IAAI,EAAE,QAAQ,aAAa,CAAC,aAAa,CAAC,KAAG,MAAM,GAAG,IA8BrH,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,uBAAuB,CAAC,QAAQ,CAAC,EACzC,0BAA0B,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,KAC5D,MAuGF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAC1B,cAAc,MAAM,EACpB,cAAc,MAAM,KACnB;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAkB9C,CAAC"}

package/dist/core/renderCoordinator/utils/canvasUtils.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Canvas sizing and measurement utilities for the RenderCoordinator.
+ *
+ * These pure functions handle canvas dimension retrieval with special handling
+ * for device pixel ratio and GPU overlay coordinate conversions.
+ *
+ * @module canvasUtils
+ */
+/**
+ * Gets canvas CSS width - clientWidth for HTMLCanvasElement.
+ *
+ * @param canvas - The canvas element to measure, or null
+ * @returns CSS width in pixels, or 0 if canvas is null
+ */
+export declare function getCanvasCssWidth(canvas: HTMLCanvasElement | null): number;
+/**
+ * Gets canvas CSS height - clientHeight for HTMLCanvasElement.
+ *
+ * @param canvas - The canvas element to measure, or null
+ * @returns CSS height in pixels, or 0 if canvas is null
+ */
+export declare function getCanvasCssHeight(canvas: HTMLCanvasElement | null): number;
+/**
+ * Gets canvas CSS size derived strictly from device-pixel dimensions and DPR.
+ *
+ * This is intentionally different from `getCanvasCssWidth/Height(...)`:
+ * - HTMLCanvasElement: `clientWidth/clientHeight` reflect DOM layout and can diverge (rounding, zoom, async resize)
+ *   from the WebGPU render target size (`canvas.width/height` in device pixels).
+ * - For GPU overlays that round-trip CSS↔device pixels in-shader, we must derive CSS size from
+ *   `canvas.width/height` + DPR to keep transforms consistent with the render target.
+ *
+ * NOTE: Use this for GPU overlay coordinate conversion only (reference lines, markers).
+ * Keep DOM overlays (labels/tooltips) using `clientWidth/clientHeight` for layout correctness.
+ *
+ * @param canvas - The canvas element to measure, or null
+ * @param devicePixelRatio - The device pixel ratio (defaults to window.devicePixelRatio or 1)
+ * @returns Object with width and height in CSS pixels derived from device pixels
+ */
+export declare function getCanvasCssSizeFromDevicePixels(canvas: HTMLCanvasElement | null, devicePixelRatio?: number): Readonly<{
+    width: number;
+    height: number;
+}>;
+/**
+ * Clamps a value to an integer within [lo, hi] range.
+ *
+ * @param v - Value to clamp
+ * @param lo - Lower bound (inclusive)
+ * @param hi - Upper bound (inclusive)
+ * @returns Clamped integer value
+ */
+export declare function clampInt(v: number, lo: number, hi: number): number;
+//# sourceMappingURL=canvasUtils.d.ts.map

package/dist/core/renderCoordinator/utils/canvasUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvasUtils.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/utils/canvasUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,GAAG,MAAM,CAM1E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,GAAG,MAAM,CAM3E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,iBAAiB,GAAG,IAAI,EAChC,gBAAgB,GAAE,MAAoE,GACrF,QAAQ,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAK7C;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAElE"}

package/dist/core/renderCoordinator/utils/dataPointUtils.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Data point type guards and utilities for the RenderCoordinator.
+ *
+ * These pure functions handle the dual data format system (tuple vs object)
+ * and provide type-safe access to point coordinates.
+ *
+ * @module dataPointUtils
+ */
+import type { DataPoint, DataPointTuple, OHLCDataPoint, OHLCDataPointTuple } from '../../../config/types';
+/**
+ * Validates that a number is finite, returning the number or null.
+ *
+ * @param v - Value to validate
+ * @returns The number if finite, otherwise null
+ */
+export declare const finiteOrNull: (v: number | null | undefined) => number | null;
+/**
+ * Validates that a number is finite, returning the number or undefined.
+ *
+ * @param v - Value to validate
+ * @returns The number if finite, otherwise undefined
+ */
+export declare const finiteOrUndefined: (v: number | undefined) => number | undefined;
+/**
+ * Compile-time exhaustiveness check for error handling.
+ * Used in switch statements to ensure all cases are handled.
+ *
+ * @param value - The value that should be of type `never` if all cases are handled
+ * @throws Always throws an error if called
+ */
+export declare const assertUnreachable: (value: never) => never;
+/**
+ * Type guard: checks if a DataPoint is in tuple form `[x, y]`.
+ *
+ * @param p - The data point to check
+ * @returns True if the point is a tuple, false if it's an object
+ */
+export declare const isTupleDataPoint: (p: DataPoint) => p is DataPointTuple;
+/**
+ * Extracts x,y coordinates from either tuple or object point format.
+ *
+ * @param p - The data point (either tuple or object format)
+ * @returns Object with x and y properties
+ */
+export declare const getPointXY: (p: DataPoint) => {
+    readonly x: number;
+    readonly y: number;
+};
+/**
+ * Type guard: checks if a data point is in tuple OHLC form `[timestamp, open, high, low, close]`.
+ *
+ * @param p - The OHLC data point to check
+ * @returns True if the point is a tuple, false if it's an object
+ */
+export declare const isTupleOHLCDataPoint: (p: OHLCDataPoint) => p is OHLCDataPointTuple;
+/**
+ * Type guard: checks if a data point is in tuple form `[x, y]` (for individual points).
+ *
+ * @param p - The point to check
+ * @returns True if the point is a tuple array
+ */
+export declare const isTuplePoint: (p: unknown) => p is readonly [number, number];
+/**
+ * Type guard: checks if entire data array is in tuple format.
+ * Only checks the first element for performance.
+ *
+ * @param data - Array of data points to check
+ * @returns True if first element (and therefore likely all) is a tuple
+ */
+export declare const isTupleDataArray: (data: ReadonlyArray<DataPoint>) => data is ReadonlyArray<DataPointTuple>;
+//# sourceMappingURL=dataPointUtils.d.ts.map

package/dist/core/renderCoordinator/utils/dataPointUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataPointUtils.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/utils/dataPointUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE1G;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,MAAM,GAAG,IACb,CAAC;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,GAAG,MAAM,GAAG,SAAS,KAAG,MAAM,GAAG,SACN,CAAC;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,KAAK,KAAG,KAGhD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,SAAS,KAAG,CAAC,IAAI,cAAkC,CAAC;AAExF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,GAAG,SAAS,KAAG;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAGjF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,GAAG,aAAa,KAAG,CAAC,IAAI,kBAAsC,CAAC;AAEpG;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,SAAS,CAAC,MAAM,EAAE,MAAM,CAAqB,CAAC;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,aAAa,CAAC,SAAS,CAAC,KAAG,IAAI,IAAI,aAAa,CAAC,cAAc,CACxD,CAAC"}

package/dist/core/renderCoordinator/utils/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Utility functions for the RenderCoordinator.
+ * Pure, stateless helper functions organized by category.
+ *
+ * @module utils
+ */
+export * from './canvasUtils';
+export * from './dataPointUtils';
+export * from './boundsComputation';
+export * from './axisUtils';
+export * from './timeAxisUtils';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/renderCoordinator/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,eAAe,CAAC;AAG9B,cAAc,kBAAkB,CAAC;AAGjC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,aAAa,CAAC;AAG5B,cAAc,iBAAiB,CAAC"}

package/dist/core/renderCoordinator/utils/timeAxisUtils.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Time axis and formatting utilities for the RenderCoordinator.
+ *
+ * These pure functions handle time-based tick generation, adaptive label formatting,
+ * and number/percentage parsing for pie chart configuration.
+ *
+ * @module timeAxisUtils
+ */
+import type { LinearScale } from '../../../utils/scales';
+import type { PieCenter, PieRadius } from '../../../config/types';
+/**
+ * Time constants for axis formatting decisions.
+ */
+export declare const MS_PER_DAY: number;
+export declare const MS_PER_MONTH_APPROX: number;
+export declare const MS_PER_YEAR_APPROX: number;
+/**
+ * Tick configuration constants.
+ */
+export declare const MAX_TIME_X_TICK_COUNT = 9;
+export declare const MIN_TIME_X_TICK_COUNT = 1;
+export declare const MIN_X_LABEL_GAP_CSS_PX = 6;
+export declare const DEFAULT_MAX_TICK_FRACTION_DIGITS = 6;
+export declare const DEFAULT_TICK_COUNT = 5;
+/**
+ * English month abbreviations for time axis labels.
+ */
+export declare const MONTH_SHORT_EN: readonly string[];
+/**
+ * Parses value as number or percentage string, returns null if invalid.
+ * Used for pie chart center and radius configuration.
+ *
+ * @param value - Number or percentage string (e.g. "50%", "120", 120)
+ * @param basis - Basis value for percentage calculation
+ * @returns Parsed number or null if invalid
+ */
+export declare const parseNumberOrPercent: (value: number | string, basis: number) => number | null;
+/**
+ * Resolves pie center from mixed number/string/percent format.
+ * Defaults to center of plot area (50%, 50%).
+ *
+ * @param center - Pie center configuration or undefined
+ * @param plotWidthCss - Plot area width in CSS pixels
+ * @param plotHeightCss - Plot area height in CSS pixels
+ * @returns Resolved center coordinates in CSS pixels
+ */
+export declare const resolvePieCenterPlotCss: (center: PieCenter | undefined, plotWidthCss: number, plotHeightCss: number) => {
+    readonly x: number;
+    readonly y: number;
+};
+/**
+ * Type guard for pie radius tuple format `[inner, outer]`.
+ *
+ * @param radius - Pie radius configuration
+ * @returns True if radius is a tuple
+ */
+export declare const isPieRadiusTuple: (radius: PieRadius) => radius is readonly [inner: number | string, outer: number | string];
+/**
+ * Resolves pie inner/outer radii with defaults, bounds checking.
+ * Default outer radius is 70% of max, inner radius is 0 (full pie).
+ *
+ * @param radius - Pie radius configuration or undefined
+ * @param maxRadiusCss - Maximum radius in CSS pixels
+ * @returns Resolved inner and outer radii in CSS pixels
+ */
+export declare const resolvePieRadiiCss: (radius: PieRadius | undefined, maxRadiusCss: number) => {
+    readonly inner: number;
+    readonly outer: number;
+};
+/**
+ * Calculates decimal precision needed for clean tick formatting from tick step.
+ * Prefers "clean" decimal representations (e.g. 2.5, 0.25, 0.125) without relying on magnitude alone.
+ *
+ * @param tickStep - Step size between ticks
+ * @param cap - Maximum fraction digits to return (default 6)
+ * @returns Number of fraction digits for formatting
+ */
+export declare const computeMaxFractionDigitsFromStep: (tickStep: number, cap?: number) => number;
+/**
+ * Creates Intl.NumberFormat instance for consistent tick formatting.
+ * Automatically computes appropriate fraction digits from tick step.
+ *
+ * @param tickStep - Step size between ticks
+ * @returns NumberFormat instance
+ */
+export declare const createTickFormatter: (tickStep: number) => Intl.NumberFormat;
+/**
+ * Formats numeric value using NumberFormat, handles -0 and NaN edge cases.
+ *
+ * @param nf - NumberFormat instance
+ * @param v - Value to format
+ * @returns Formatted string or null if invalid
+ */
+export declare const formatTickValue: (nf: Intl.NumberFormat, v: number) => string | null;
+/**
+ * Pads single-digit numbers with leading zero (used by time formatting).
+ *
+ * @param n - Number to pad
+ * @returns Zero-padded string (minimum 2 digits)
+ */
+export declare const pad2: (n: number) => string;
+/**
+ * Formats millisecond timestamps with adaptive precision based on visible range.
+ * Format tiers:
+ * - < 1 day: HH:mm
+ * - 1-7 days: MM/DD HH:mm
+ * - 1-12 weeks (up to ~3 months): MM/DD
+ * - 3-12 months: MMM DD
+ * - > 1 year: YYYY/MM
+ *
+ * @param timestampMs - Timestamp in milliseconds
+ * @param visibleRangeMs - Visible range width in milliseconds
+ * @returns Formatted time string or null if invalid
+ */
+export declare const formatTimeTickValue: (timestampMs: number, visibleRangeMs: number) => string | null;
+/**
+ * Generates evenly-spaced tick values across domain.
+ *
+ * @param domainMin - Domain minimum value
+ * @param domainMax - Domain maximum value
+ * @param tickCount - Number of ticks to generate
+ * @returns Array of tick values
+ */
+export declare const generateLinearTicks: (domainMin: number, domainMax: number, tickCount: number) => number[];
+/**
+ * Computes optimal tick count + values to avoid label overlap on time x-axis.
+ * Uses text measurement context to test label widths.
+ * Tries tick counts from MAX (9) down to MIN (1) until labels fit without overlap.
+ *
+ * @param params - Configuration object with axis, scale, canvas, and measurement settings
+ * @returns Object with tickCount and tickValues
+ */
+export declare const computeAdaptiveTimeXAxisTicks: (params: {
+    readonly axisMin: number | null;
+    readonly axisMax: number | null;
+    readonly xScale: LinearScale;
+    readonly plotClipLeft: number;
+    readonly plotClipRight: number;
+    readonly canvasCssWidth: number;
+    readonly visibleRangeMs: number;
+    readonly measureCtx: CanvasRenderingContext2D | null;
+    readonly measureCache?: Map<string, number>;
+    readonly fontSize: number;
+    readonly fontFamily: string;
+}) => {
+    readonly tickCount: number;
+    readonly tickValues: readonly number[];
+};
+//# sourceMappingURL=timeAxisUtils.d.ts.map

package/dist/core/renderCoordinator/utils/timeAxisUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeAxisUtils.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/utils/timeAxisUtils.ts"],"names":[],"mappings":"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"}

package/dist/core/renderCoordinator/zoom/zoomHelpers.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Zoom helper utilities for domain calculations and zoom state checks.
+ *
+ * Provides pure functions for computing visible domains from zoom ranges,
+ * checking full-span zoom states, and other zoom-related calculations.
+ *
+ * @module zoomHelpers
+ */
+import type { ZoomRange } from '../../../interaction/createZoomState';
+/**
+ * Domain boundaries with min and max values.
+ */
+export interface DomainBounds {
+    readonly min: number;
+    readonly max: number;
+}
+/**
+ * Visible domain with span fraction for performance optimization hints.
+ */
+export interface VisibleDomain extends DomainBounds {
+    /**
+     * Fraction of the base domain that is visible (0 to 1).
+     * Used to determine if full-resolution data can be used.
+     */
+    readonly spanFraction: number;
+}
+/**
+ * Computes the visible X domain from base domain and zoom range.
+ *
+ * Converts a percent-space zoom range [0-100] to actual domain coordinates.
+ * Returns the full base domain when zoom is null/undefined or full-span.
+ *
+ * @param baseDomain - The complete data domain (unzoomed)
+ * @param zoomRange - Zoom window in percent space [0-100], or null for full view
+ * @returns Visible domain with min, max, and span fraction
+ *
+ * @example
+ * ```ts
+ * const baseDomain = { min: 0, max: 1000 };
+ * const zoomRange = { start: 25, end: 75 };
+ * const visible = computeVisibleDomain(baseDomain, zoomRange);
+ * // Returns: { min: 250, max: 750, spanFraction: 0.5 }
+ * ```
+ */
+export declare function computeVisibleDomain(baseDomain: DomainBounds, zoomRange?: ZoomRange | null): VisibleDomain;
+/**
+ * Checks if a zoom range represents a full-span (unzoomed) view.
+ *
+ * A zoom is considered full-span if:
+ * - Range is null/undefined
+ * - Start is at or before 0% AND end is at or after 100%
+ *
+ * Small tolerance (0.5%) is applied to account for floating-point arithmetic
+ * and UI imprecision (e.g., slider at edge).
+ *
+ * @param zoomRange - Zoom window to check, or null
+ * @returns True if the zoom represents a full-span view
+ *
+ * @example
+ * ```ts
+ * isFullSpanZoom(null);                        // true
+ * isFullSpanZoom({ start: 0, end: 100 });      // true
+ * isFullSpanZoom({ start: -0.1, end: 100.1 }); // true (tolerance)
+ * isFullSpanZoom({ start: 25, end: 75 });      // false
+ * ```
+ */
+export declare function isFullSpanZoom(zoomRange: ZoomRange | null | undefined): boolean;
+/**
+ * Computes a buffer zone around the visible domain for data caching.
+ *
+ * Adds a percentage buffer on each side of the visible domain to cache
+ * extra data points for smooth panning. This reduces resampling frequency
+ * when the user pans slightly beyond the current view.
+ *
+ * @param visibleDomain - Current visible domain
+ * @param bufferPercent - Buffer percentage (0 to 1), default 0.1 (10%)
+ * @returns Buffered domain bounds
+ *
+ * @example
+ * ```ts
+ * const visible = { min: 100, max: 200 };
+ * const buffered = computeBufferedDomain(visible, 0.1);
+ * // Returns: { min: 90, max: 210 } (±10% buffer)
+ * ```
+ */
+export declare function computeBufferedDomain(visibleDomain: DomainBounds, bufferPercent?: number): DomainBounds;
+/**
+ * Converts a domain coordinate to percent-space relative to base domain.
+ *
+ * Useful for converting mouse positions or data coordinates to zoom range
+ * percentages for zoom/pan operations.
+ *
+ * @param value - Domain coordinate to convert
+ * @param baseDomain - Base domain for reference
+ * @returns Percent value [0-100]
+ *
+ * @example
+ * ```ts
+ * const percent = domainValueToPercent(500, { min: 0, max: 1000 });
+ * // Returns: 50
+ * ```
+ */
+export declare function domainValueToPercent(value: number, baseDomain: DomainBounds): number;
+/**
+ * Converts a percent-space value to domain coordinate.
+ *
+ * Inverse of `domainValueToPercent`. Useful for converting zoom range
+ * percentages back to domain coordinates.
+ *
+ * @param percent - Percent value [0-100]
+ * @param baseDomain - Base domain for reference
+ * @returns Domain coordinate
+ *
+ * @example
+ * ```ts
+ * const value = percentToDomainValue(50, { min: 0, max: 1000 });
+ * // Returns: 500
+ * ```
+ */
+export declare function percentToDomainValue(percent: number, baseDomain: DomainBounds): number;
+/**
+ * Calculates the zoom span (in percent) from a domain window.
+ *
+ * @param windowDomain - The zoomed window domain
+ * @param baseDomain - The full base domain
+ * @returns Span in percent [0-100]
+ */
+export declare function calculateZoomSpan(windowDomain: DomainBounds, baseDomain: DomainBounds): number;
+//# sourceMappingURL=zoomHelpers.d.ts.map

package/dist/core/renderCoordinator/zoom/zoomHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoomHelpers.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/zoom/zoomHelpers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,YAAY,EACxB,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAC3B,aAAa,CAsBf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAS/E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,YAAY,EAC3B,aAAa,GAAE,MAAY,GAC1B,YAAY,CAWd;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,GAAG,MAAM,CAMpF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,GAAG,MAAM,CAGtF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,GAAG,MAAM,CAQ9F"}

package/dist/data/cartesianData.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Internal cartesian data abstraction for CartesianSeriesData.
+ *
+ * Provides high-performance, allocation-minimizing primitives to support all three cartesian formats:
+ * - ReadonlyArray<DataPoint> (tuple or object)
+ * - XYArraysData (separate x/y/size arrays)
+ * - InterleavedXYData (typed array view with [x0,y0,x1,y1,...] layout)
+ *
+ * DO NOT export from public entrypoint (src/index.ts). This is internal-only.
+ *
+ * @module cartesianData
+ * @internal
+ */
+import type { CartesianSeriesData } from '../config/types';
+/**
+ * Bounds type for min/max x and y values.
+ */
+export type Bounds = Readonly<{
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}>;
+/**
+ * Returns the number of points in the CartesianSeriesData.
+ */
+export declare function getPointCount(data: CartesianSeriesData): number;
+/**
+ * Returns the x-coordinate of the point at index i.
+ */
+export declare function getX(data: CartesianSeriesData, i: number): number;
+/**
+ * Returns the y-coordinate of the point at index i.
+ */
+export declare function getY(data: CartesianSeriesData, i: number): number;
+/**
+ * Returns the size value of the point at index i, or undefined if not available.
+ * Note: InterleavedXYData does NOT support interleaved size (use XYArraysData.size if needed).
+ */
+export declare function getSize(data: CartesianSeriesData, i: number): number | undefined;
+/**
+ * Packs XY coordinates from CartesianSeriesData into a Float32Array in interleaved layout.
+ *
+ * Writes `pointCount` points starting at `srcPointOffset` in the source data
+ * into `out` starting at `outFloatOffset` (measured in float32 elements, not bytes).
+ *
+ * Each point writes 2 floats: [x - xOffset, y].
+ * Size dimension is NOT packed (use getSize() separately if needed).
+ *
+ * @param out - Target Float32Array to write into
+ * @param outFloatOffset - Starting offset in `out` (in float32 elements)
+ * @param src - Source CartesianSeriesData
+ * @param srcPointOffset - Starting point index in source
+ * @param pointCount - Number of points to pack
+ * @param xOffset - Value to subtract from x coordinates (for Float32 precision preservation)
+ */
+export declare function packXYInto(out: Float32Array, outFloatOffset: number, src: CartesianSeriesData, srcPointOffset: number, pointCount: number, xOffset: number): void;
+/**
+ * Computes xMin/xMax/yMin/yMax bounds from CartesianSeriesData.
+ * Skips non-finite x or y values. Returns null if no finite points found.
+ * Ensures xMin !== xMax and yMin !== yMax for scale derivation (expands max by +1 if needed).
+ *
+ * @param data - CartesianSeriesData in any supported format
+ * @returns Bounds object or null if no finite points
+ */
+export declare function computeRawBoundsFromCartesianData(data: CartesianSeriesData): Bounds | null;
+//# sourceMappingURL=cartesianData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianData.d.ts","sourceRoot":"","sources":["../../src/data/cartesianData.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAA8C,MAAM,iBAAiB,CAAC;AAEvG;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAqD1F;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,CAmB/D;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBjE;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBjE;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAahF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,YAAY,EACjB,cAAc,EAAE,MAAM,EACtB,GAAG,EAAE,mBAAmB,EACxB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd,IAAI,CAsDN;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,GAAG,IAAI,CAkE1F"}

package/dist/data/createDataStore.d.ts

@@ -1,6 +1,6 @@
-import type { DataPoint } from '../config/types';
+import type { CartesianSeriesData } from '../config/types';
 export interface DataStore {
-    setSeries(index: number, data: ReadonlyArray<DataPoint>, options?: Readonly<{
+    setSeries(index: number, data: CartesianSeriesData, options?: Readonly<{
         xOffset?: number;
     }>): void;
     /**
@@ -8,11 +8,11 @@ export interface DataStore {
      *
      * - 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.
+     * - Maintains `pointCount` for render path queries.
      *
      * Throws if the series has not been set yet.
      */
-    appendSeries(index: number, newPoints: ReadonlyArray<DataPoint>): void;
+    appendSeries(index: number, newPoints: CartesianSeriesData): void;
     removeSeries(index: number): void;
     getSeriesBuffer(index: number): GPUBuffer;
     /**
@@ -21,14 +21,6 @@ export interface DataStore {
      * 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;

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

@@ -1 +1 @@
-{"version":3,"file":"createDataStore.d.ts","sourceRoot":"","sources":["../../src/data/createDataStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,iBAAiB,CAAC;AAGjE,MAAM,WAAW,SAAS;IACxB,SAAS,CACP,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,EAC9B,OAAO,CAAC,EAAE,QAAQ,CAAC;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GACvC,IAAI,CAAC;IACR;;;;;;;;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;AAsDD,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAgP5D"}
+{"version":3,"file":"createDataStore.d.ts","sourceRoot":"","sources":["../../src/data/createDataStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG3D,MAAM,WAAW,SAAS;IACxB,SAAS,CACP,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,mBAAmB,EACzB,OAAO,CAAC,EAAE,QAAQ,CAAC;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GACvC,IAAI,CAAC;IACR;;;;;;;;OAQG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClE,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,OAAO,IAAI,IAAI,CAAC;CACjB;AAyDD,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CA2O5D"}

package/dist/data/sampleSeries.d.ts

@@ -1,3 +1,20 @@
-import type { DataPoint, SeriesSampling } from '../config/types';
-export declare function sampleSeriesDataPoints(data: ReadonlyArray<DataPoint>, sampling: SeriesSampling, samplingThreshold: number): ReadonlyArray<DataPoint>;
+import type { CartesianSeriesData, SeriesSampling } from '../config/types';
+/**
+ * Samples CartesianSeriesData using the specified sampling strategy.
+ *
+ * Returns the ORIGINAL data reference when:
+ * - `sampling === 'none'`
+ * - `samplingThreshold` is invalid/non-positive
+ * - Point count <= threshold
+ *
+ * When sampling occurs:
+ * - For `lttb`:
+ *   - Float32Array interleaved → returns sampled Float32Array
+ *   - Other interleaved typed array → packs to Float32Array, returns sampled Float32Array
+ *   - DataPoint[] → returns sampled DataPoint[]
+ *   - XYArraysData → packs to Float32Array, returns sampled Float32Array
+ * - For `average`/`max`/`min`:
+ *   - Returns DataPointTuple[] for all input formats
+ */
+export declare function sampleSeriesDataPoints(data: CartesianSeriesData, sampling: SeriesSampling, samplingThreshold: number): CartesianSeriesData;
 //# sourceMappingURL=sampleSeries.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"sampleSeries.d.ts","sourceRoot":"","sources":["../../src/data/sampleSeries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAkB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAoM3F;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,mBAAmB,EACzB,QAAQ,EAAE,cAAc,EACxB,iBAAiB,EAAE,MAAM,GACxB,mBAAmB,CA8CrB"}