chartgpu 0.2.2 → 0.2.3

package/dist/core/renderCoordinator/ui/tooltipLegendHelpers.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Tooltip and legend helper utilities.
+ *
+ * Provides utilities for managing tooltip state, caching content to avoid
+ * unnecessary DOM updates, and computing tooltip anchor positions for special
+ * chart types like candlesticks.
+ *
+ * @module tooltipLegendHelpers
+ */
+import type { OHLCDataPoint } from '../../../config/types';
+import type { LinearScale } from '../../../utils/scales';
+/**
+ * Tooltip anchor position in canvas-local CSS pixels.
+ */
+export interface TooltipAnchor {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Cached tooltip state for content deduplication.
+ *
+ * Tracks the last displayed content and position to avoid unnecessary DOM updates
+ * when the tooltip hasn't actually changed.
+ */
+export interface TooltipCache {
+    content: string | null;
+    x: number | null;
+    y: number | null;
+}
+/**
+ * Creates a new empty tooltip cache.
+ *
+ * @returns Fresh tooltip cache with null values
+ */
+export declare function createTooltipCache(): TooltipCache;
+/**
+ * Checks if tooltip content or position has changed.
+ *
+ * Returns true if any of the values differ from the cache, indicating that
+ * a DOM update is needed.
+ *
+ * @param cache - Current cached state
+ * @param content - New content to display
+ * @param x - New X position in CSS pixels
+ * @param y - New Y position in CSS pixels
+ * @returns True if update is needed (values differ from cache)
+ */
+export declare function shouldUpdateTooltip(cache: TooltipCache, content: string, x: number, y: number): boolean;
+/**
+ * Updates the tooltip cache with new values.
+ *
+ * Should be called after successfully updating the DOM to keep cache in sync.
+ *
+ * @param cache - Tooltip cache to update (mutated)
+ * @param content - New content that was displayed
+ * @param x - New X position that was set
+ * @param y - New Y position that was set
+ */
+export declare function updateTooltipCache(cache: TooltipCache, content: string, x: number, y: number): void;
+/**
+ * Clears the tooltip cache.
+ *
+ * Should be called when the tooltip is hidden to ensure fresh state
+ * when it's shown again.
+ *
+ * @param cache - Tooltip cache to clear (mutated)
+ */
+export declare function clearTooltipCache(cache: TooltipCache): void;
+/**
+ * Computes container-local CSS pixel anchor coordinates for a candlestick tooltip.
+ *
+ * The anchor is positioned near the candle body center for stable tooltip positioning
+ * even when the cursor is at the edge of the candlestick.
+ *
+ * Coordinate transformations:
+ * 1. Extract O/H/L/C from data point (tuple: [timestamp, open, close, low, high])
+ * 2. Compute body center Y = (open + close) / 2
+ * 3. Transform to clip space via scales
+ * 4. Convert clip space to canvas-local CSS pixels
+ * 5. Add container offset for absolute positioning
+ *
+ * Returns null if any coordinate computation fails (non-finite values).
+ *
+ * @param point - OHLC data point (tuple or object format)
+ * @param xScale - Linear scale for X axis
+ * @param yScale - Linear scale for Y axis
+ * @param canvasCssWidth - Canvas width in CSS pixels
+ * @param canvasCssHeight - Canvas height in CSS pixels
+ * @param offsetX - Container offset X in CSS pixels (default: 0)
+ * @param offsetY - Container offset Y in CSS pixels (default: 0)
+ * @returns Tooltip anchor position or null if computation fails
+ */
+export declare function computeCandlestickTooltipAnchor(point: OHLCDataPoint, xScale: LinearScale, yScale: LinearScale, canvasCssWidth: number, canvasCssHeight: number, offsetX?: number, offsetY?: number): TooltipAnchor | null;
+/**
+ * Determines if a data point is an OHLC/candlestick point.
+ *
+ * Checks if the point is a 5-element tuple (timestamp, open, close, low, high)
+ * or an object with OHLC properties.
+ *
+ * @param point - Data point to check
+ * @returns True if point is OHLC format
+ */
+export declare function isOHLCDataPoint(point: any): point is OHLCDataPoint;
+//# sourceMappingURL=tooltipLegendHelpers.d.ts.map

package/dist/core/renderCoordinator/ui/tooltipLegendHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltipLegendHelpers.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/ui/tooltipLegendHelpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIzD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAMjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,EACf,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,OAAO,CAET;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,EACf,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,IAAI,CAIN;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAI3D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,WAAW,EACnB,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,OAAO,GAAE,MAAU,EACnB,OAAO,GAAE,MAAU,GAClB,aAAa,GAAG,IAAI,CA0CtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,aAAa,CAclE"}

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

@@ -0,0 +1,122 @@
+/**
+ * Axis and grid utilities for the RenderCoordinator.
+ *
+ * These pure functions handle coordinate transformations between different spaces:
+ * - CSS pixels (DOM layout)
+ * - Device pixels (canvas.width/height)
+ * - Normalized device coordinates / clip space (WebGPU [-1, 1])
+ *
+ * @module axisUtils
+ */
+import type { GPUContextLike } from '../types';
+import type { ResolvedChartGPUOptions } from '../../../config/OptionResolver';
+import type { GridArea } from '../../../renderers/createGridRenderer';
+/**
+ * Computes grid area with margins and canvas dimensions for rendering layout.
+ * GridArea uses:
+ * - Margins (left, right, top, bottom) in CSS pixels
+ * - Canvas dimensions (canvasWidth, canvasHeight) in DEVICE pixels
+ * - devicePixelRatio for CSS-to-device conversion (worker-compatible)
+ *
+ * @param gpuContext - GPU context with canvas and device pixel ratio
+ * @param options - Resolved chart options with grid margins
+ * @returns GridArea object with margins, canvas dimensions, and DPR
+ * @throws If canvas is null or has invalid dimensions
+ */
+export declare const computeGridArea: (gpuContext: GPUContextLike, options: ResolvedChartGPUOptions) => GridArea;
+/**
+ * Converts RGBA normalized [0-1] values to CSS rgba() string.
+ *
+ * @param rgba - Array of [r, g, b, a] in range [0, 1]
+ * @returns CSS rgba() string
+ */
+export declare const rgba01ToCssRgba: (rgba: readonly [number, number, number, number]) => string;
+/**
+ * Applies alpha multiplier to CSS color.
+ * Parses color, multiplies alpha channel, and returns new CSS rgba() string.
+ *
+ * @param cssColor - CSS color string
+ * @param alphaMultiplier - Alpha multiplier in range [0, 1]
+ * @returns CSS rgba() string with modified alpha, or original color if parse fails
+ */
+export declare const withAlpha: (cssColor: string, alphaMultiplier: number) => string;
+/**
+ * Converts grid margins to normalized device clip coordinates for WebGPU.
+ * Output is in WebGPU clip space: [-1, 1] for both x and y.
+ * Y-axis is flipped (top is positive, bottom is negative).
+ *
+ * @param gridArea - Grid area with margins and canvas dimensions
+ * @returns Clip rect with left, right, top, bottom in range [-1, 1]
+ */
+export declare const computePlotClipRect: (gridArea: GridArea) => {
+    readonly left: number;
+    readonly right: number;
+    readonly top: number;
+    readonly bottom: number;
+};
+/**
+ * Clamps value to [0, 1] range.
+ *
+ * @param v - Value to clamp
+ * @returns Clamped value
+ */
+export declare const clamp01: (v: number) => number;
+/**
+ * Linear interpolation between two values with clamped t.
+ *
+ * @param a - Start value
+ * @param b - End value
+ * @param t01 - Interpolation parameter in range [0, 1]
+ * @returns Interpolated value
+ */
+export declare const lerp: (a: number, b: number, t01: number) => number;
+/**
+ * Interpolates between two domains (min/max pairs).
+ * Ensures result is a valid domain (min ≤ max, both finite).
+ *
+ * @param from - Start domain
+ * @param to - End domain
+ * @param t01 - Interpolation parameter in range [0, 1]
+ * @returns Interpolated domain
+ */
+export declare const lerpDomain: (from: {
+    readonly min: number;
+    readonly max: number;
+}, to: {
+    readonly min: number;
+    readonly max: number;
+}, t01: number) => {
+    readonly min: number;
+    readonly max: number;
+};
+/**
+ * Computes scissor rect in device pixels from grid margins.
+ * Used for WebGPU scissor testing to clip rendering to plot area.
+ *
+ * @param gridArea - Grid area with margins and canvas dimensions
+ * @returns Scissor rect with x, y, w, h in device pixels
+ */
+export declare const computePlotScissorDevicePx: (gridArea: GridArea) => {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+};
+/**
+ * Converts clip-space X to canvas CSS pixels (from normalized [-1, 1]).
+ *
+ * @param xClip - X coordinate in clip space [-1, 1]
+ * @param canvasCssWidth - Canvas width in CSS pixels
+ * @returns X coordinate in canvas CSS pixels
+ */
+export declare const clipXToCanvasCssPx: (xClip: number, canvasCssWidth: number) => number;
+/**
+ * Converts clip-space Y to canvas CSS pixels (from normalized [-1, 1]).
+ * Y-axis is flipped (1 is top, -1 is bottom).
+ *
+ * @param yClip - Y coordinate in clip space [-1, 1]
+ * @param canvasCssHeight - Canvas height in CSS pixels
+ * @returns Y coordinate in canvas CSS pixels
+ */
+export declare const clipYToCanvasCssPx: (yClip: number, canvasCssHeight: number) => number;
+//# sourceMappingURL=axisUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"axisUtils.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/utils/axisUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uCAAuC,CAAC;AAKtE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAAI,YAAY,cAAc,EAAE,SAAS,uBAAuB,KAAG,QA4C9F,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,KAAG,MAMjF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,UAAU,MAAM,EAAE,iBAAiB,MAAM,KAAG,MAKrE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAC9B,UAAU,QAAQ,KACjB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAmBhG,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,KAAG,MAAqC,CAAC;AAE1E;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,KAAK,MAAM,KAAG,MAAoC,CAAC;AAE9F;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GACrB,MAAM;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACpD,IAAI;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAClD,KAAK,MAAM,KACV;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAE9C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GACrC,UAAU,QAAQ,KACjB;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAgBlF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,EAAE,gBAAgB,MAAM,KAAG,MAA4C,CAAC;AAExH;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,EAAE,iBAAiB,MAAM,KAAG,MAA6C,CAAC"}

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;AAG9E;;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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"}