@livo-build/charts 0.2.1 → 0.2.3

package/dist/core/renderer.d.ts

@@ -1,4 +1,59 @@
-import type { Candle, ChartTheme, ChartType, Indicator } from "./types";
+import type { Candle, ChartTheme, ChartType, Drawing, Indicator, Oscillator, VolumeProfileConfig } from "./types";
+/**
+ * Width of one candle slot (px). By default the slot is capped at `maxBarWidth` and the
+ * series is right-anchored — sparse data stays tight in the corner. With `fitContent`,
+ * the cap is dropped so `count` candles spread across the whole plot (fills the
+ * container). Dense series are identical either way (plotW/count < maxBarWidth).
+ */
+export declare function slotWidth(plotW: number, count: number, maxBarWidth: number, fitContent?: boolean): number;
+/** Convert a `#rrggbb` color to `rgba(...)` with the given alpha (passes other formats through). */
+export declare function withAlpha(color: string, alpha: number): string;
+/** The visible candle window (which slice is on screen and the per-candle slot width).
+ *  A negative `view.offset` scrolls past the newest candle into the future: `end` exceeds
+ *  the data length and `rightGap` counts the empty slots between the newest candle and the
+ *  right edge (so the user can pull the current price left of the edge / toward center). */
+export declare function windowOf(candles: Candle[], view: Viewport, plotW: number, maxBarWidth: number, fitContent?: boolean): {
+    start: number;
+    end: number;
+    vis: Candle[];
+    n: number;
+    count: number;
+    rightGap: number;
+    cw: number;
+};
+/**
+ * Price ↔ pixel mapping for the price pane, shared by the renderer and the drawing-tool
+ * hit-testing so they never drift. Handles the log transform and the padded/zoomed range.
+ */
+export declare function priceScale(vis: Candle[], yZoom: number, logScale: boolean, top: number, priceH: number): {
+    yOfPrice: (v: number) => number;
+    priceOfY: (y: number) => number;
+    fwd: (v: number) => number;
+    inv: (s: number) => number;
+    sLo: number;
+    sRng: number;
+    lo: number;
+    hi: number;
+};
+/** Time ↔ pixel mapping for the visible window (candle index and arbitrary unix-second time).
+ *  `rightGap` (empty future slots, see windowOf) shifts the candles left of the right edge. */
+export declare function timeScale(vis: Candle[], n: number, cw: number, plotW: number, interval: number, rightGap?: number): {
+    xOf: (j: number) => number;
+    xOfTime: (t: number) => number;
+    timeOfX: (x: number) => number;
+};
+/** Full pixel↔data projection for the current frame — built from the same input `draw` uses. */
+export interface Projection {
+    xOfTime: (t: number) => number;
+    timeOfX: (x: number) => number;
+    yOfPrice: (p: number) => number;
+    priceOfY: (y: number) => number;
+    plotW: number;
+    priceTop: number;
+    priceBottom: number;
+}
+/** Compute the {@link Projection} for interaction/hit-testing without rendering. */
+export declare function computeProjection(input: RenderInput): Projection | null;
 export interface Viewport {
     /** candles visible. */
     count: number;
@@ -15,6 +70,10 @@ export interface RenderInput {
     width: number;
     height: number;
     candles: Candle[];
+    /** Candles used for the price series + axis (Heikin-Ashi in `heikin` mode). The Chart
+     *  controller precomputes this on data/type change; if omitted, `draw` derives it. The
+     *  RAW `candles` still drive volume, indicators, oscillators and the crosshair readout. */
+    priceCandles?: Candle[];
     view: Viewport;
     hover: {
         x: number;
@@ -26,6 +85,8 @@ export interface RenderInput {
     yZoom: number;
     /** max candle slot width in px. */
     maxBarWidth: number;
+    /** max candle body / volume-bar width in px (default 40). */
+    maxBodyWidth?: number;
     /** volume-panel height in px. */
     volH: number;
     theme: ChartTheme;
@@ -34,12 +95,46 @@ export interface RenderInput {
     indicators?: Indicator[];
     /** precomputed overlay value-series (aligned to `candles`); preferred over `indicators`. */
     overlays?: ResolvedOverlay[];
+    /** logarithmic price axis — equal vertical distance = equal % move. */
+    logScale?: boolean;
+    /** centered text when there are no candles (default "no priced trades yet"; "" = nothing). */
+    emptyText?: string;
+    /** reference price for the `baseline` chart type (default: the first visible candle's close). */
+    baselinePrice?: number;
+    /** volume-by-price histogram drawn on the price pane (default off). */
+    volumeProfile?: VolumeProfileConfig;
+    /** spread candles across the full plot width instead of right-anchoring at a capped slot. */
+    fitContent?: boolean;
+    /** y-axis price label formatter (default: range-aware {@link formatAxisValue}). */
+    priceFormat?: (value: number) => string;
+    /** x-axis time label formatter (default {@link formatTime}). */
+    timeFormat?: (time: number, interval: number) => string;
+    /** number of horizontal price gridlines / labels (default 5). */
+    priceTicks?: number;
+    /** approximate number of time-axis labels (default 7). */
+    timeTicks?: number;
+    /** canvas font for axis labels (default "10px ui-monospace, monospace"); color is `theme.axis`. */
+    axisFont?: string;
+    /** oscillators (RSI / MACD) drawn in stacked sub-panes below the volume panel. */
+    oscillators?: Oscillator[];
+    /** committed user drawings (trendlines / horizontal lines). */
+    drawings?: Drawing[];
+    /** in-progress drawing rendered as a live preview (not yet committed). */
+    drawPreview?: Drawing | null;
+    /** id of the selected drawing (rendered emphasized with anchor handles). */
+    selectedDrawing?: string | null;
 }
 /** A resolved indicator overlay: a color and a value-series aligned to the candles. */
 export interface ResolvedOverlay {
     color: string;
     values: (number | null)[];
 }
+/**
+ * Resolve indicator configs into drawable overlay lines. Moving averages / VWAP map 1:1;
+ * a `bollinger` indicator expands into three lines (upper / mid / lower), the bands faint.
+ * Shared by the Chart controller (precompute) and `draw` (standalone callers).
+ */
+export declare function resolveOverlays(candles: Candle[], indicators: Indicator[]): ResolvedOverlay[];
 /**
  * Pure draw pass: renders grid, axes, the price series (candles or line), a volume
  * panel, the last-price tag and the crosshair + axis labels. Returns the candle under