@livo-build/charts 0.2.3 → 0.2.4

package/dist/core/polymarket.d.ts

@@ -32,13 +32,22 @@ export interface PolymarketFeedOptions {
     host?: string;
     /** Live poll cadence in ms (default 30s; 0 disables the live poll). */
     refetchMs?: number;
+    /**
+     * Optional Livo indexer base (e.g. "https://polymarket.livo.build"). When set (and
+     * EventSource is available), the live candle is driven by the indexer's `/stream` SSE
+     * — INSTANT updates on every price/trade — instead of the 30s history poll. History
+     * still loads from the public CLOB, so this is a pure realtime upgrade. Omit to keep
+     * the dependency-free poll-only behavior.
+     */
+    liveUrl?: string;
     /** Override "now" (ms) — for tests/determinism. */
     now?: number;
 }
 /**
  * A {@link ChartFeed} for a Polymarket outcome: paged price history bucketed into OHLC
- * candles, plus a polling "live" candle (Polymarket has no public candle socket, so the
- * latest bucket is re-fetched on an interval). Price-history has no volume, so candles
- * carry `vol: 0`. Pass it to `connectFeed` with `bucketSeconds` as the interval.
+ * candles, plus a "live" candle. By default the latest bucket is re-fetched on an
+ * interval (Polymarket has no public candle socket). Pass `liveUrl` (a Livo indexer) to
+ * upgrade the live candle to INSTANT SSE updates. Price-history has no volume, so
+ * history candles carry `vol: 0`. Pass it to `connectFeed` with `bucketSeconds`.
  */
 export declare function polymarketFeed(opts: PolymarketFeedOptions): ChartFeed;

package/dist/core/polymarket.js

@@ -41,15 +41,17 @@ export async function fetchPolymarketPriceHistory(opts) {
 }
 /**
  * A {@link ChartFeed} for a Polymarket outcome: paged price history bucketed into OHLC
- * candles, plus a polling "live" candle (Polymarket has no public candle socket, so the
- * latest bucket is re-fetched on an interval). Price-history has no volume, so candles
- * carry `vol: 0`. Pass it to `connectFeed` with `bucketSeconds` as the interval.
+ * candles, plus a "live" candle. By default the latest bucket is re-fetched on an
+ * interval (Polymarket has no public candle socket). Pass `liveUrl` (a Livo indexer) to
+ * upgrade the live candle to INSTANT SSE updates. Price-history has no volume, so
+ * history candles carry `vol: 0`. Pass it to `connectFeed` with `bucketSeconds`.
  */
 export function polymarketFeed(opts) {
     const secs = opts.bucketSeconds ?? 3600;
     const host = opts.host ?? POLYMARKET_CLOB;
     const tokenId = opts.tokenId;
     const fidelity = Math.max(1, Math.round(secs / 60));
+    const ES = globalThis.EventSource;
     return {
         async loadHistory({ before, limit }) {
             const endTs = Math.floor((before ?? opts.now ?? Date.now()) / 1000);
@@ -58,35 +60,114 @@ export function polymarketFeed(opts) {
             return buildOHLC(points, secs);
         },
         subscribe(_params, onUpdate) {
-            const ms = opts.refetchMs ?? 30000;
-            if (ms <= 0)
-                return () => { };
-            let stopped = false;
-            let timer;
-            const tick = async () => {
-                if (stopped)
-                    return;
-                try {
-                    // re-fetch the last few buckets and emit the most recent candle.
-                    const endTs = Math.floor((opts.now ?? Date.now()) / 1000);
-                    const points = await fetchPolymarketPriceHistory({ tokenId, host, startTs: endTs - secs * 3, endTs, fidelity });
-                    const candles = buildOHLC(points, secs);
-                    const last = candles[candles.length - 1];
-                    if (last && !stopped)
-                        onUpdate(last);
-                }
-                catch {
-                    /* transient fetch error — try again next tick */
-                }
-                if (!stopped)
-                    timer = setTimeout(tick, ms);
-            };
-            timer = setTimeout(tick, ms);
-            return () => {
-                stopped = true;
-                if (timer)
-                    clearTimeout(timer);
+            // Poll the latest buckets from the public CLOB (the default + the SSE fallback).
+            const startPoll = () => {
+                const ms = opts.refetchMs ?? 30000;
+                if (ms <= 0)
+                    return () => { };
+                let stopped = false;
+                let timer;
+                const tick = async () => {
+                    if (stopped)
+                        return;
+                    try {
+                        const endTs = Math.floor((opts.now ?? Date.now()) / 1000);
+                        const points = await fetchPolymarketPriceHistory({ tokenId, host, startTs: endTs - secs * 3, endTs, fidelity });
+                        const candles = buildOHLC(points, secs);
+                        const last = candles[candles.length - 1];
+                        if (last && !stopped)
+                            onUpdate(last);
+                    }
+                    catch {
+                        /* transient fetch error — try again next tick */
+                    }
+                    if (!stopped)
+                        timer = setTimeout(tick, ms);
+                };
+                timer = setTimeout(tick, ms);
+                return () => {
+                    stopped = true;
+                    if (timer)
+                        clearTimeout(timer);
+                };
             };
+            // Realtime via the Livo indexer's SSE stream (instant), when configured + available.
+            // Falls back to polling if the stream can't connect (e.g. the indexer is down).
+            if (opts.liveUrl && ES)
+                return subscribeIndexerSse(opts.liveUrl, tokenId, secs, opts.now, onUpdate, ES, startPoll);
+            return startPoll();
         },
     };
 }
+/**
+ * Drive the live candle from Livo's Polymarket indexer SSE (`/stream`): `price` frames
+ * (mid) and `trade` frames (price + size → volume) for our token roll the in-progress
+ * bucket. If the stream can't connect (indexer down), it falls back to `startPoll` so the
+ * chart still gets a building candle. Returns an unsubscribe fn.
+ */
+function subscribeIndexerSse(liveUrl, tokenId, secs, nowOverride, onUpdate, ES, startPoll) {
+    let cur = null;
+    let gotMessage = false;
+    let pollStop;
+    const es = new ES(`${liveUrl.replace(/\/$/, "")}/stream`);
+    // If the stream errors before ever delivering a frame, it's almost certainly down —
+    // close it and fall back to the poll. (A drop AFTER messages auto-reconnects via ES.)
+    es.onerror = () => {
+        if (!gotMessage && !pollStop) {
+            try {
+                es.close();
+            }
+            catch {
+                /* already closing */
+            }
+            pollStop = startPoll();
+        }
+    };
+    const tick = (price, vol = 0) => {
+        gotMessage = true;
+        if (!(price > 0) || !isFinite(price))
+            return;
+        const nowSec = Math.floor((nowOverride ?? Date.now()) / 1000);
+        const bt = Math.floor(nowSec / secs) * secs;
+        if (!cur || bt > cur.time)
+            cur = { time: bt, o: price, h: price, l: price, c: price, vol };
+        else {
+            cur.h = Math.max(cur.h, price);
+            cur.l = Math.min(cur.l, price);
+            cur.c = price;
+            cur.vol += vol;
+        }
+        onUpdate({ ...cur });
+    };
+    const onPrice = (ev) => {
+        try {
+            const d = JSON.parse(ev.data);
+            if (d.tokenId === tokenId)
+                tick(d.mid || d.last || 0);
+        }
+        catch {
+            /* ignore malformed frame */
+        }
+    };
+    const onTrade = (ev) => {
+        try {
+            const d = JSON.parse(ev.data);
+            if (d.tokenId === tokenId && d.price)
+                tick(d.price, d.size || 0);
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    es.addEventListener("price", onPrice);
+    es.addEventListener("trade", onTrade);
+    return () => {
+        try {
+            es.close();
+        }
+        catch {
+            /* already closed */
+        }
+        pollStop?.();
+    };
+}

package/dist/react/PolymarketChart.d.ts

@@ -6,8 +6,13 @@ export interface PolymarketChartProps {
     bucketSeconds?: number;
     /** Override the CLOB host. */
     host?: string;
-    /** Live poll cadence in ms (default 30s; 0 = fetch once). */
+    /** Live poll cadence in ms (default 30s; 0 = fetch once). Ignored when `liveUrl` is set. */
     refetchMs?: number;
+    /**
+     * Optional Livo indexer base (e.g. "https://polymarket.livo.build") — upgrades the live
+     * candle from the 30s poll to INSTANT SSE updates. History still loads from the CLOB.
+     */
+    liveUrl?: string;
     /** Candles per history page; older pages load as you scroll left (default 500). */
     pageSize?: number;
     height?: number;
@@ -37,4 +42,4 @@ export interface PolymarketChartProps {
  * <PolymarketChart tokenId={yesTokenId} bucketSeconds={3600} label="Yes" />
  * ```
  */
-export declare function PolymarketChart({ tokenId, bucketSeconds, host, refetchMs, pageSize, height, chartType, indicators, oscillators, drawings, onDrawingsChange, hideDrawingTools, showVolume: showVolumeProp, volumeProfile: volumeProfileProp, theme, toolbar, fitContent, label, priceFormat, }: PolymarketChartProps): import("react").JSX.Element;
+export declare function PolymarketChart({ tokenId, bucketSeconds, host, refetchMs, liveUrl, pageSize, height, chartType, indicators, oscillators, drawings, onDrawingsChange, hideDrawingTools, showVolume: showVolumeProp, volumeProfile: volumeProfileProp, theme, toolbar, fitContent, label, priceFormat, }: PolymarketChartProps): import("react").JSX.Element;

package/dist/react/PolymarketChart.js

@@ -16,7 +16,7 @@ const pct = (v) => `${(v * 100).toFixed(1)}%`;
  * <PolymarketChart tokenId={yesTokenId} bucketSeconds={3600} label="Yes" />
  * ```
  */
-export function PolymarketChart({ tokenId, bucketSeconds = 3600, host, refetchMs, pageSize = 500, height = 420, chartType = "line", indicators, oscillators, drawings, onDrawingsChange, hideDrawingTools = false, showVolume: showVolumeProp = false, volumeProfile: volumeProfileProp, theme, toolbar = true, fitContent = true, label, priceFormat = pct, }) {
+export function PolymarketChart({ tokenId, bucketSeconds = 3600, host, refetchMs, liveUrl, pageSize = 500, height = 420, chartType = "line", indicators, oscillators, drawings, onDrawingsChange, hideDrawingTools = false, showVolume: showVolumeProp = false, volumeProfile: volumeProfileProp, theme, toolbar = true, fitContent = true, label, priceFormat = pct, }) {
     const [secs, setSecs] = useState(bucketSeconds);
     const [type, setType] = useState(chartType);
     const [log, setLog] = useState(false);
@@ -70,7 +70,7 @@ export function PolymarketChart({ tokenId, bucketSeconds = 3600, host, refetchMs
             return;
         setLoading(true);
         setError(null);
-        const feed = polymarketFeed({ tokenId, bucketSeconds: secs, host, refetchMs });
+        const feed = polymarketFeed({ tokenId, bucketSeconds: secs, host, refetchMs, liveUrl });
         const conn = connectFeed(chart.current, feed, {
             interval: secs,
             pageSize,
@@ -85,7 +85,7 @@ export function PolymarketChart({ tokenId, bucketSeconds = 3600, host, refetchMs
             },
         });
         return () => conn.disconnect();
-    }, [tokenId, secs, host, refetchMs, pageSize]);
+    }, [tokenId, secs, host, refetchMs, liveUrl, pageSize]);
     const info = legend ?? last;
     const lc = info && info.c >= info.o ? th.up : th.down;
     const { btn, sepStyle, barStyle, muted } = toolbarUi(th);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livo-build/charts",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "livo-charts — a lightweight, dependency-free canvas charting library (candlesticks/line/baseline/Heikin-Ashi, zoom/pan, crosshair, MA/RSI/MACD/Stochastic/ATR indicators, volume profile, drawing tools, and live Hyperliquid/Polymarket/Signal-Radar feeds) with a framework-agnostic core and a React wrapper.",
   "type": "module",
   "license": "UNLICENSED",