@livo-build/charts 0.2.1 → 0.2.3

package/dist/core/signals.d.ts

@@ -0,0 +1,63 @@
+import type { Candle, Point } from "./types";
+import type { ChartFeed } from "./feed";
+/** The public Livo signals engine. */
+export declare const DEFAULT_SIGNALS_URL = "https://signals.livo.build";
+/** The fields of a Signal Radar market this adapter needs. `spark` is recent closes (oldest→newest). */
+export interface SignalsMarket {
+    pair: string;
+    base: string;
+    pool: string;
+    price: number;
+    spark: number[];
+}
+/** Fetch one Signal Radar market (price + spark) from the engine snapshot, or null if absent. */
+export declare function fetchSignalsMarket(token: string, url?: string): Promise<SignalsMarket | null>;
+/**
+ * Fetch a page of indexed swaps for a pool from the engine's GraphQL API (`allSwaps`,
+ * newest-first), mapped to priced {@link Point}s. `pool` must be the 0x-prefixed address.
+ * Returns one point per swap (unpriceable swaps keep `p: 0` and are dropped by `buildOHLC`),
+ * so the caller can advance its offset by `points.length`.
+ */
+export declare function fetchSignalsSwaps(pool: string, opts?: {
+    url?: string;
+    first?: number;
+    offset?: number;
+}): Promise<Point[]>;
+/**
+ * Drop swaps whose price is a wild outlier — the engine occasionally mis-prices historical
+ * swaps (e.g. a thin pool's old trades priced at $2.5M for a $3 token). Uses the median of
+ * the newest swaps as a robust reference (recent prices are reliable) and rejects anything
+ * more than `factor`× off it. Input is newest-first; output preserves order.
+ */
+export declare function rejectPriceOutliers(pts: Point[], factor?: number): Point[];
+/** Turn a `spark` (recent closes, oldest→newest) into flat candles ending at `nowSec`. */
+export declare function sparkCandles(spark: number[], bucketSeconds: number, nowSec: number, lastClose?: number): Candle[];
+export interface SignalsFeedOptions {
+    /** Token to chart — pool address, base-token address, or pair symbol (e.g. "PEPE"). */
+    token: string;
+    /** Engine base URL (default https://signals.livo.build). */
+    url?: string;
+    /** Candle bucket size in seconds (default 300 = 5m). */
+    bucketSeconds?: number;
+    /** Swaps fetched per history page from the index (default 1500); older pages load lazily. */
+    swapPageSize?: number;
+    /** Candles to load before the first paint, so the chart opens filled rather than a sliver
+     *  on the right (default 160). Active pools pack many swaps per bucket, so this may take a
+     *  few index pages. */
+    initialCandles?: number;
+    /** Force `"spark"` (snapshot closes only) instead of the default `"index"` (GraphQL history). */
+    history?: "index" | "spark";
+    /** Live poll cadence in ms (default 15s; 0 disables the live poll). */
+    refetchMs?: number;
+    /** Override "now" (ms) — for tests/determinism. */
+    now?: number;
+}
+/**
+ * A {@link ChartFeed} for a Signal Radar token. History comes from the engine's indexed
+ * swaps (`/graphql allSwaps` for the pool → bucketed into OHLC at `bucketSeconds`), paged
+ * lazily on back-scroll, so it shows real candles days deep. The live candle is polled from
+ * `/data` (current price). If the index is unreachable (or `history: "spark"`), it falls back
+ * to seeding from the snapshot's `spark`. Pass it to `connectFeed` with `bucketSeconds` as
+ * the interval.
+ */
+export declare function signalsFeed(opts: SignalsFeedOptions): ChartFeed;

package/dist/core/signals.js

@@ -0,0 +1,234 @@
+// Signal Radar adapter — chart a token tracked by the Livo on-chain signals engine.
+// The engine ("Signal Radar") indexes every Ethereum mainnet DEX swap into Postgres and
+// exposes it over a PostGraphile GraphQL API (`/graphql`), plus a live `/data` snapshot
+// (no key) with the current USD `price` and a short `spark` of recent closes.
+//
+// This adapter pulls REAL history from the index — `allSwaps` for the pool, bucketed into
+// OHLC candles at any interval — so it shows true 1m / 5m candles days back (the index has
+// no TTL), and lazy-loads older pages as you scroll. It polls `/data` for the live, building
+// candle. If `/graphql` is unreachable (e.g. CORS), it falls back to seeding from `spark`.
+//
+//   import { Chart, connectFeed, signalsFeed } from "@livo-build/charts";
+//   const chart = new Chart(el, { height: 420 });
+//   connectFeed(chart, signalsFeed({ token: "PEPE" }), { interval: 300 });
+import { buildOHLC } from "./ohlc";
+/** The public Livo signals engine. */
+export const DEFAULT_SIGNALS_URL = "https://signals.livo.build";
+/** fetch with an abort timeout so a stalled engine request can't wedge lazy-loading forever. */
+async function fetchT(input, init = {}, timeoutMs = 12000) {
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    const timer = ac ? setTimeout(() => ac.abort(), timeoutMs) : undefined;
+    try {
+        return await fetch(input, ac ? { ...init, signal: ac.signal } : init);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+const bare = (s) => s.replace(/^0x/i, "").toLowerCase();
+/** Find the snapshot market for a token by pool address, base-token address, or pair symbol. */
+function findMarket(markets, token) {
+    const q = bare(token);
+    const byAddr = markets.find((m) => bare(m.pool) === q || bare(m.base) === q);
+    if (byAddr)
+        return byAddr;
+    const sym = token.toLowerCase();
+    // symbol match → the deepest (first listed; the snapshot is hottest-first) market.
+    return markets.find((m) => m.pair.toLowerCase().split("/")[0] === sym);
+}
+/** Fetch one Signal Radar market (price + spark) from the engine snapshot, or null if absent. */
+export async function fetchSignalsMarket(token, url = DEFAULT_SIGNALS_URL) {
+    const res = await fetchT(`${url}/data`);
+    if (!res.ok)
+        throw new Error("signals /data " + res.status);
+    const snap = (await res.json());
+    return findMarket(snap.markets ?? [], token) ?? null;
+}
+/**
+ * Fetch a page of indexed swaps for a pool from the engine's GraphQL API (`allSwaps`,
+ * newest-first), mapped to priced {@link Point}s. `pool` must be the 0x-prefixed address.
+ * Returns one point per swap (unpriceable swaps keep `p: 0` and are dropped by `buildOHLC`),
+ * so the caller can advance its offset by `points.length`.
+ */
+export async function fetchSignalsSwaps(pool, opts = {}) {
+    const url = opts.url ?? DEFAULT_SIGNALS_URL;
+    const first = opts.first ?? 1500;
+    const offset = opts.offset ?? 0;
+    const query = `{ allSwaps(condition:{pool:"${pool}"}, orderBy: BLOCK_TIME_DESC, first:${first}, offset:${offset}){ nodes{ blockTime priceUsd amountUsd } } }`;
+    const res = await fetchT(`${url}/graphql`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ query }),
+    });
+    if (!res.ok)
+        throw new Error("signals /graphql " + res.status);
+    const j = (await res.json());
+    const nodes = j?.data?.allSwaps?.nodes;
+    if (!nodes)
+        throw new Error("signals /graphql: no allSwaps");
+    return nodes.map((s) => ({ t: +s.blockTime, p: +(s.priceUsd ?? 0), v: +(s.amountUsd ?? 0) || 0 }));
+}
+/**
+ * Drop swaps whose price is a wild outlier — the engine occasionally mis-prices historical
+ * swaps (e.g. a thin pool's old trades priced at $2.5M for a $3 token). Uses the median of
+ * the newest swaps as a robust reference (recent prices are reliable) and rejects anything
+ * more than `factor`× off it. Input is newest-first; output preserves order.
+ */
+export function rejectPriceOutliers(pts, factor = 100) {
+    const priced = pts.filter((p) => p.p > 0 && isFinite(p.p));
+    if (priced.length < 8)
+        return priced;
+    const recent = priced
+        .slice(0, 200)
+        .map((p) => p.p)
+        .sort((a, b) => a - b);
+    const ref = recent[Math.floor(recent.length / 2)] || 0;
+    if (!(ref > 0))
+        return priced;
+    return priced.filter((p) => p.p >= ref / factor && p.p <= ref * factor);
+}
+/** Turn a `spark` (recent closes, oldest→newest) into flat candles ending at `nowSec`. */
+export function sparkCandles(spark, bucketSeconds, nowSec, lastClose) {
+    const n = spark.length;
+    const endBucket = Math.floor(nowSec / bucketSeconds) * bucketSeconds;
+    return spark.map((p, i) => {
+        const c = i === n - 1 && lastClose != null ? lastClose : p;
+        const time = endBucket - (n - 1 - i) * bucketSeconds;
+        return { time, o: p, h: Math.max(p, c), l: Math.min(p, c), c, vol: 0 };
+    });
+}
+/**
+ * A {@link ChartFeed} for a Signal Radar token. History comes from the engine's indexed
+ * swaps (`/graphql allSwaps` for the pool → bucketed into OHLC at `bucketSeconds`), paged
+ * lazily on back-scroll, so it shows real candles days deep. The live candle is polled from
+ * `/data` (current price). If the index is unreachable (or `history: "spark"`), it falls back
+ * to seeding from the snapshot's `spark`. Pass it to `connectFeed` with `bucketSeconds` as
+ * the interval.
+ */
+export function signalsFeed(opts) {
+    const url = opts.url ?? DEFAULT_SIGNALS_URL;
+    const secs = opts.bucketSeconds ?? 300;
+    const token = opts.token;
+    const swapPage = opts.swapPageSize ?? 1500;
+    const initialCandles = opts.initialCandles ?? 160;
+    const sparkOnly = opts.history === "spark";
+    const MAX_SWAPS = 60000; // memory/CPU bound on deep back-scroll
+    // Resolve the market once (gives the pool to query + the spark fallback), cached.
+    let marketP = null;
+    const market = () => (marketP ?? (marketP = fetchSignalsMarket(token, url).catch(() => null)));
+    // Accumulate ALL fetched swaps and re-bucket the full set each page, so a candle bucket
+    // that straddles a swap-page boundary is always COMPLETE (no partial O/H/L/volume). The
+    // feed returns the full ascending candle set; connectFeed merges it (replacing the partial
+    // boundary it already showed). `offset` pages older swaps; bounded by MAX_SWAPS.
+    // When `token` is a pool address, query the index by it DIRECTLY — the index keys on the
+    // pool (permanent) so history works even after the market rotates out of the live `/data`
+    // snapshot. /data is then only needed for the spark fallback + the live price.
+    const directPool = /^(0x)?[0-9a-fA-F]{40}$/.test(token) ? `0x${bare(token)}` : null;
+    let allSwaps = [];
+    let offset = 0;
+    let sparkMode = sparkOnly; // flipped on if the index is unreachable
+    let histLatest = null; // newest indexed candle (seeds the live bucket)
+    const spark = async (m) => {
+        if (!m)
+            return [];
+        const nowSec = (opts.now ?? Date.now()) / 1000;
+        const cs = sparkCandles(m.spark ?? [], secs, nowSec, m.price);
+        histLatest = cs[cs.length - 1] ?? null;
+        return cs;
+    };
+    return {
+        async loadHistory({ before }) {
+            const m = await market(); // for the spark fallback + the live price (best-effort)
+            // Prefer the pool straight from the token (rotation-proof); else resolve it via /data.
+            const pool = directPool ?? (m && m.pool ? `0x${bare(m.pool)}` : null);
+            if (!pool)
+                return [];
+            // Spark mode (forced via `history:"spark"`, or fell back): only the initial page has
+            // data (the snapshot's recent closes); there are no deeper pages.
+            if (sparkMode)
+                return before == null ? spark(m) : [];
+            if (allSwaps.length >= MAX_SWAPS)
+                return []; // depth cap reached
+            try {
+                // On the FIRST load, keep pulling pages until we have a full screen of candles, so the
+                // chart paints filled rather than a sliver on the right (active pools pack many swaps
+                // into each bucket, so one page can be only an hour or two). Lazy scroll-back fetches
+                // one page at a time. `rejectPriceOutliers` drops engine mis-pricings (e.g. $2.5M).
+                const want = before == null ? initialCandles : 0;
+                let got = 0;
+                do {
+                    const pts = await fetchSignalsSwaps(pool, { url, first: swapPage, offset });
+                    offset += pts.length;
+                    got += pts.length;
+                    if (pts.length === 0)
+                        break;
+                    allSwaps = allSwaps.concat(pts);
+                } while (allSwaps.length < MAX_SWAPS && buildOHLC(rejectPriceOutliers(allSwaps), secs).length < want);
+                if (got === 0) {
+                    if (allSwaps.length === 0) {
+                        sparkMode = true; // index empty for this pool — seed from spark
+                        return before == null ? spark(m) : [];
+                    }
+                    return []; // no older swaps — history exhausted
+                }
+                const candles = buildOHLC(rejectPriceOutliers(allSwaps), secs); // clean, complete buckets
+                histLatest = candles[candles.length - 1] ?? null; // newest (may be the live bucket) — seeds the live poll
+                // EXCLUDE the in-progress (current wall-clock) bucket: the live poll owns it. Otherwise a
+                // history re-fetch (lazy load) would overwrite the live candle with the stale indexed close,
+                // and the next poll would restore the live price — making the latest candle oscillate.
+                const curBucket = Math.floor((opts.now ?? Date.now()) / 1000 / secs) * secs;
+                return candles.filter((c) => c.time < curBucket);
+            }
+            catch {
+                // index unreachable (e.g. /graphql CORS) — fall back to the snapshot spark, once.
+                sparkMode = true;
+                return before == null ? spark(m) : [];
+            }
+        },
+        subscribe(_params, onUpdate) {
+            const ms = opts.refetchMs ?? 15000;
+            if (ms <= 0)
+                return () => { };
+            let stopped = false;
+            let timer;
+            // Track the in-progress bucket so polled prices accumulate high/low instead of
+            // overwriting the whole candle each tick.
+            let cur = null;
+            const tick = async () => {
+                if (stopped)
+                    return;
+                try {
+                    const m = await fetchSignalsMarket(token, url);
+                    if (m && !stopped) {
+                        const nowSec = (opts.now ?? Date.now()) / 1000;
+                        const bt = Math.floor(nowSec / secs) * secs;
+                        if (!cur || cur.time !== bt) {
+                            // Seed the in-progress bucket from the latest INDEXED candle when it's the same
+                            // bucket, so the live price extends real OHLC/volume instead of flattening it.
+                            const base = histLatest && histLatest.time === bt ? histLatest : null;
+                            cur = base
+                                ? { ...base, h: Math.max(base.h, m.price), l: Math.min(base.l, m.price), c: m.price }
+                                : { time: bt, o: m.price, h: m.price, l: m.price, c: m.price, vol: 0 };
+                        }
+                        else {
+                            cur = { ...cur, h: Math.max(cur.h, m.price), l: Math.min(cur.l, m.price), c: m.price };
+                        }
+                        onUpdate(cur);
+                    }
+                }
+                catch {
+                    /* transient fetch error — try again next tick */
+                }
+                if (!stopped)
+                    timer = setTimeout(tick, ms);
+            };
+            void tick(); // fire immediately so the live (current-bucket) candle appears at once
+            return () => {
+                stopped = true;
+                if (timer)
+                    clearTimeout(timer);
+            };
+        },
+    };
+}

package/dist/core/theme.d.ts

@@ -1,3 +1,7 @@
 import type { ChartTheme } from "./types";
-/** Default dark theme (TradingView-ish palette). */
+/** Default dark theme — a refined, modern crypto-terminal palette. */
 export declare const DEFAULT_THEME: ChartTheme;
+/** Light theme preset (same hues on a clean white plot). Pass to `theme` / `setTheme`. */
+export declare const LIGHT_THEME: ChartTheme;
+/** Built-in theme presets, addressable by name. */
+export declare const THEME_PRESETS: Record<"dark" | "light", ChartTheme>;

package/dist/core/theme.js

@@ -1,14 +1,35 @@
-/** Default dark theme (TradingView-ish palette). */
+/** Default dark theme — a refined, modern crypto-terminal palette. */
 export const DEFAULT_THEME = {
-    up: "#26a69a",
-    down: "#ef5350",
-    line: "#2962ff",
-    grid: "#1c2030",
-    axis: "#787b86",
-    crosshair: "#9598a1",
-    volUp: "rgba(38,166,154,.5)",
-    volDown: "rgba(239,83,80,.5)",
-    tagText: "#0a0a0a",
-    axisTagBg: "#2a2e39",
-    axisTagText: "#d1d4dc",
+    up: "#2ebd85",
+    down: "#f6465d",
+    line: "#5b8def",
+    grid: "#1a2030",
+    axis: "#8b919e",
+    crosshair: "#b3b9c4",
+    volUp: "rgba(46,189,133,.28)",
+    volDown: "rgba(246,70,93,.28)",
+    tagText: "#06080c",
+    axisTagBg: "#2b3242",
+    axisTagText: "#eaedf2",
+    background: "#0b0e14",
+};
+/** Light theme preset (same hues on a clean white plot). Pass to `theme` / `setTheme`. */
+export const LIGHT_THEME = {
+    up: "#089981",
+    down: "#f23645",
+    line: "#3b6fe0",
+    grid: "#eceff4",
+    axis: "#6b7280",
+    crosshair: "#4b5563",
+    volUp: "rgba(8,153,129,.22)",
+    volDown: "rgba(242,54,69,.22)",
+    tagText: "#ffffff",
+    axisTagBg: "#1f2733",
+    axisTagText: "#ffffff",
+    background: "#ffffff",
+};
+/** Built-in theme presets, addressable by name. */
+export const THEME_PRESETS = {
+    dark: DEFAULT_THEME,
+    light: LIGHT_THEME,
 };

package/dist/core/types.d.ts

@@ -15,10 +15,30 @@ export interface Point {
     v?: number;
 }
 export type Denom = "USD" | "ETH";
-export type ChartType = "candle" | "line";
-export type IndicatorType = "sma" | "ema" | "wma" | "vwap";
+/** Price-series style: candlesticks, a line, a two-tone baseline area, or Heikin-Ashi candles. */
+export type ChartType = "candle" | "line" | "baseline" | "heikin";
+export type IndicatorType = "sma" | "ema" | "wma" | "vwap" | "bollinger";
 export type PriceSource = "open" | "high" | "low" | "close";
-/** An overlay indicator drawn on the price pane (a moving average for now). */
+/** Oscillators render in their own stacked sub-pane below the volume panel. */
+export type OscillatorType = "rsi" | "macd" | "stoch" | "atr";
+/** An oscillator drawn in a dedicated sub-pane (RSI/Stochastic 0–100 band, MACD, or ATR). */
+export interface Oscillator {
+    type: OscillatorType;
+    /** Lookback — RSI/ATR period, or the Stochastic %K period (defaults 14). Ignored by MACD. */
+    period?: number;
+    /** MACD fast / slow / signal EMA lengths (defaults 12 / 26 / 9). Ignored by the others. */
+    fast?: number;
+    slow?: number;
+    signal?: number;
+    /** Stochastic %D period (default 3) and %K smoothing (default 1 = fast). Ignored by others. */
+    dPeriod?: number;
+    smooth?: number;
+    /** Pane height in px (default 84). */
+    height?: number;
+    /** Primary line color; defaults to a built-in palette slot. */
+    color?: string;
+}
+/** An overlay indicator drawn on the price pane (a moving average, VWAP, or Bollinger band). */
 export interface Indicator {
     type: IndicatorType;
     /** Lookback in candles. */
@@ -27,7 +47,29 @@ export interface Indicator {
     color?: string;
     /** Which price to average. Default "close". */
     source?: PriceSource;
+    /** Bollinger band width in standard deviations (default 2). Ignored by other types. */
+    mult?: number;
+}
+/** A point anchored in data space (so drawings stay attached across pan/zoom). */
+export interface DrawingPoint {
+    /** unix seconds. */
+    time: number;
+    price: number;
 }
+export type DrawingType = "trendline" | "hline" | "fib" | "rect";
+/**
+ * A user-drawn annotation on the price pane. `hline` uses `a.price`; `trendline`, `fib`
+ * (retracement levels between the two prices) and `rect` (box) use both `a` and `b`.
+ */
+export interface Drawing {
+    id: string;
+    type: DrawingType;
+    a: DrawingPoint;
+    b?: DrawingPoint;
+    color?: string;
+}
+/** Drawing interaction mode. `none` = pan/zoom + select/move; the others arm a one-shot draw. */
+export type DrawMode = "none" | "trendline" | "hline" | "fib" | "rect";
 /** Transform applied to raw prices before aggregation. */
 export interface PriceTransform {
     /** "USD" leaves prices as-is; "ETH" divides by `ethUsd`. */
@@ -56,6 +98,15 @@ export interface ChartTheme {
     axisTagText: string;
     background?: string;
 }
+/** Volume-by-price overlay config. `true` uses defaults; an object tunes it. */
+export type VolumeProfileConfig = boolean | {
+    /** number of price bands (default 24). */
+    buckets?: number;
+    /** fraction of the plot width the widest bar occupies (default 0.16). */
+    width?: number;
+    /** bar fill color (default a translucent `theme.axis`). */
+    color?: string;
+};
 export interface ChartOptions {
     /** canvas height in CSS px (default 420). */
     height?: number;
@@ -66,6 +117,11 @@ export interface ChartOptions {
     minBars?: number;
     /** cap on a candle's slot width in px — keeps sparse series tight, right-anchored (default 18). */
     maxBarWidth?: number;
+    /** cap on a candle's BODY (and volume bar) width in px (default 40). The body is 70% of
+     *  the slot up to this cap; raise it for chunkier candles on sparse / `fitContent` series. */
+    maxBodyWidth?: number;
+    /** show the volume panel (default true). */
+    showVolume?: boolean;
     /** fraction of the plot used by the volume panel (default 0.18). */
     volumeRatio?: number;
     rightPad?: number;
@@ -75,6 +131,49 @@ export interface ChartOptions {
     onCrosshair?: (candle: Candle | null) => void;
     /** moving-average overlays drawn on the price pane. */
     indicators?: Indicator[];
+    /** oscillators (RSI / MACD) drawn in stacked sub-panes below the volume panel. */
+    oscillators?: Oscillator[];
+    /** user drawings (trendlines / horizontal price lines) to render on the price pane. */
+    drawings?: Drawing[];
+    /** fired whenever the user adds, moves, or deletes a drawing. */
+    onDrawingsChange?: (drawings: Drawing[]) => void;
+    /** fired when the active draw mode changes (e.g. auto-reset to "none" after one draw). */
+    onDrawModeChange?: (mode: DrawMode) => void;
+    /** logarithmic price axis — equal vertical distance = equal % move (default false). */
+    logScale?: boolean;
+    /** centered text shown when there are no candles (default "no priced trades yet"). Feeds
+     *  set this to "Loading…" while the first page is in flight. Pass "" to draw 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 a capped slot
+     *  (default false in the core `Chart`; the React wrappers default it on). */
+    fitContent?: boolean;
+    /** y-axis price label formatter. Default adapts precision to the tick step. */
+    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;
     /** fired when the user pans/zooms near the start of loaded data (lazy history). */
     onNeedHistory?: () => void;
 }
+/** Axis label/format/layout overrides — the subset of {@link ChartOptions} that styles the ticks. */
+export interface AxisOptions {
+    fitContent?: boolean;
+    priceFormat?: (value: number) => string;
+    timeFormat?: (time: number, interval: number) => string;
+    priceTicks?: number;
+    timeTicks?: number;
+    axisFont?: string;
+    /** max candle slot width in px (spacing). */
+    maxBarWidth?: number;
+    /** max candle body / volume-bar width in px. */
+    maxBodyWidth?: number;
+}

package/dist/index.d.ts

@@ -1,12 +1,17 @@
-export { Chart } from "./core/chart";
-export { buildOHLC, transformPrice } from "./core/ohlc";
-export { draw } from "./core/renderer";
-export type { RenderInput, Viewport, Pads, ResolvedOverlay } from "./core/renderer";
+export { Chart, needsHistory, maxPanOffset } from "./core/chart";
+export { buildOHLC, transformPrice, heikinAshi } from "./core/ohlc";
+export { draw, slotWidth, windowOf, priceScale, timeScale, computeProjection, withAlpha, resolveOverlays } from "./core/renderer";
+export type { RenderInput, Viewport, Pads, ResolvedOverlay, Projection } from "./core/renderer";
 export { connectFeed } from "./core/feed";
 export type { ChartFeed, ConnectFeedOptions, FeedConnection, LoadHistoryParams } from "./core/feed";
-export { DEFAULT_THEME } from "./core/theme";
-export { formatValue, formatVolume, formatTime } from "./core/format";
-export { sma, ema, wma, vwap, bollingerBands, sourceValues, computeIndicator, INDICATOR_PALETTE } from "./core/indicators";
+export { DEFAULT_THEME, LIGHT_THEME, THEME_PRESETS } from "./core/theme";
+export { formatValue, formatAxisValue, formatVolume, formatTime } from "./core/format";
+export { sma, ema, wma, vwap, bollingerBands, rsi, macd, stochastic, atr, volumeProfile, sourceValues, computeIndicator, INDICATOR_PALETTE } from "./core/indicators";
+export type { VolumeBucket, VolumeProfileResult } from "./core/indicators";
 export { fetchHyperliquidCandles, fetchHlCandleWindow, hyperliquidFeed, mapHlCandles, HL_INTERVAL_SECONDS } from "./core/live";
 export type { HlRawCandle, FetchHlCandlesOptions, HyperliquidFeedOptions } from "./core/live";
-export type { Candle, Point, Denom, ChartType, PriceTransform, ChartTheme, ChartOptions, Indicator, IndicatorType, PriceSource, } from "./core/types";
+export { fetchPolymarketPriceHistory, polymarketFeed, POLYMARKET_CLOB } from "./core/polymarket";
+export type { PolyHistoryPoint, FetchPolyHistoryOptions, PolymarketFeedOptions } from "./core/polymarket";
+export { fetchSignalsMarket, fetchSignalsSwaps, signalsFeed, sparkCandles, rejectPriceOutliers, DEFAULT_SIGNALS_URL } from "./core/signals";
+export type { SignalsMarket, SignalsFeedOptions } from "./core/signals";
+export type { Candle, Point, Denom, ChartType, PriceTransform, ChartTheme, ChartOptions, Indicator, IndicatorType, PriceSource, Oscillator, OscillatorType, Drawing, DrawingType, DrawingPoint, DrawMode, AxisOptions, VolumeProfileConfig, } from "./core/types";

package/dist/index.js

@@ -1,11 +1,13 @@
 // livo-charts — framework-agnostic core.
 // React bindings live in the `@livo-build/charts/react` subpath so non-React
 // consumers never pull React into their bundle.
-export { Chart } from "./core/chart";
-export { buildOHLC, transformPrice } from "./core/ohlc";
-export { draw } from "./core/renderer";
+export { Chart, needsHistory, maxPanOffset } from "./core/chart";
+export { buildOHLC, transformPrice, heikinAshi } from "./core/ohlc";
+export { draw, slotWidth, windowOf, priceScale, timeScale, computeProjection, withAlpha, resolveOverlays } from "./core/renderer";
 export { connectFeed } from "./core/feed";
-export { DEFAULT_THEME } from "./core/theme";
-export { formatValue, formatVolume, formatTime } from "./core/format";
-export { sma, ema, wma, vwap, bollingerBands, sourceValues, computeIndicator, INDICATOR_PALETTE } from "./core/indicators";
+export { DEFAULT_THEME, LIGHT_THEME, THEME_PRESETS } from "./core/theme";
+export { formatValue, formatAxisValue, formatVolume, formatTime } from "./core/format";
+export { sma, ema, wma, vwap, bollingerBands, rsi, macd, stochastic, atr, volumeProfile, sourceValues, computeIndicator, INDICATOR_PALETTE } from "./core/indicators";
 export { fetchHyperliquidCandles, fetchHlCandleWindow, hyperliquidFeed, mapHlCandles, HL_INTERVAL_SECONDS } from "./core/live";
+export { fetchPolymarketPriceHistory, polymarketFeed, POLYMARKET_CLOB } from "./core/polymarket";
+export { fetchSignalsMarket, fetchSignalsSwaps, signalsFeed, sparkCandles, rejectPriceOutliers, DEFAULT_SIGNALS_URL } from "./core/signals";

package/dist/react/HyperliquidChart.d.ts

@@ -1,4 +1,4 @@
-import type { ChartTheme, ChartType, Indicator } from "../core/types";
+import type { ChartTheme, ChartType, Drawing, Indicator, Oscillator, VolumeProfileConfig } from "../core/types";
 export interface HyperliquidChartProps {
     /** Hyperliquid coin symbol, e.g. "BTC", "ETH", or a builder-dex name like "xyz:TSLA". */
     coin: string;
@@ -9,11 +9,39 @@ export interface HyperliquidChartProps {
     chartType?: ChartType;
     /** Moving-average overlays, e.g. [{ type: "ema", period: 21 }]. */
     indicators?: Indicator[];
+    /** Oscillator sub-panes (RSI / MACD), e.g. [{ type: "macd" }]. */
+    oscillators?: Oscillator[];
+    /** Initial drawings (trendlines / horizontal lines). */
+    drawings?: Drawing[];
+    /** Fired whenever the user adds, moves, or deletes a drawing. */
+    onDrawingsChange?: (drawings: Drawing[]) => void;
+    /** Hide the trendline / h-line / clear drawing-tool buttons (shown by default). */
+    hideDrawingTools?: boolean;
+    /** Show the volume panel (default true). */
+    showVolume?: boolean;
+    /** Volume-by-price histogram (default off); the toolbar adds a VP toggle when set. */
+    volumeProfile?: VolumeProfileConfig;
     /** Candles per history page; older pages load as you scroll left (default 500). */
     pageSize?: number;
     theme?: Partial<ChartTheme>;
     /** Show the interval / candle-line toolbar. Default true. */
     toolbar?: boolean;
+    /** Spread candles across the full width instead of right-anchoring (default true). */
+    fitContent?: boolean;
+    /** Max candle slot width in px (spacing; default 18). */
+    maxBarWidth?: number;
+    /** Max candle body / volume-bar width in px (default 40). */
+    maxBodyWidth?: number;
+    /** y-axis price label formatter (default adapts precision to the tick step). */
+    priceFormat?: (value: number) => string;
+    /** x-axis time label formatter. */
+    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; color is `theme.axis`. */
+    axisFont?: string;
 }
 /**
  * A turnkey, REALTIME Hyperliquid trading chart. Streams live candles over WebSocket,
@@ -25,4 +53,4 @@ export interface HyperliquidChartProps {
  * <HyperliquidChart coin="BTC" interval="15m" indicators={[{ type: "ema", period: 21 }]} />
  * ```
  */
-export declare function HyperliquidChart({ coin, interval, testnet, height, chartType, indicators, pageSize, theme, toolbar, }: HyperliquidChartProps): import("react").JSX.Element;
+export declare function HyperliquidChart({ coin, interval, testnet, height, chartType, indicators, oscillators, drawings, onDrawingsChange, hideDrawingTools, showVolume: showVolumeProp, volumeProfile: volumeProfileProp, pageSize, theme, toolbar, fitContent, maxBarWidth, maxBodyWidth, priceFormat, timeFormat, priceTicks, timeTicks, axisFont, }: HyperliquidChartProps): import("react").JSX.Element;