@pipsend/charts 2.0.1 → 2.2.0

package/dist/typings.d.ts

@@ -1902,6 +1902,28 @@ export declare function applyDonchianChannels(series: ISeriesApi<SeriesType>, ch
 export declare function applyEMA(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: EMAOptions): IndicatorRuntime<EMAOptions> & {
 	series: ISeriesApi<"Line">;
 };
+/**
+ * Draw a source series as Heikin Ashi candles.
+ *
+ * The source series is left in place holding its real prices — it is only
+ * painted transparent — so indicators bound to it keep computing on the true
+ * OHLC, its price lines and primitives stay on screen, and `remove()` puts the
+ * chart back exactly as it was. That makes this usable as a chart-type toggle:
+ *
+ * ```js
+ * const ha = applyHeikinAshi(candleSeries, chart);
+ * // …back to regular candles:
+ * ha.remove();
+ * ```
+ *
+ * @param series - Source OHLC series (a candlestick or bar series).
+ * @param chart - Chart instance.
+ * @param options - Heikin Ashi configuration options.
+ * @returns The Heikin Ashi candlestick series, plus live control over its options.
+ */
+export declare function applyHeikinAshi(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: HeikinAshiOptions): IndicatorRuntime<HeikinAshiOptions> & {
+	series: ISeriesApi<"Candlestick">;
+};
 /**
  * Ichimoku Kinko Hyo.
  *
@@ -2106,6 +2128,32 @@ export declare function applyWMA(series: ISeriesApi<SeriesType>, chart: IChartAp
 export declare function applyWilliamsR(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: WilliamsROptions): IndicatorRuntime<WilliamsROptions> & {
 	series: ISeriesApi<"Line">;
 };
+/**
+ * Turns raw OHLC bars into Heikin Ashi ones.
+ *
+ * Heikin Ashi is a price transform, not an overlay: each candle averages itself
+ * with the one before it, which drops most of the single-bar noise and leaves
+ * runs of same-coloured bodies while a trend holds.
+ *
+ * ```
+ * close = (O + H + L + C) / 4
+ * open  = (previous open + previous close) / 2      // first bar: (O + C) / 2
+ * high  = max(H, open, close)
+ * low   = min(L, open, close)
+ * ```
+ *
+ * Because every bar folds in the one before it, the result depends on where the
+ * data starts: the same bar computed from a longer history differs slightly.
+ * The difference decays over a few bars, so pass the whole series rather than a
+ * recent window when you can.
+ *
+ * Whitespace items are passed through untouched, and do not advance the
+ * running open/close — a gap in the data is not a bar.
+ *
+ * @param bars - Source bars, ordered oldest to newest.
+ * @returns The transformed bars, one per input item.
+ */
+export declare function calculateHeikinAshi<HorzScaleItem = Time>(bars: readonly HeikinAshiInput<HorzScaleItem>[]): HeikinAshiPoint<HorzScaleItem>[];
 /**
  * Automatically calculate pip configuration based on price
  * This is completely generic and works for any instrument
@@ -2426,6 +2474,21 @@ export declare function defaultHorzScaleBehavior(): new () => IHorzScaleBehavior
  * Now ignores symbol and uses price-based detection
  */
 export declare function getPipConfig(symbolOrPrice: string | number, price?: number): PipConfig;
+/**
+ * Take a series off the screen without hiding it.
+ *
+ * `visible: false` takes down everything hung off the series as well: its
+ * price lines, primitives and price-axis label stop rendering. A transform
+ * that only wants the bars themselves out of the way — Heikin Ashi drawing
+ * over its source — needs the series to stay visible to the engine, so its
+ * paint is made transparent instead and the last-value label and price line
+ * are switched off. Custom series have no known colours; those fall back to
+ * `visible: false`.
+ *
+ * @param series - Series to blank out.
+ * @returns Puts back the options the series had when it was blanked.
+ */
+export declare function hideSeriesPaint(series: ISeriesApi<SeriesType>): () => void;
 /**
  * Check if a time value is a business day object.
  *
@@ -3612,6 +3675,36 @@ export interface HandleScrollOptions {
 	 */
 	vertTouchDrag: boolean;
 }
+export interface HeikinAshiOptions {
+	/** Pane the candles are drawn in. Fixed at creation. */
+	paneIndex?: number;
+	/** Color of rising Heikin Ashi candles. */
+	upColor?: string;
+	/** Color of falling Heikin Ashi candles. */
+	downColor?: string;
+	/** Enable candle borders. */
+	borderVisible?: boolean;
+	/** Border color of rising candles. */
+	borderUpColor?: string;
+	/** Border color of falling candles. */
+	borderDownColor?: string;
+	/** Enable high and low price candle wicks. */
+	wickVisible?: boolean;
+	/** Wick color of rising candles. */
+	wickUpColor?: string;
+	/** Wick color of falling candles. */
+	wickDownColor?: string;
+	/**
+	 * Blank out the source series while the Heikin Ashi candles are shown, so
+	 * the two do not overlap. The source is painted transparent rather than
+	 * hidden: it stays visible to the engine, so its price lines, primitives
+	 * and everything else hung off it keep rendering. `remove()` puts its paint
+	 * back.
+	 *
+	 * @defaultValue `true`
+	 */
+	hideSource?: boolean;
+}
 /**
  * Structure describing a single item of data for histogram series
  */
@@ -7478,6 +7571,10 @@ export type DrawingToolType = "ruler" | "fibonacci" | "position" | "trendline" |
  * The valid values are integers in range [0, 255]
  */
 export type GreenComponent = Nominal<number, "GreenComponent">;
+/** A bar the Heikin Ashi transform can read: a real OHLC bar, or a gap. */
+export type HeikinAshiInput<HorzScaleItem = Time> = OhlcData<HorzScaleItem> | WhitespaceData<HorzScaleItem>;
+/** What it produces: a smoothed candle per input bar, gaps passed through. */
+export type HeikinAshiPoint<HorzScaleItem = Time> = CandlestickData<HorzScaleItem> | WhitespaceData<HorzScaleItem>;
 /**
  * Represents histogram series options.
  */

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.1",
+  "version": "2.2.0",
   "name": "@pipsend/charts",
   "author": "Pipsend",
   "license": "SEE LICENSE IN LICENSE",