/* *
 *
 *  (c) 2010-2026 Highsoft AS
 *  Author: Torstein Hønsi
 *
 *  Integration of this software requires a license.
 *  - For commercial use, see www.highcharts.com/license
 *  - For non-commercial, see www.highcharts.com/license-eula
 *
 *
 * */
'use strict';
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
/* *
 *
 *  Imports
 *
 * */
import HollowCandlestickPoint from './HollowCandlestickPoint.js';
import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
import Axis from '../../Core/Axis/Axis.js';
import { addEvent, merge } from '../../Shared/Utilities.js';
var CandlestickSeries = SeriesRegistry.seriesTypes.candlestick;
/* *
 *
 *  Code
 *
 * */
/**
 * The hollowcandlestick series.
 *
 * @private
 * @class
 * @name Highcharts.seriesTypes.hollowcandlestick
 *
 * @augments Highcharts.seriesTypes.candlestick
 */
var HollowCandlestickSeries = /** @class */ (function (_super) {
    __extends(HollowCandlestickSeries, _super);
    function HollowCandlestickSeries() {
        /* *
         *
         * Static properties
         *
         * */
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.hollowCandlestickData = [];
        return _this;
    }
    /* *
     *
     * Functions
     *
     * */
    /**
     * Iterate through all points and get their type.
     * @private
     *
     * @function Highcharts.seriesTypes.hollowcandlestick#getPriceMovement
     *
     *
     */
    HollowCandlestickSeries.prototype.getPriceMovement = function () {
        var series = this, table = series.allGroupedTable || series.dataTable, dataLength = table.rowCount, hollowCandlestickData = this.hollowCandlestickData;
        hollowCandlestickData.length = 0;
        var previousDataPoint;
        for (var i = 0; i < dataLength; i++) {
            var dataPoint = table.getRowObject(i, this.pointArrayMap);
            hollowCandlestickData.push(series.isBullish(dataPoint, 
            // Determine the first point is bullish based on
            // its open and close values.(#21683)
            i ? previousDataPoint : dataPoint));
            previousDataPoint = dataPoint;
        }
    };
    /**
     * Return line color based on candle type.
     * @private
     *
     * @function Highcharts.seriesTypes.hollowcandlestick#getLineColor
     *
     * @param {string} trendDirection
     * Type of candle direction (bearish/bullish)(down/up).
     *
     * @return {ColorType}
     * Line color
     */
    HollowCandlestickSeries.prototype.getLineColor = function (trendDirection) {
        var series = this;
        // Return line color based on trend direction
        return trendDirection === 'up' ?
            series.options.upColor || 'var(--highcharts-positive-color)' :
            series.options.color || 'var(--highcharts-negative-color)';
    };
    /**
     * Return fill color based on candle type.
     * @private
     *
     * @function Highcharts.seriesTypes.hollowcandlestick#getPointFill
     *
     * @param {HollowcandleInfo} hollowcandleInfo
     *        Information about the current candle.
     *
     * @return {ColorType}
     * Point fill color
     */
    HollowCandlestickSeries.prototype.getPointFill = function (hollowcandleInfo) {
        var series = this;
        // Return fill color only for bearish candles.
        if (hollowcandleInfo.isBullish) {
            return 'transparent';
        }
        return hollowcandleInfo.trendDirection === 'up' ?
            series.options.upColor || 'var(--highcharts-positive-color)' :
            series.options.color || 'var(--highcharts-negative-color)';
    };
    /**
     * @private
     * @function Highcharts.seriesTypes.hollowcandlestick#init
     */
    HollowCandlestickSeries.prototype.init = function () {
        _super.prototype.init.apply(this, arguments);
        this.hollowCandlestickData = [];
    };
    /**
     * Check if the candle is bearish or bullish. For bullish one, return true.
     * For bearish, return string depending on the previous point.
     *
     * @function Highcharts.seriesTypes.hollowcandlestick#isBullish
     *
     * @param {Object} dataPoint
     * Current point which we calculate.
     *
     * @param {Object} previousDataPoint
     * Previous point.
     */
    HollowCandlestickSeries.prototype.isBullish = function (dataPoint, previousDataPoint) {
        return {
            // Compare points' open and close value.
            isBullish: (dataPoint.open || 0) <= (dataPoint.close || 0),
            // For bearish candles.
            trendDirection: (dataPoint.close || 0) < ((previousDataPoint === null || previousDataPoint === void 0 ? void 0 : previousDataPoint.close) || 0) ?
                'down' : 'up'
        };
    };
    /**
     * Add color and fill attribute for each point.
     *
     * @private
     *
     * @function Highcharts.seriesTypes.hollowcandlestick#pointAttribs
     *
     * @param {HollowCandlestickPoint} point
     * Point to which we are adding attributes.
     *
     * @param {StatesOptionsKey} state
     * Current point state.
     */
    HollowCandlestickSeries.prototype.pointAttribs = function (point, state) {
        var attribs = _super.prototype.pointAttribs.call(this, point, state);
        var stateOptions;
        var index = point === null || point === void 0 ? void 0 : point.index, hollowcandleInfo = this.hollowCandlestickData[index || 0] || {};
        attribs.fill = this.getPointFill(hollowcandleInfo) || attribs.fill;
        attribs.stroke = this.getLineColor(hollowcandleInfo.trendDirection) ||
            attribs.stroke;
        // Select or hover states
        if (state) {
            stateOptions = this.options.states[state];
            attribs.fill = stateOptions.color || attribs.fill;
            attribs.stroke = stateOptions.lineColor || attribs.stroke;
            attribs['stroke-width'] =
                stateOptions.lineWidth || attribs['stroke-width'];
        }
        return attribs;
    };
    /**
     * A hollow candlestick chart is a style of financial chart used to
     * describe price movements over time.
     *
     * @sample stock/demo/hollow-candlestick/
     *         Hollow Candlestick chart
     *
     * @extends      plotOptions.candlestick
     * @product      highstock
     * @requires     modules/hollowcandlestick
     * @optionparent plotOptions.hollowcandlestick
     */
    HollowCandlestickSeries.defaultOptions = merge(CandlestickSeries.defaultOptions, {
        /**
         * The fill color of the candlestick when the current
         * close is lower than the previous one.
         *
         * @sample stock/plotoptions/hollow-candlestick-color/
         *     Custom colors
         * @sample {highstock} highcharts/css/hollow-candlestick/
         *         Colors in styled mode
         *
         * @type    {ColorType}
         * @product highstock
         */
        color: 'var(--highcharts-negative-color)',
        dataGrouping: {
            groupAll: true,
            groupPixelWidth: 10
        },
        /**
         * The color of the line/border of the hollow candlestick when
         * the current close is lower than the previous one.
         *
         * @sample stock/plotoptions/hollow-candlestick-color/
         *     Custom colors
         * @sample {highstock} highcharts/css/hollow-candlestick/
         *         Colors in styled mode
         *
         * @type    {ColorType}
         * @product highstock
         */
        lineColor: 'var(--highcharts-negative-color)',
        /**
         * The fill color of the candlestick when the current
         * close is higher than the previous one.
         *
         * @sample stock/plotoptions/hollow-candlestick-color/
         *     Custom colors
         * @sample {highstock} highcharts/css/hollow-candlestick/
         *         Colors in styled mode
         *
         * @type    {ColorType}
         * @product highstock
         */
        upColor: 'var(--highcharts-positive-color)',
        /**
         * The color of the line/border of the hollow candlestick when
         * the current close is higher than the previous one.
         *
         * @sample stock/plotoptions/hollow-candlestick-color/
         *     Custom colors
         * @sample {highstock} highcharts/css/hollow-candlestick/
         *         Colors in styled mode
         *
         * @type    {ColorType}
         * @product highstock
         */
        upLineColor: 'var(--highcharts-positive-color)'
    });
    return HollowCandlestickSeries;
}(CandlestickSeries));
// Force to recalculate the hollowcandlestick data set after updating data.
addEvent(HollowCandlestickSeries, 'updatedData', function () {
    if (this.hollowCandlestickData.length) {
        this.hollowCandlestickData.length = 0;
    }
});
// After processing and grouping the data,
// check if the candle is bearish or bullish.
// Required for further calculation.
addEvent(Axis, 'postProcessData', function () {
    var axis = this, series = axis.series;
    series.forEach(function (series) {
        if (series.is('hollowcandlestick')) {
            series.getPriceMovement();
        }
    });
});
/* *
 *
 *  Class Prototype
 *
 * */
HollowCandlestickSeries.prototype.pointClass = HollowCandlestickPoint;
SeriesRegistry.registerSeriesType('hollowcandlestick', HollowCandlestickSeries);
/* *
 *
 * Default Export
 *
 * */
export default HollowCandlestickSeries;
/* *
 *
 * API Options
 *
 * */
/**
 * A `hollowcandlestick` series. If the [type](#series.candlestick.type)
 * option is not specified, it is inherited from [chart.type](
 * #chart.type).
 *
 * @type      {*}
 * @extends   series,plotOptions.hollowcandlestick
 * @excluding dataParser, dataURL, marker
 * @product   highstock
 * @requires  modules/hollowcandlestick
 * @apioption series.hollowcandlestick
 */
/**
 * An array of data points for the series. For the `hollowcandlestick` series
 * type, points can be given in the following ways:
 *
 * 1. An array of arrays with 5 or 4 values. In this case, the values correspond
 *    to `x,open,high,low,close`. If the first value is a string, it is applied
 *    as the name of the point, and the `x` value is inferred. The `x` value can
 *    also be omitted, in which case the inner arrays should be of length 4.
 *    Then the `x` value is automatically calculated, either starting at 0 and
 *    incremented by 1, or from `pointStart` and `pointInterval` given in the
 *    series options.
 *    ```js
 *    data: [
 *        [0, 7, 2, 0, 4],
 *        [1, 1, 4, 2, 8],
 *        [2, 3, 3, 9, 3]
 *    ]
 *    ```
 *
 * 2. An array of objects with named values. The following snippet shows only a
 *    few settings, see the complete options set below. If the total number of
 *    data points exceeds the series'
 *    [turboThreshold](#series.hollowcandlestick.turboThreshold), this option is not
 *    available.
 *    ```js
 *    data: [{
 *        x: 1,
 *        open: 9,
 *        high: 2,
 *        low: 4,
 *        close: 6,
 *        name: "Point2",
 *        color: "#00FF00"
 *    }, {
 *        x: 1,
 *        open: 1,
 *        high: 4,
 *        low: 7,
 *        close: 7,
 *        name: "Point1",
 *        color: "#FF00FF"
 *    }]
 *    ```
 *
 * @basic
 * @type      {Array<Array<(number|string),number,number,number>|Array<(number|string),number,number,number,number>|*>}
 * @extends   series.candlestick.data
 * @excluding y
 * @product   highstock
 * @apioption series.hollowcandlestick.data
 */
''; // Adds doclets above to transpiled
