openalgo-charts 1.8.3 → 1.8.4

package/README.md

@@ -210,11 +210,11 @@ Enforced in CI by [`size-limit`](./.size-limit.json). Nothing is excluded, becau
 |---|---|---|
 | Base engine | 60 KB | 59.06 KB |
 | Base + trade | 68 KB | 66.67 KB |
-| Indicators tier | 30 KB | 27.21 KB |
+| Indicators tier | 30 KB | 27.27 KB |
 | Draw tier | 14 KB | 13.13 KB |
 | Transform tier | 5 KB | 2.66 KB |
 | Profile tier | 11 KB | 10.66 KB |
-| **Everything** | **124 KB** | **120.32 KB** |
+| **Everything** | **124 KB** | **120.38 KB** |
 
 ## Documentation
 
@@ -271,7 +271,7 @@ npm run verify     # typecheck + test + build + size
 
 ## Status & limitations
 
-Version **1.8.3**. All engine build phases are implemented with 2408 unit tests across 129 files.
+Version **1.8.4**. All engine build phases are implemented with 2411 unit tests across 130 files.
 
 Known gaps, stated plainly:
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /** Library version string. Matches package.json (published npm release). */
-declare const VERSION = "1.8.3";
+declare const VERSION = "1.8.4";
 /** Returns the current library version. */
 declare function version(): string;
 
@@ -2296,6 +2296,13 @@ interface IndicatorHost {
      */
     addIndicatorPrimitive?(primitive: IPrimitive, paneIndex: number): void;
     removeIndicatorPrimitive?(primitive: IPrimitive): void;
+    /**
+     * Recompute whatever the host has marked stale, before a caller reads a value.
+     *
+     * Optional, like `timezone`, so a host predating it still satisfies this
+     * interface: one that recomputes eagerly has nothing to flush.
+     */
+    flushIndicators?(): void;
     /** Bars of the primary price series — the calculation input. */
     sourceBars(): readonly Bar[];
     /** Index of a fresh pane for an indicator that wants its own. */
@@ -3349,6 +3356,7 @@ declare class Chart {
     private readonly _indicators;
     /** Guards indicator recompute against re-entry via its own `series.setData`. */
     private _recomputing;
+    private _indicatorsDirty;
     /** Instance id of the indicator whose colours are on the price bars, if any. */
     private _barColorOwner;
     private _barColors;
@@ -3524,7 +3532,13 @@ declare class Chart {
      * descriptor chose.
      */
     private _distinctColors;
-    /** Every live indicator instance, in the order they were added. */
+    /**
+     * Every live indicator instance, in the order they were added.
+     *
+     * Flushes any pending recompute first. Indicator maths is deferred to the
+     * frame, so a caller that updates a bar and reads a value back in the same
+     * turn would otherwise see the previous tick's numbers.
+     */
     indicators(): readonly IndicatorApi[];
     /** Remove one indicator instance by its handle id. Returns true if it existed. */
     removeIndicator(instanceId: string): boolean;
@@ -3535,7 +3549,7 @@ declare class Chart {
      *
      * Only one overlay can be on the candles, so this is last writer wins. That is
      * deterministic rather than arbitrary: publishers run inside
-     * `_recomputeIndicators`, in `addIndicator` order, so the same instance wins
+     * `_flushIndicators`, in `addIndicator` order, so the same instance wins
      * every frame. Withdrawal is gated on ownership, or the first publisher's
      * teardown would wipe the second one's colours. If the *winner* is removed
      * while another publisher is still live, the bars go back to their own colours
@@ -3554,11 +3568,27 @@ declare class Chart {
      */
     private _applyBarColors;
     /**
-     * Recompute every indicator after a source-data change. Reentrant-guarded:
-     * an indicator writes its plots with `series.setData`, which re-enters the
-     * same data-mutation path that called us.
+     * Mark every indicator stale after a source-data change, to be recomputed
+     * once before the next paint.
+     *
+     * Recomputing straight from the data update instead costs a full pass over
+     * every bar, for every indicator, for every tick. A busy symbol delivers ticks
+     * in bursts far faster than the display refreshes, so most of those passes are
+     * thrown away unseen: 50 ticks between two frames cost 50 recomputes per
+     * indicator and blocked the main thread for over half a second on a ten
+     * indicator chart. Deferring to the frame makes that one recompute, because
+     * only the last one could ever have been shown.
+     *
+     * `flushIndicators` therefore has to run before anything that can observe a
+     * value, which is the frame and the public `indicators()` accessor.
+     */
+    private _invalidateIndicators;
+    /**
+     * Recompute every stale indicator. Reentrant-guarded: an indicator writes its
+     * plots with `series.setData`, which re-enters the same data-mutation path
+     * that marked us dirty.
      */
-    private _recomputeIndicators;
+    private _flushIndicators;
     /** Subscribe to clicks on hit-testable primitives (markers, events, lines). */
     subscribeClick(cb: (externalId: string) => void): void;
     /**