@tranding-custom-chart/core 0.0.0-stage → 2.0.0

package/README.md

@@ -1,3 +1,38 @@
-# Temporary Holding Version
+# @tranding-custom-chart/core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Pure TypeScript domain primitives, scales, math, data structures, and formatting for the `@tranding-custom-chart` suite.
+
+[![Version](https://img.shields.io/badge/version-2.0.0-blue.svg)](https://semver.org)
+[![Zero Telemetry](https://img.shields.io/badge/telemetry-zero-green.svg)](#)
+[![TypeScript](https://img.shields.io/badge/typescript-strict-blue.svg)](#)
+
+## Features
+- **Dynamic Options System**: `ChartOptions`, `DEFAULT_CHART_OPTIONS`, `mergeChartOptions`, `validateChartOptions`, and `resolveTheme`.
+- **Scales**: `LinearScale`, `LogScale` (safe log-space projection with decade ticks), `IndexTimeScale` (discrete session-aware time scale), and `ContinuousTimeScale`.
+- **Domain Invariants**: Strict financial candle validation ($Low \le \min(O,C) \le \max(O,C) \le High$).
+- **Data Downsampling**: Largest-Triangle-Three-Buckets (LTTB) algorithm.
+- **Fast Search**: $O(\log N)$ bisection culling for visible coordinate ranges.
+- **Catmull-Rom Splines**: $C^1$ continuous cubic Bezier spline math.
+- **Types**: 13 Chart types, Drawing tools, Indicators, Scales, Themes, and Color tokens.
+- **Runtime Version Constant**: `CHART_VERSION = '2.0.0'`.
+
+## Installation
+```bash
+npm install @tranding-custom-chart/core
+```
+
+## Quick Start
+```ts
+import { createLinearScale, createIndexTimeScale, CHART_VERSION } from '@tranding-custom-chart/core';
+
+console.log(`Using chart-core v${CHART_VERSION}`);
+
+const xScale = createIndexTimeScale(200, [0, 800]);
+const yScale = createLinearScale([100, 200], [400, 0]);
+
+console.log('X pixel for bar #10:', xScale.scale(10));
+console.log('Y pixel for price 150:', yScale.scale(150));
+```
+
+## License
+UNLICENSED (Internal / In-House Use)

package/dist/animation/animator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file packages/chart-core/src/animation/animator.ts
+ * Interpolation utilities and animation loop controller for progressive chart transitions.
+ */
+import { type EasingFunction, type EasingName } from './easing.js';
+export declare function interpolateNumber(from: number, to: number, progress: number): number;
+export declare function interpolateNumberArray(from: readonly number[], to: readonly number[], progress: number): number[];
+export declare const interpolateArrays: typeof interpolateNumberArray;
+export interface AnimationOptions {
+    /** Duration in milliseconds (default: 400ms) */
+    readonly duration?: number | undefined;
+    /** Easing function or name (default: 'easeOutQuart') */
+    readonly easing?: EasingName | EasingFunction | undefined;
+    /** Frame update callback called with progress value [0, 1] */
+    readonly onUpdate: (progress: number) => void;
+    /** Callback fired when animation finishes successfully */
+    readonly onComplete?: (() => void) | undefined;
+}
+export declare class Animator {
+    private readonly options;
+    private rafId;
+    private startTime;
+    private isCancelled;
+    constructor(options: AnimationOptions);
+    start(): void;
+    cancel(): void;
+}
+//# sourceMappingURL=animator.d.ts.map

package/dist/animation/animator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animator.d.ts","sourceRoot":"","sources":["../../src/animation/animator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAElF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEpF;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,QAAQ,EAAE,MAAM,GACf,MAAM,EAAE,CAWV;AAED,eAAO,MAAM,iBAAiB,+BAAyB,CAAC;AAExD,MAAM,WAAW,gBAAgB;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,wDAAwD;IACxD,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,cAAc,GAAG,SAAS,CAAC;IAC1D,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;CAChD;AAED,qBAAa,QAAQ;IAKP,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,WAAW,CAAS;gBAEC,OAAO,EAAE,gBAAgB;IAE/C,KAAK,IAAI,IAAI;IAyCb,MAAM,IAAI,IAAI;CAOtB"}

package/dist/animation/animator.js

@@ -0,0 +1,72 @@
+/**
+ * @file packages/chart-core/src/animation/animator.ts
+ * Interpolation utilities and animation loop controller for progressive chart transitions.
+ */
+import { resolveEasing } from './easing.js';
+export function interpolateNumber(from, to, progress) {
+    return from + (to - from) * progress;
+}
+export function interpolateNumberArray(from, to, progress) {
+    const maxLength = Math.max(from.length, to.length);
+    const result = new Array(maxLength);
+    for (let i = 0; i < maxLength; i++) {
+        const f = i < from.length ? (from[i] ?? 0) : 0;
+        const t = i < to.length ? (to[i] ?? 0) : 0;
+        result[i] = interpolateNumber(f, t, progress);
+    }
+    return result;
+}
+export const interpolateArrays = interpolateNumberArray;
+export class Animator {
+    options;
+    rafId = null;
+    startTime = null;
+    isCancelled = false;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        this.cancel();
+        this.isCancelled = false;
+        this.startTime = null;
+        const duration = Math.max(16, this.options.duration ?? 400);
+        const easingFn = resolveEasing(this.options.easing);
+        const step = (timestamp) => {
+            if (this.isCancelled)
+                return;
+            if (this.startTime === null) {
+                this.startTime = timestamp;
+            }
+            const elapsed = timestamp - this.startTime;
+            const rawProgress = Math.min(1, elapsed / duration);
+            const easedProgress = easingFn(rawProgress);
+            this.options.onUpdate(easedProgress);
+            if (rawProgress < 1) {
+                if (typeof window !== 'undefined' && typeof window.requestAnimationFrame === 'function') {
+                    this.rafId = window.requestAnimationFrame(step);
+                }
+                else {
+                    // Node / headless fallback
+                    setTimeout(() => step(timestamp + 16), 16);
+                }
+            }
+            else {
+                this.rafId = null;
+                this.options.onComplete?.();
+            }
+        };
+        if (typeof window !== 'undefined' && typeof window.requestAnimationFrame === 'function') {
+            this.rafId = window.requestAnimationFrame(step);
+        }
+        else {
+            setTimeout(() => step(16), 16);
+        }
+    }
+    cancel() {
+        this.isCancelled = true;
+        if (this.rafId !== null && typeof window !== 'undefined' && typeof window.cancelAnimationFrame === 'function') {
+            window.cancelAnimationFrame(this.rafId);
+            this.rafId = null;
+        }
+    }
+}

package/dist/animation/easing.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file packages/chart-core/src/animation/easing.ts
+ * Comprehensive mathematical easing functions and animation curves.
+ */
+export type EasingName = 'linear' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic' | 'easeInQuart' | 'easeOutQuart' | 'easeInOutQuart' | 'easeInBounce' | 'easeOutBounce' | 'easeInOutBounce';
+export type EasingFunction = (t: number) => number;
+export declare const EASING_FUNCTIONS: Record<EasingName, EasingFunction>;
+export declare function resolveEasing(easing?: EasingName | EasingFunction): EasingFunction;
+export declare const linear: EasingFunction;
+export declare const easeInQuad: EasingFunction;
+export declare const easeOutQuad: EasingFunction;
+export declare const easeInOutQuad: EasingFunction;
+export declare const easeInCubic: EasingFunction;
+export declare const easeOutCubic: EasingFunction;
+export declare const easeInOutCubic: EasingFunction;
+export declare const easeInQuart: EasingFunction;
+export declare const easeOutQuart: EasingFunction;
+export declare const easeInOutQuart: EasingFunction;
+export declare const easeInBounce: EasingFunction;
+export declare const easeOutBounce: EasingFunction;
+export declare const easeInOutBounce: EasingFunction;
+//# sourceMappingURL=easing.d.ts.map

package/dist/animation/easing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easing.d.ts","sourceRoot":"","sources":["../../src/animation/easing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,UAAU,GAClB,QAAQ,GACR,YAAY,GACZ,aAAa,GACb,eAAe,GACf,aAAa,GACb,cAAc,GACd,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,gBAAgB,GAChB,cAAc,GACd,eAAe,GACf,iBAAiB,CAAC;AAEtB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAEnD,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,UAAU,EAAE,cAAc,CAiD/D,CAAC;AAEF,wBAAgB,aAAa,CAAC,MAAM,GAAE,UAAU,GAAG,cAA+B,GAAG,cAAc,CAKlG;AAED,eAAO,MAAM,MAAM,EAAE,cAAwC,CAAC;AAC9D,eAAO,MAAM,UAAU,EAAE,cAA4C,CAAC;AACtE,eAAO,MAAM,WAAW,EAAE,cAA6C,CAAC;AACxE,eAAO,MAAM,aAAa,EAAE,cAA+C,CAAC;AAC5E,eAAO,MAAM,WAAW,EAAE,cAA6C,CAAC;AACxE,eAAO,MAAM,YAAY,EAAE,cAA8C,CAAC;AAC1E,eAAO,MAAM,cAAc,EAAE,cAAgD,CAAC;AAC9E,eAAO,MAAM,WAAW,EAAE,cAA6C,CAAC;AACxE,eAAO,MAAM,YAAY,EAAE,cAA8C,CAAC;AAC1E,eAAO,MAAM,cAAc,EAAE,cAAgD,CAAC;AAC9E,eAAO,MAAM,YAAY,EAAE,cAA8C,CAAC;AAC1E,eAAO,MAAM,aAAa,EAAE,cAA+C,CAAC;AAC5E,eAAO,MAAM,eAAe,EAAE,cAAiD,CAAC"}

package/dist/animation/easing.js

@@ -0,0 +1,69 @@
+/**
+ * @file packages/chart-core/src/animation/easing.ts
+ * Comprehensive mathematical easing functions and animation curves.
+ */
+export const EASING_FUNCTIONS = {
+    linear: (t) => t,
+    easeInQuad: (t) => t * t,
+    easeOutQuad: (t) => t * (2 - t),
+    easeInOutQuad: (t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t),
+    easeInCubic: (t) => t * t * t,
+    easeOutCubic: (t) => {
+        const t1 = t - 1;
+        return t1 * t1 * t1 + 1;
+    },
+    easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+    easeInQuart: (t) => t * t * t * t,
+    easeOutQuart: (t) => {
+        const t1 = t - 1;
+        return 1 - t1 * t1 * t1 * t1;
+    },
+    easeInOutQuart: (t) => {
+        if (t < 0.5)
+            return 8 * t * t * t * t;
+        const t1 = t - 1;
+        return 1 - 8 * t1 * t1 * t1 * t1;
+    },
+    easeOutBounce: (t) => {
+        const n1 = 7.5625;
+        const d1 = 2.75;
+        if (t < 1 / d1) {
+            return n1 * t * t;
+        }
+        else if (t < 2 / d1) {
+            const t1 = t - 1.5 / d1;
+            return n1 * t1 * t1 + 0.75;
+        }
+        else if (t < 2.5 / d1) {
+            const t1 = t - 2.25 / d1;
+            return n1 * t1 * t1 + 0.9375;
+        }
+        else {
+            const t1 = t - 2.625 / d1;
+            return n1 * t1 * t1 + 0.984375;
+        }
+    },
+    easeInBounce: (t) => 1 - EASING_FUNCTIONS.easeOutBounce(1 - t),
+    easeInOutBounce: (t) => t < 0.5
+        ? (1 - EASING_FUNCTIONS.easeOutBounce(1 - 2 * t)) / 2
+        : (1 + EASING_FUNCTIONS.easeOutBounce(2 * t - 1)) / 2,
+};
+export function resolveEasing(easing = 'easeOutQuart') {
+    if (typeof easing === 'function') {
+        return easing;
+    }
+    return EASING_FUNCTIONS[easing] ?? EASING_FUNCTIONS.easeOutQuart;
+}
+export const linear = EASING_FUNCTIONS.linear;
+export const easeInQuad = EASING_FUNCTIONS.easeInQuad;
+export const easeOutQuad = EASING_FUNCTIONS.easeOutQuad;
+export const easeInOutQuad = EASING_FUNCTIONS.easeInOutQuad;
+export const easeInCubic = EASING_FUNCTIONS.easeInCubic;
+export const easeOutCubic = EASING_FUNCTIONS.easeOutCubic;
+export const easeInOutCubic = EASING_FUNCTIONS.easeInOutCubic;
+export const easeInQuart = EASING_FUNCTIONS.easeInQuart;
+export const easeOutQuart = EASING_FUNCTIONS.easeOutQuart;
+export const easeInOutQuart = EASING_FUNCTIONS.easeInOutQuart;
+export const easeInBounce = EASING_FUNCTIONS.easeInBounce;
+export const easeOutBounce = EASING_FUNCTIONS.easeOutBounce;
+export const easeInOutBounce = EASING_FUNCTIONS.easeInOutBounce;

package/dist/data/downsample.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file packages/chart-core/src/data/downsample.ts
+ * Downsampling algorithms for high-density 2D visual series.
+ */
+import type { Point } from '../types.js';
+/**
+ * Downsamples a collection of 2D points using the Largest-Triangle-Three-Buckets (LTTB) algorithm.
+ * Preserves visual peaks, troughs, and overall trend characteristics while strictly capping
+ * point count to threshold.
+ */
+export declare function downsampleLTTB(data: readonly Point[], threshold: number): readonly Point[];
+//# sourceMappingURL=downsample.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"downsample.d.ts","sourceRoot":"","sources":["../../src/data/downsample.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,SAAS,EAAE,MAAM,GAChB,SAAS,KAAK,EAAE,CAoElB"}

package/dist/data/downsample.js

@@ -0,0 +1,60 @@
+/**
+ * @file packages/chart-core/src/data/downsample.ts
+ * Downsampling algorithms for high-density 2D visual series.
+ */
+/**
+ * Downsamples a collection of 2D points using the Largest-Triangle-Three-Buckets (LTTB) algorithm.
+ * Preserves visual peaks, troughs, and overall trend characteristics while strictly capping
+ * point count to threshold.
+ */
+export function downsampleLTTB(data, threshold) {
+    const dataLen = data.length;
+    if (threshold >= dataLen || threshold <= 2) {
+        return data;
+    }
+    const sampled = [];
+    let sampledIndex = 0;
+    // Bucket size. Leave room for start and end data points
+    const every = (dataLen - 2) / (threshold - 2);
+    let a = 0; // Initially point a is the first point in the first bucket
+    let maxAreaPoint = data[a];
+    let nextA = 0;
+    sampled[sampledIndex++] = data[a]; // Always add the first point
+    for (let i = 0; i < threshold - 2; i++) {
+        // Calculate point average for next bucket (containing c)
+        let avgX = 0;
+        let avgY = 0;
+        let avgRangeStart = Math.floor((i + 1) * every) + 1;
+        let avgRangeEnd = Math.floor((i + 2) * every) + 1;
+        avgRangeEnd = avgRangeEnd < dataLen ? avgRangeEnd : dataLen;
+        const avgRangeLength = avgRangeEnd - avgRangeStart;
+        for (; avgRangeStart < avgRangeEnd; avgRangeStart++) {
+            avgX += data[avgRangeStart].x;
+            avgY += data[avgRangeStart].y;
+        }
+        avgX /= avgRangeLength || 1;
+        avgY /= avgRangeLength || 1;
+        // Get the range for this bucket
+        let rangeOffs = Math.floor(i * every) + 1;
+        const rangeTo = Math.floor((i + 1) * every) + 1;
+        // Point a
+        const pointAX = data[a].x;
+        const pointAY = data[a].y;
+        let maxArea = -1;
+        for (; rangeOffs < rangeTo; rangeOffs++) {
+            const current = data[rangeOffs];
+            // Calculate triangle area over three points: a, current, and avg of next bucket
+            const area = Math.abs((pointAX - avgX) * (current.y - pointAY) -
+                (pointAX - current.x) * (avgY - pointAY)) * 0.5;
+            if (area > maxArea) {
+                maxArea = area;
+                maxAreaPoint = current;
+                nextA = rangeOffs; // Next a is this point
+            }
+        }
+        sampled[sampledIndex++] = maxAreaPoint;
+        a = nextA;
+    }
+    sampled[sampledIndex++] = data[dataLen - 1]; // Always add the last point
+    return sampled;
+}

package/dist/data/validation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file packages/chart-core/src/data/validation.ts
+ * Validation and normalization utilities for financial time series data.
+ */
+import type { OHLCVBar } from '../types.js';
+export interface BarValidationResult {
+    readonly valid: boolean;
+    readonly errors?: readonly string[];
+}
+/**
+ * Validates a single OHLCV bar candidate.
+ */
+export declare function validateOHLCVBar(bar: unknown): BarValidationResult;
+/**
+ * Normalizes, deduplicates, and sorts a time series collection ascending by time.
+ * If duplicate timestamps occur, later items in the array take precedence.
+ */
+export declare function normalizeTimeSeries<T>(items: readonly T[], getTime: (item: T) => number): readonly T[];
+/**
+ * Calculates the [minLow, maxHigh] domain across a collection of OHLCV bars.
+ * Gracefully handles empty data and flat markets.
+ */
+export declare function calculateOHLCDomain(bars: readonly OHLCVBar[]): [number, number];
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/data/validation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,mBAAmB,CAmDlE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAC3B,SAAS,CAAC,EAAE,CAcd;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAwB/E"}

package/dist/data/validation.js

@@ -0,0 +1,93 @@
+/**
+ * @file packages/chart-core/src/data/validation.ts
+ * Validation and normalization utilities for financial time series data.
+ */
+/**
+ * Validates a single OHLCV bar candidate.
+ */
+export function validateOHLCVBar(bar) {
+    if (!bar || typeof bar !== 'object') {
+        return { valid: false, errors: ['Bar must be a non-null object'] };
+    }
+    const b = bar;
+    const errors = [];
+    if (typeof b.time !== 'number' || !Number.isFinite(b.time) || b.time <= 0) {
+        errors.push('Bar time must be a positive finite number');
+    }
+    if (typeof b.open !== 'number' || !Number.isFinite(b.open)) {
+        errors.push('Bar open must be a finite number');
+    }
+    if (typeof b.high !== 'number' || !Number.isFinite(b.high)) {
+        errors.push('Bar high must be a finite number');
+    }
+    if (typeof b.low !== 'number' || !Number.isFinite(b.low)) {
+        errors.push('Bar low must be a finite number');
+    }
+    if (typeof b.close !== 'number' || !Number.isFinite(b.close)) {
+        errors.push('Bar close must be a finite number');
+    }
+    if (errors.length === 0) {
+        const { open, high, low, close } = b;
+        if (high < low) {
+            errors.push(`High (${high}) cannot be less than low (${low})`);
+        }
+        if (open > high || open < low) {
+            errors.push(`Open (${open}) must be between low (${low}) and high (${high})`);
+        }
+        if (close > high || close < low) {
+            errors.push(`Close (${close}) must be between low (${low}) and high (${high})`);
+        }
+    }
+    if (b.volume !== null && b.volume !== undefined) {
+        if (typeof b.volume !== 'number' || !Number.isFinite(b.volume) || b.volume < 0) {
+            errors.push('Bar volume must be null, undefined, or a non-negative finite number');
+        }
+    }
+    return errors.length === 0
+        ? { valid: true }
+        : { valid: false, errors };
+}
+/**
+ * Normalizes, deduplicates, and sorts a time series collection ascending by time.
+ * If duplicate timestamps occur, later items in the array take precedence.
+ */
+export function normalizeTimeSeries(items, getTime) {
+    if (!items || items.length === 0)
+        return [];
+    const map = new Map();
+    for (const item of items) {
+        const t = getTime(item);
+        if (Number.isFinite(t)) {
+            map.set(t, item);
+        }
+    }
+    return Array.from(map.entries())
+        .sort(([t1], [t2]) => t1 - t2)
+        .map(([, item]) => item);
+}
+/**
+ * Calculates the [minLow, maxHigh] domain across a collection of OHLCV bars.
+ * Gracefully handles empty data and flat markets.
+ */
+export function calculateOHLCDomain(bars) {
+    if (!bars || bars.length === 0) {
+        return [0, 100];
+    }
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < bars.length; i++) {
+        const b = bars[i];
+        if (b.low < min)
+            min = b.low;
+        if (b.high > max)
+            max = b.high;
+    }
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+        return [0, 100];
+    }
+    if (min === max) {
+        const pad = min === 0 ? 1 : Math.abs(min) * 0.05;
+        return [min - pad, max + pad];
+    }
+    return [min, max];
+}

package/dist/drawing/drawing-geometry.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file packages/chart-core/src/drawing/drawing-geometry.ts
+ * Pure data-domain coordinate calculations, spatial hit-testing, handle resolution,
+ * translation, and geometric mutations for interactive chart drawings.
+ */
+import type { DrawingHandleType, DrawingItem, Scale } from '../types.js';
+/**
+ * Calculates Euclidean distance between point (px, py) and segment (x1, y1)-(x2, y2).
+ */
+export declare function distanceToSegment(px: number, py: number, x1: number, y1: number, x2: number, y2: number): number;
+/**
+ * Checks if point (px, py) is within radius of target (tx, ty).
+ */
+export declare function isNearPoint(px: number, py: number, tx: number, ty: number, radius?: number): boolean;
+export interface DrawingHitResult {
+    readonly drawing: DrawingItem;
+    readonly handle: DrawingHandleType;
+    readonly distance: number;
+}
+/**
+ * Hit-tests an individual drawing against screen coordinates (x, y) given scales.
+ * Returns handle type ('p1' | 'p2' | 'body' | 'channelOffset' | 'vertex') or null.
+ */
+export declare function hitTestDrawing(drawing: DrawingItem, x: number, y: number, xScale: Scale<number>, yScale: Scale<number>, tolerance?: number): {
+    handle: DrawingHandleType;
+    distance: number;
+} | null;
+/**
+ * Hit-tests against an entire collection of drawings in reverse z-order (topmost first).
+ */
+export declare function hitTestAllDrawings(drawings: readonly DrawingItem[], x: number, y: number, xScale: Scale<number>, yScale: Scale<number>, tolerance?: number): DrawingHitResult | null;
+/**
+ * Translates an entire drawing by deltaIndex and deltaPrice in data-domain coordinates.
+ */
+export declare function translateDrawing(drawing: DrawingItem, deltaIndex: number, deltaPrice: number): DrawingItem;
+/**
+ * Moves a specific control handle of a drawing to a new data-domain position.
+ */
+export declare function moveDrawingHandle(drawing: DrawingItem, handle: DrawingHandleType, newIndex: number, newPrice: number): DrawingItem;
+/**
+ * Duplicates a drawing with a slight offset in data space.
+ */
+export declare function duplicateDrawing(drawing: DrawingItem, offsetIndex?: number, offsetPrice?: number): DrawingItem;
+//# sourceMappingURL=drawing-geometry.d.ts.map

package/dist/drawing/drawing-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing-geometry.d.ts","sourceRoot":"","sources":["../../src/drawing/drawing-geometry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAgB,KAAK,EAAE,MAAM,aAAa,CAAC;AAEvF;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,MAAM,CAWR;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,OAAO,CAE/F;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,WAAW,EACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,EACrB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,EACrB,SAAS,SAAI,GACZ;IAAE,MAAM,EAAE,iBAAiB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAyJxD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,EACrB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,EACrB,SAAS,SAAI,GACZ,gBAAgB,GAAG,IAAI,CASzB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CAiDb;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,WAAW,CAsCb;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,WAAW,EACpB,WAAW,SAAI,EACf,WAAW,SAAI,GACd,WAAW,CASb"}