@chartgpu/chartgpu 0.2.5

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,72 @@
+/**
+ * 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.
+ * Returns NaN if the point is undefined, null, or non-object (for DataPoint[] format).
+ * This allows callers using `Number.isFinite()` to naturally skip missing points.
+ */
+export declare function getX(data: CartesianSeriesData, i: number): number;
+/**
+ * Returns the y-coordinate of the point at index i.
+ * Returns NaN if the point is undefined, null, or non-object (for DataPoint[] format).
+ * This allows callers using `Number.isFinite()` to naturally skip missing points.
+ */
+export declare function getY(data: CartesianSeriesData, i: number): number;
+/**
+ * Returns the size value of the point at index i, or undefined if not available.
+ * Returns undefined if the point is undefined, null, or non-object (for DataPoint[] format).
+ * 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;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAoBjE;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAoBjE;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAiBhF;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,CA6DN;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,GAAG,IAAI,CAkE1F"}

package/dist/data/createDataStore.d.ts

@@ -0,0 +1,27 @@
+import type { CartesianSeriesData } from '../config/types';
+export interface DataStore {
+    setSeries(index: number, data: CartesianSeriesData, options?: Readonly<{
+        xOffset?: number;
+    }>): 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` for render path queries.
+     *
+     * Throws if the series has not been set yet.
+     */
+    appendSeries(index: number, newPoints: CartesianSeriesData): 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;
+    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,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/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/ohlcSample.d.ts

@@ -0,0 +1,21 @@
+import type { OHLCDataPoint } from '../config/types';
+/**
+ * Downsamples OHLC (candlestick) data to a target number of points using bucket aggregation.
+ *
+ * Each bucket aggregates candles preserving OHLC semantics:
+ * - timestamp and open from the first candle in the bucket
+ * - close from the last candle in the bucket
+ * - high as the maximum of all highs in the bucket
+ * - low as the minimum of all lows in the bucket
+ *
+ * @param data - Array of OHLC data points (tuples or objects)
+ * @param targetPoints - Desired number of output points
+ * @returns Downsampled array; same reference if no sampling needed
+ *
+ * Edge cases:
+ * - If `data.length <= targetPoints` or `targetPoints < 2`, returns the original array (same reference)
+ * - First and last candles are always preserved exactly (same element references)
+ * - Output shape matches input shape (tuples → tuples, objects → objects)
+ */
+export declare function ohlcSample(data: ReadonlyArray<OHLCDataPoint>, targetPoints: number): ReadonlyArray<OHLCDataPoint>;
+//# sourceMappingURL=ohlcSample.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ohlcSample.d.ts","sourceRoot":"","sources":["../../src/data/ohlcSample.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAsB,MAAM,iBAAiB,CAAC;AAMzE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,aAAa,CAAC,aAAa,CAAC,EAClC,YAAY,EAAE,MAAM,GACnB,aAAa,CAAC,aAAa,CAAC,CAgG9B"}

package/dist/data/packDataPoints.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Data point packing utilities for GPU buffer uploads.
+ *
+ * Internal utilities that convert high-level DataPoint/OHLCDataPoint arrays into
+ * interleaved Float32Array buffers suitable for direct GPU buffer uploads via
+ * `queue.writeBuffer()`.
+ *
+ * @module packDataPoints
+ * @internal
+ */
+import type { DataPoint, OHLCDataPoint } from '../config/types';
+/**
+ * Packs DataPoint array into an interleaved Float32Array for GPU buffer uploads.
+ *
+ * **Internal utility** used by data store for efficient GPU buffer management.
+ *
+ * **Format**: `[x0, y0, x1, y1, x2, y2, ...]` (2 floats per point = 8 bytes stride)
+ *
+ * @param points - Array of data points (tuple or object form)
+ * @returns Interleaved Float32Array [x0,y0,x1,y1,...] for GPU vertex buffer upload
+ * @throws {TypeError} If points is null, undefined, or not an array
+ * @throws {RangeError} If points array is empty or contains invalid values
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * const points = [{ x: 0, y: 10 }, { x: 1, y: 20 }];
+ * const packed = packDataPoints(points);
+ * // packed = Float32Array[0, 10, 1, 20]
+ *
+ * // Upload to GPU buffer:
+ * device.queue.writeBuffer(vertexBuffer, 0, packed.buffer);
+ * ```
+ */
+export declare function packDataPoints(points: ReadonlyArray<DataPoint>): Float32Array;
+/**
+ * Packs OHLCDataPoint array into an interleaved Float32Array for GPU buffer uploads.
+ *
+ * **Internal utility** used by data store for efficient candlestick GPU buffer management.
+ *
+ * **Format**: `[t0, o0, h0, l0, c0, t1, o1, h1, l1, c1, ...]` (5 floats per point = 20 bytes stride)
+ *
+ * Order follows ECharts convention: timestamp, open, high, low, close (t, o, h, l, c).
+ *
+ * @param points - Array of OHLC data points (tuple or object form)
+ * @returns Interleaved Float32Array [t0,o0,h0,l0,c0,t1,...] for GPU vertex buffer upload
+ * @throws {TypeError} If points is null, undefined, or not an array
+ * @throws {RangeError} If points array is empty or contains invalid values
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * const ohlcPoints = [
+ *   { timestamp: 1000, open: 100, high: 110, low: 95, close: 105 },
+ *   { timestamp: 2000, open: 105, high: 115, low: 100, close: 110 }
+ * ];
+ * const packed = packOHLCDataPoints(ohlcPoints);
+ * // packed = Float32Array[1000, 100, 110, 95, 105, 2000, 105, 115, 100, 110]
+ *
+ * // Upload to GPU buffer:
+ * device.queue.writeBuffer(vertexBuffer, 0, packed.buffer);
+ * ```
+ */
+export declare function packOHLCDataPoints(points: ReadonlyArray<OHLCDataPoint>): Float32Array;
+//# sourceMappingURL=packDataPoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"packDataPoints.d.ts","sourceRoot":"","sources":["../../src/data/packDataPoints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAkB,MAAM,iBAAiB,CAAC;AAiBhF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,YAAY,CA2D7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,YAAY,CAiGrF"}

package/dist/data/sampleSeries.d.ts

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1 @@
+{"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"}