ReadonlydeviationReadonlyplacementWhere the indicator renders (overlay vs. its own pane).
Optional ReadonlypriceWhich price scale an overlay-placement indicator projects through
(B2). 'right' (the default when undefined) is the primary scale
shared with the price series; 'left' binds the indicator to the
independent secondary scale, which the chart enables — reserving the
left axis strip — only while at least one indicator requests it.
Ignored for pane-placement indicators (they own their sub-pane axis).
Subclasses opt in by overriding this getter (or declaring a matching
readonly field).
Stable human-readable identifier, e.g. sma(20) or rsi(14). Used as
the cache key by the IndicatorRegistry and as a label in legends.
Read the buffer and return one or more aligned series. Every returned
Float64Array MUST have the same length as buffer.length so the
renderer can align values with candles index-for-index.
Memoized wrapper around compute. Returns the same cached array
reference while the SAME buffer's version and length are unchanged.
The buffer identity is part of the key so reusing one indicator
instance across two buffers (or swapping a chart's buffer) never
returns another buffer's stale series — important right after init when
distinct buffers can share version: 0 and the same length.
When the data did change but only via a single realtime tick — an
updateLast (same length) or one append (length + 1) on the SAME
buffer with an unmoved head (firstTime unchanged) — and the
subclass provides an updateTail hook, the tail is patched in O(tail)
instead of recomputing the whole series in O(n). firstTime is part
of the key precisely so a prepend/evictHead (which shifts the head
and renumbers every index) can never be mistaken for an append/update
and forces a full recompute.
Use this on render paths; use compute directly to force a fresh
computation.
Protected OptionalupdateOptional incremental-update hook. When implemented, computeCached
calls it instead of the full compute for the two cheap realtime
mutations — an in-place updateLast (length unchanged) or a single
append (length grew by one) — provided the buffer head has not
moved (same firstTime).
kind is 'updateLast' when only the final candle changed, or
'append' when exactly one candle was added.
Contract:
Float64Arrays. Copy
prev[k].values into a fresh array of the correct length and
recompute only the affected tail. NEVER mutate the arrays inside
prev: a caller may still hold a reference to the previously
returned series (e.g. a renderer captured it last frame), and
mutating it in place would corrupt that snapshot.null to fall back to a full compute (e.g. when the
affected index falls inside the warmup/seed region where the
incremental recurrence is not valid).Only implement this for indicators whose tail value is a pure
function of the input candles plus PREVIOUS OUTPUT values already
present in prev — i.e. no hidden recursive state (Wilder
smoothing, running trend flips, etc.) that an incremental step
cannot reconstruct. Indicators without this hook always take the
full-recompute path and stay correct automatically.
ZigZag — connects significant swing highs and lows, filtering out moves smaller than
deviationpercent. Useful as a structural overlay (Elliott wave / pattern scaffolding) and as the basis for Fibonacci anchoring.The output series carries the swing price at each pivot index and NaN everywhere else; the overlay renderer connects the non-NaN points with straight lines, producing the characteristic zigzag.
Algorithm: track the running extreme in the current direction; when price reverses by at least
deviation% from that extreme, commit the extreme as a pivot and flip direction. This is the standard single-pass percentage ZigZag. Note it is inherently non-causal at the right edge (the last leg can still extend), which is expected behavior for ZigZag.