scichart 2.1.2301 → 2.2.2389

package/Charting/Visuals/RenderableSeries/FastErrorBarsRenderableSeries.js

@@ -0,0 +1,357 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adjustRangeByStrokeThickness = exports.FastErrorBarsRenderableSeries = void 0;
+var Deleter_1 = require("../../../Core/Deleter");
+var NumberRange_1 = require("../../../Core/NumberRange");
+var AxisType_1 = require("../../../types/AxisType");
+var DataPointWidthMode_1 = require("../../../types/DataPointWidthMode");
+var ErrorDirection_1 = require("../../../types/ErrorDirection");
+var ErrorMode_1 = require("../../../types/ErrorMode");
+var SeriesType_1 = require("../../../types/SeriesType");
+var IDataSeries_1 = require("../../Model/IDataSeries");
+var HlcPointSeriesWrapped_1 = require("../../Model/PointSeries/HlcPointSeriesWrapped");
+var BaseRenderableSeries_1 = require("./BaseRenderableSeries");
+var constants_1 = require("./constants");
+var ErrorSeriesDrawingProvider_1 = require("./DrawingProviders/ErrorSeriesDrawingProvider");
+var PointMarkerDrawingProvider_1 = require("./DrawingProviders/PointMarkerDrawingProvider");
+var ErrorSeriesHitTestProvider_1 = require("./HitTest/ErrorSeriesHitTestProvider");
+/**
+ * Defines an Error Bars Series or Error Bars chart type in the SciChart's High Performance Real-time
+ * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
+ * @remarks
+ * To add a line series to a {@link SciChartSurface} you need to declare both the {@link FastErrorBarsRenderableSeries | RenderableSeries}
+ * and a {@link HlcDataSeries | DataSeries}. Simplified code sample below:
+ *
+ * ```ts
+ * const sciChartSurface: SciChartSurface;
+ * const wasmContext: TSciChart;
+ * // Create and fill the dataseries
+ * const dataSeries = new HlcDataSeries(wasmContext);
+ * dataSeries.append(1, 2, 0,4, 0.5);
+ * dataSeries.append(2, 3, 0,2, 0.3);
+ * // Create the renderableSeries
+ * const errorSeries = new FastErrorBarsRenderableSeries(wasmContext);
+ * errorSeries.dataSeries = dataSeries;
+ * // append to the SciChartSurface
+ * sciChartSurface.renderableSeries.add(errorSeries);
+ * ```
+ */
+var FastErrorBarsRenderableSeries = /** @class */ (function (_super) {
+    __extends(FastErrorBarsRenderableSeries, _super);
+    /**
+     * Creates an instance of the {@link FastErrorBarsRenderableSeries}
+     * @param webAssemblyContext The {@link TSciChart | SciChart WebAssembly Context} containing
+     * native methods and access to our WebGL2 WebAssembly Drawing Engine
+     * @param options optional parameters of type {@link IFastErrorBarsRenderableSeriesOptions} applied when constructing the series type
+     */
+    function FastErrorBarsRenderableSeries(webAssemblyContext, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _this = _super.call(this, webAssemblyContext, options) || this;
+        _this.type = SeriesType_1.ESeriesType.ErrorBarsSeries;
+        _this.dataPointWidthProperty = 0.5;
+        _this.dataPointWidthModeProperty = DataPointWidthMode_1.EDataPointWidthMode.Relative;
+        _this.errorModeProperty = ErrorMode_1.EErrorMode.Both;
+        _this.errorDirectionProperty = ErrorDirection_1.EErrorDirection.Vertical;
+        _this.strokeDashArrayProperty = [];
+        _this.drawWhiskersProperty = true;
+        _this.drawConnectorProperty = true;
+        _this.dataPointWidth = (_a = options === null || options === void 0 ? void 0 : options.dataPointWidth) !== null && _a !== void 0 ? _a : _this.dataPointWidthProperty;
+        _this.errorModeProperty = (_b = options === null || options === void 0 ? void 0 : options.errorMode) !== null && _b !== void 0 ? _b : _this.errorModeProperty;
+        _this.errorDirectionProperty = (_c = options === null || options === void 0 ? void 0 : options.errorDirection) !== null && _c !== void 0 ? _c : _this.errorDirectionProperty;
+        _this.dataPointWidthMode = (_d = options === null || options === void 0 ? void 0 : options.dataPointWidthMode) !== null && _d !== void 0 ? _d : _this.dataPointWidthModeProperty;
+        _this.strokeDashArray = (_e = options === null || options === void 0 ? void 0 : options.strokeDashArray) !== null && _e !== void 0 ? _e : _this.strokeDashArrayProperty;
+        _this.drawWhiskers = (_f = options === null || options === void 0 ? void 0 : options.drawWhiskers) !== null && _f !== void 0 ? _f : _this.drawWhiskersProperty;
+        _this.drawConnector = (_g = options === null || options === void 0 ? void 0 : options.drawConnector) !== null && _g !== void 0 ? _g : _this.drawConnectorProperty;
+        // delete inherited drawing providers
+        _this.drawingProviders = [
+            new ErrorSeriesDrawingProvider_1.ErrorSeriesDrawingProvider(webAssemblyContext, _this),
+            new PointMarkerDrawingProvider_1.PointMarkerDrawingProvider(webAssemblyContext, _this)
+        ];
+        // Must be called here for the series type to be available
+        if ((_h = _this.paletteProvider) === null || _h === void 0 ? void 0 : _h.onAttached) {
+            (_j = _this.paletteProvider) === null || _j === void 0 ? void 0 : _j.onAttached(_this);
+        }
+        if (options === null || options === void 0 ? void 0 : options.animation) {
+            _this.animationQueue.push(options.animation);
+        }
+        return _this;
+    }
+    /** @inheritDoc */
+    FastErrorBarsRenderableSeries.prototype.applyTheme = function (themeProvider) {
+        _super.prototype.applyTheme.call(this, themeProvider);
+        var previousThemeProvider = this.parentSurface.previousThemeProvider;
+        if (this.stroke === previousThemeProvider.lineSeriesColor) {
+            this.stroke = themeProvider.lineSeriesColor;
+        }
+    };
+    Object.defineProperty(FastErrorBarsRenderableSeries.prototype, "strokeDashArray", {
+        /**
+         * The StrokeDashArray defines the stroke or dash pattern for the line.
+         * Accepts an array of values, e.g. [2,2] will have a line of length 2 and a gap of length 2.
+         */
+        get: function () {
+            return this.strokeDashArrayProperty;
+        },
+        /**
+         * The StrokeDashArray defines the stroke or dash pattern for the line.
+         * Accepts an array of values, e.g. [2,2] will have a line of length 2 and a gap of length 2.
+         */
+        set: function (strokeDashArray) {
+            this.strokeDashArrayProperty = strokeDashArray;
+            this.notifyPropertyChanged(constants_1.PROPERTY.STROKE_DASH_ARRAY);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FastErrorBarsRenderableSeries.prototype, "drawWhiskers", {
+        /**
+         * Gets or sets whether Error Bars should be drawn with whiskers
+         * @remarks enabled by default
+         */
+        get: function () {
+            return this.drawWhiskersProperty;
+        },
+        /**
+         * Gets or sets whether Error Bars should be drawn with whiskers
+         * @remarks enabled by default
+         */
+        set: function (value) {
+            this.drawWhiskersProperty = value;
+            this.notifyPropertyChanged(constants_1.PROPERTY.DRAW_WHISKERS);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FastErrorBarsRenderableSeries.prototype, "drawConnector", {
+        /**
+         * Gets or sets whether Error Bars should be drawn with a connector
+         * @remarks enabled by default
+         */
+        get: function () {
+            return this.drawConnectorProperty;
+        },
+        /**
+         * Gets or sets whether Error Bars should be drawn with a connector
+         * @remarks enabled by default
+         */
+        set: function (value) {
+            this.drawConnectorProperty = value;
+            this.notifyPropertyChanged(constants_1.PROPERTY.DRAW_CONNECTOR);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FastErrorBarsRenderableSeries.prototype, "paletteProvider", {
+        /**
+         * Gets or sets the paletteProvider of Renderable Series
+         * @remarks paletteProvider is not supported by {@link FastErrorBarsRenderableSeries}
+         */
+        get: function () {
+            // TODO implement paletting for FastErrorBarsRenderableSeries
+            return undefined;
+        },
+        set: function (paletteProvider) {
+            throw new Error("paletteProvider is not supported by FastErrorBarsRenderableSeries!");
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FastErrorBarsRenderableSeries.prototype, "dataPointWidth", {
+        /**
+         * Gets or sets the width of error bar caps.
+         * By default the value is treated as relative, valid values range from 0.0 - 1.0.
+         * @remarks
+         * To specify if the value should be treated as relative or absolute use {@link errorType}
+         */
+        get: function () {
+            return this.dataPointWidthProperty;
+        },
+        /**
+         * Gets or sets the width of error bar caps.
+         * By default the value is treated as relative, valid values range from 0.0 - 1.0.
+         * @remarks
+         * To specify if the value should be treated as relative or absolute use {@link dataPointWidthMode}
+         */
+        set: function (value) {
+            this.dataPointWidthProperty = value;
+            this.notifyPropertyChanged(constants_1.PROPERTY.DATA_POINT_WIDTH);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FastErrorBarsRenderableSeries.prototype, "errorMode", {
+        /**
+         * Gets or sets the errorMode of Error Bars. Available values are {@link EErrorMode}
+         */
+        get: function () {
+            return this.errorModeProperty;
+        },
+        /**
+         * Gets or sets the errorMode of Error Bars. Available values are {@link EErrorMode}
+         */
+        set: function (value) {
+            this.errorModeProperty = value;
+            this.notifyPropertyChanged(constants_1.PROPERTY.ERROR_MODE);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FastErrorBarsRenderableSeries.prototype, "errorDirection", {
+        /**
+         * Gets or sets the errorDirection of Error Bars. Available values are {@link EErrorDirection}
+         */
+        get: function () {
+            return this.errorDirectionProperty;
+        },
+        /**
+         * Gets or sets the errorDirection of Error Bars. Available values are {@link EErrorDirection}
+         */
+        set: function (value) {
+            this.errorDirectionProperty = value;
+            this.notifyPropertyChanged(constants_1.PROPERTY.ERROR_DIRECTION);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FastErrorBarsRenderableSeries.prototype, "dataPointWidthMode", {
+        /**
+         * Gets or sets the value mode for data point width. Available values are {@link EDataPointWidthMode}
+         */
+        get: function () {
+            return this.dataPointWidthModeProperty;
+        },
+        /**
+         * Gets or sets the value mode for data point width. Available values are {@link EDataPointWidthMode}
+         */
+        set: function (value) {
+            this.dataPointWidthModeProperty = value;
+            this.notifyPropertyChanged(constants_1.PROPERTY.DATA_POINT_WIDTH_MODE);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FastErrorBarsRenderableSeries.prototype.delete = function () {
+        _super.prototype.delete.call(this);
+        this.pointSeries = (0, Deleter_1.deleteSafe)(this.pointSeries);
+    };
+    /**
+     *  @inheritDoc
+     */
+    FastErrorBarsRenderableSeries.prototype.getDataPointWidth = function (coordCalc, widthFraction) {
+        var isVerticalDirection = this.errorDirection === ErrorDirection_1.EErrorDirection.Vertical;
+        var values = isVerticalDirection ? this.dataSeries.getNativeXValues() : this.dataSeries.getNativeYValues();
+        var seriesViewRectWidth = coordCalc.viewportDimension;
+        var isCategoryAxis = coordCalc.isCategoryCoordinateCalculator;
+        return (0, BaseRenderableSeries_1.getDataPointWidth)(values, coordCalc, seriesViewRectWidth, widthFraction, isCategoryAxis, this.webAssemblyContext);
+    };
+    /**
+     * @inheritDoc
+     */
+    FastErrorBarsRenderableSeries.prototype.getXRange = function () {
+        var _a;
+        var isVerticalDirection = this.errorDirection === ErrorDirection_1.EErrorDirection.Vertical;
+        var hasHighCap = this.errorMode !== ErrorMode_1.EErrorMode.Low;
+        var hasLowCap = this.errorMode !== ErrorMode_1.EErrorMode.High;
+        var range = this.dataSeries.getXRange(IDataSeries_1.EDataSeriesValueType.Default, !isVerticalDirection, hasHighCap, hasLowCap);
+        if (this.xAxis.type === AxisType_1.EAxisType.LogarithmicAxis)
+            return range;
+        else
+            return isVerticalDirection
+                ? this.adjustRangeByDataPointWidth(range)
+                : (0, exports.adjustRangeByStrokeThickness)(range, this.strokeThickness, (_a = this.parentSurface.seriesViewRect) === null || _a === void 0 ? void 0 : _a.width);
+    };
+    /** @inheritDoc */
+    FastErrorBarsRenderableSeries.prototype.getYRange = function (xVisibleRange, isXCategoryAxis) {
+        var _a;
+        if (isXCategoryAxis === void 0) { isXCategoryAxis = false; }
+        var isHorizontalDirection = this.errorDirection === ErrorDirection_1.EErrorDirection.Horizontal;
+        var hasHighCap = this.errorMode !== ErrorMode_1.EErrorMode.Low;
+        var hasLowCap = this.errorMode !== ErrorMode_1.EErrorMode.High;
+        var dataSeriesValueType = this.isRunningDataAnimation
+            ? IDataSeries_1.EDataSeriesValueType.FinalAnimationValues
+            : IDataSeries_1.EDataSeriesValueType.Default;
+        var range = this.dataSeries.getWindowedYRange(xVisibleRange, true, isXCategoryAxis, dataSeriesValueType, isHorizontalDirection, hasHighCap, hasLowCap);
+        // Not sure how to adjust this sensibly without having the dataPointWidth in pixels.  Not sure if we can reliably get a valid coordCacluator
+        if (this.yAxis.type === AxisType_1.EAxisType.LogarithmicAxis)
+            return range;
+        else
+            return isHorizontalDirection
+                ? this.adjustRangeByDataPointWidth(range)
+                : (0, exports.adjustRangeByStrokeThickness)(range, this.strokeThickness, (_a = this.parentSurface.seriesViewRect) === null || _a === void 0 ? void 0 : _a.height);
+    };
+    /** @inheritDoc */
+    FastErrorBarsRenderableSeries.prototype.toJSON = function (excludeData) {
+        if (excludeData === void 0) { excludeData = false; }
+        var json = _super.prototype.toJSON.call(this, excludeData);
+        var options = {
+            dataPointWidth: this.dataPointWidth,
+            dataPointWidthMode: this.dataPointWidthMode,
+            errorDirection: this.errorDirection,
+            errorMode: this.errorMode,
+            drawWhiskers: this.drawWhiskers,
+            drawConnector: this.drawConnector,
+            strokeDashArray: this.strokeDashArray
+        };
+        Object.assign(json.options, options);
+        return json;
+    };
+    /** @inheritDoc */
+    FastErrorBarsRenderableSeries.prototype.toPointSeries = function (rp) {
+        if (rp) {
+            throw new Error("Error Bars Series don't support resampling!");
+        }
+        else {
+            return new HlcPointSeriesWrapped_1.HlcPointSeriesWrapped(this.dataSeries);
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    FastErrorBarsRenderableSeries.prototype.newHitTestProvider = function () {
+        return new ErrorSeriesHitTestProvider_1.ErrorSeriesHitTestProvider(this, this.webAssemblyContext);
+    };
+    FastErrorBarsRenderableSeries.prototype.adjustRangeByDataPointWidth = function (range) {
+        var _a, _b, _c, _d;
+        var count = this.dataSeries.count();
+        if (count > 1) {
+            var areaSize = this.errorDirection === ErrorDirection_1.EErrorDirection.Vertical
+                ? (_b = (_a = this.parentSurface.seriesViewRect) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0
+                : (_d = (_c = this.parentSurface.seriesViewRect) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0;
+            var additionalValue = this.dataPointWidthMode === DataPointWidthMode_1.EDataPointWidthMode.Relative
+                ? ((range.diff / (count - 1)) * this.dataPointWidth) / 2
+                : areaSize &&
+                    (0, BaseRenderableSeries_1.getDelta)({
+                        range: range,
+                        areaSize: areaSize,
+                        pointSize: this.dataPointWidth
+                    });
+            return new NumberRange_1.NumberRange(range.min - additionalValue, range.max + additionalValue);
+        }
+        // TODO: figure out what to do if we have only one point
+        return range;
+    };
+    return FastErrorBarsRenderableSeries;
+}(BaseRenderableSeries_1.BaseRenderableSeries));
+exports.FastErrorBarsRenderableSeries = FastErrorBarsRenderableSeries;
+/** @ignore */
+var adjustRangeByStrokeThickness = function (range, strokeThickness, areaSize) {
+    if (areaSize === void 0) { areaSize = 0; }
+    var delta = areaSize && (0, BaseRenderableSeries_1.getDelta)({ pointSize: strokeThickness, areaSize: areaSize, range: range });
+    return new NumberRange_1.NumberRange(range.min - delta, range.max + delta);
+};
+exports.adjustRangeByStrokeThickness = adjustRangeByStrokeThickness;

package/Charting/Visuals/RenderableSeries/FastImpulseRenderableSeries.js

@@ -20,7 +20,7 @@ var NumberRange_1 = require("../../../Core/NumberRange");
 var SeriesType_1 = require("../../../types/SeriesType");
 var EllipsePointMarker_1 = require("../PointMarkers/EllipsePointMarker");
 var SciChartSurfaceBase_1 = require("../SciChartSurfaceBase");
-var DpiHelper_1 = require("../TextureManager/DpiHelper");
+var BaseRenderableSeries_1 = require("./BaseRenderableSeries");
 var constants_1 = require("./constants");
 var FastColumnRenderableSeries_1 = require("./FastColumnRenderableSeries");
 var ImpulseSeriesHitTestProvider_1 = require("./HitTest/ImpulseSeriesHitTestProvider");
@@ -120,7 +120,7 @@ var FastImpulseRenderableSeries = /** @class */ (function (_super) {
      */
     FastImpulseRenderableSeries.prototype.getXRange = function () {
         var range = _super.prototype.getXRange.call(this);
-        var delta = getDelta({
+        var delta = (0, BaseRenderableSeries_1.getDelta)({
             pointSize: this.size,
             areaSize: this.parentSurface.seriesViewRect.width,
             range: range
@@ -136,7 +136,7 @@ var FastImpulseRenderableSeries = /** @class */ (function (_super) {
         if (!yRange) {
             return undefined;
         }
-        var delta = getDelta({
+        var delta = (0, BaseRenderableSeries_1.getDelta)({
             pointSize: this.size,
             areaSize: this.parentSurface.seriesViewRect.height,
             range: yRange
@@ -170,10 +170,3 @@ var FastImpulseRenderableSeries = /** @class */ (function (_super) {
     return FastImpulseRenderableSeries;
 }(FastColumnRenderableSeries_1.FastColumnRenderableSeries));
 exports.FastImpulseRenderableSeries = FastImpulseRenderableSeries;
-/** @ignore */
-var getDelta = function (_a) {
-    var pointSize = _a.pointSize, areaSize = _a.areaSize, range = _a.range;
-    var pointScaled = pointSize * DpiHelper_1.DpiHelper.PIXEL_RATIO;
-    var k = areaSize / (areaSize - pointScaled);
-    return (Math.abs(range.max - range.min) * (k - 1)) / 2;
-};

package/Charting/Visuals/RenderableSeries/HitTest/ErrorSeriesHitTestProvider.d.ts

@@ -0,0 +1,20 @@
+import { FastErrorBarsRenderableSeries } from "../FastErrorBarsRenderableSeries";
+import { BaseHitTestProvider } from "./BaseHitTestProvider";
+import { HitTestInfo } from "./HitTestInfo";
+/**
+ * Hit-test provider for {@link FastColumnRenderableSeries}. See base class {@link BaseHitTestProvider} for further info
+ */
+export declare class ErrorSeriesHitTestProvider extends BaseHitTestProvider<FastErrorBarsRenderableSeries> {
+    /**
+     * @inheritDoc
+     */
+    hitTest(x: number, y: number): HitTestInfo;
+    /**
+     * @inheritDoc
+     */
+    hitTestForDataPointSelectionModifier(x: number, y: number, hitTestRadius?: number): HitTestInfo;
+    /**
+     * @inheritDoc
+     */
+    hitTestXSlice(x: number, y: number): HitTestInfo;
+}

package/Charting/Visuals/RenderableSeries/HitTest/ErrorSeriesHitTestProvider.js

@@ -0,0 +1,120 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorSeriesHitTestProvider = void 0;
+var ErrorDirection_1 = require("../../../../types/ErrorDirection");
+var ErrorMode_1 = require("../../../../types/ErrorMode");
+var pointUtil_1 = require("../../../../utils/pointUtil");
+var BaseHitTestProvider_1 = require("./BaseHitTestProvider");
+var hitTestHelpers_1 = require("./hitTestHelpers");
+var HitTestInfo_1 = require("./HitTestInfo");
+/**
+ * Hit-test provider for {@link FastColumnRenderableSeries}. See base class {@link BaseHitTestProvider} for further info
+ */
+var ErrorSeriesHitTestProvider = /** @class */ (function (_super) {
+    __extends(ErrorSeriesHitTestProvider, _super);
+    function ErrorSeriesHitTestProvider() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * @inheritDoc
+     */
+    ErrorSeriesHitTestProvider.prototype.hitTest = function (x, y) {
+        var hitTestPoint = this.getTranslatedHitTestPoint(x, y);
+        if (!hitTestPoint) {
+            return HitTestInfo_1.HitTestInfo.empty();
+        }
+        var _a = this.currentRenderPassData, xCoordinateCalculator = _a.xCoordinateCalculator, yCoordinateCalculator = _a.yCoordinateCalculator, isVerticalChart = _a.isVerticalChart;
+        var xHitCoord = isVerticalChart ? hitTestPoint.y : hitTestPoint.x;
+        var yHitCoord = isVerticalChart ? hitTestPoint.x : hitTestPoint.y;
+        var dataSeries = this.parentSeries.dataSeries;
+        // TODO handle horizontal direction
+        var nearestPointIndex = hitTestHelpers_1.hitTestHelpers.getNearestXPoint(this.webAssemblyContext, xCoordinateCalculator, dataSeries, xHitCoord, dataSeries.dataDistributionCalculator.isSortedAscending);
+        var xNativeValues = dataSeries.getNativeXValues();
+        var yNativeValues = dataSeries.getNativeYValues();
+        var hitTestInfo = hitTestHelpers_1.hitTestHelpers.createHitTestInfo(this.parentSeries, xCoordinateCalculator, yCoordinateCalculator, isVerticalChart, dataSeries, xNativeValues, yNativeValues, xHitCoord, yHitCoord, nearestPointIndex, 0);
+        if (nearestPointIndex >= 0) {
+            var res = hitTestHelpers_1.hitTestHelpers.testIsHitForErrorBars(xCoordinateCalculator, yCoordinateCalculator, this.parentSeries, xNativeValues, yNativeValues, nearestPointIndex, xHitCoord, yHitCoord);
+            hitTestInfo.isHit = res.isHit;
+            hitTestInfo.highValue = res.highValue;
+            hitTestInfo.lowValue = res.lowValue;
+        }
+        else {
+            hitTestInfo.isHit = false;
+        }
+        return hitTestInfo;
+    };
+    /**
+     * @inheritDoc
+     */
+    ErrorSeriesHitTestProvider.prototype.hitTestForDataPointSelectionModifier = function (x, y, hitTestRadius) {
+        if (hitTestRadius === void 0) { hitTestRadius = BaseHitTestProvider_1.BaseHitTestProvider.DEFAULT_HIT_TEST_RADIUS; }
+        return this.hitTest(x, y);
+    };
+    /**
+     * @inheritDoc
+     */
+    ErrorSeriesHitTestProvider.prototype.hitTestXSlice = function (x, y) {
+        var hitTestPoint = this.getTranslatedHitTestPoint(x, y);
+        if (!hitTestPoint) {
+            return HitTestInfo_1.HitTestInfo.empty();
+        }
+        var _a = this.currentRenderPassData, xCoordinateCalculator = _a.xCoordinateCalculator, yCoordinateCalculator = _a.yCoordinateCalculator, isVerticalChart = _a.isVerticalChart;
+        var xHitCoord = isVerticalChart ? hitTestPoint.y : hitTestPoint.x;
+        var yHitCoord = isVerticalChart ? hitTestPoint.x : hitTestPoint.y;
+        var dataSeries = this.parentSeries.dataSeries;
+        var xNativeValues = dataSeries.getNativeXValues();
+        var yNativeValues = dataSeries.getNativeYValues();
+        var lowNativeValues = dataSeries.getNativeLowValues();
+        var highNativeValues = dataSeries.getNativeHighValues();
+        var nearestPointIndex = hitTestHelpers_1.hitTestHelpers.getNearestXPoint(this.webAssemblyContext, xCoordinateCalculator, dataSeries, xHitCoord, dataSeries.dataDistributionCalculator.isSortedAscending);
+        var hitTestInfo = hitTestHelpers_1.hitTestHelpers.createHitTestInfo(this.parentSeries, xCoordinateCalculator, yCoordinateCalculator, isVerticalChart, dataSeries, xNativeValues, yNativeValues, xHitCoord, yHitCoord, nearestPointIndex, 0);
+        var isCategoryAxis = xCoordinateCalculator.isCategoryCoordinateCalculator;
+        if (nearestPointIndex >= 0) {
+            var isVerticalDirection = this.parentSeries.errorDirection === ErrorDirection_1.EErrorDirection.Vertical;
+            hitTestInfo.highValue = highNativeValues.get(nearestPointIndex);
+            hitTestInfo.lowValue = lowNativeValues.get(nearestPointIndex);
+            var hasLowCap = this.parentSeries.errorMode !== ErrorMode_1.EErrorMode.High;
+            var hasHighCap = this.parentSeries.errorMode !== ErrorMode_1.EErrorMode.Low;
+            var xFirstValue = void 0;
+            var xLastValue = void 0;
+            if (isVerticalDirection) {
+                xFirstValue = isCategoryAxis ? 0 : xNativeValues.get(0);
+                xLastValue = isCategoryAxis ? xNativeValues.size() - 1 : xNativeValues.get(xNativeValues.size() - 1);
+            }
+            else {
+                xFirstValue = hasLowCap ? lowNativeValues.get(0) : xNativeValues.get(0);
+                xLastValue = hasHighCap
+                    ? highNativeValues.get(xNativeValues.size() - 1)
+                    : xNativeValues.get(xNativeValues.size() - 1);
+            }
+            var dataPointWidthPx = this.parentSeries.getDataPointWidth(isVerticalDirection ? xCoordinateCalculator : yCoordinateCalculator, this.parentSeries.dataPointWidth);
+            var halfRange = dataPointWidthPx / 2;
+            var xCoord = xCoordinateCalculator.getCoordinate(hitTestInfo.hitTestPointValues.x);
+            var xFirstCoord = xCoordinateCalculator.getCoordinate(xFirstValue);
+            var xLastCoord = xCoordinateCalculator.getCoordinate(xLastValue);
+            hitTestInfo.isWithinDataBounds = (0, pointUtil_1.testIsInInterval)(xCoord, xFirstCoord - halfRange, xLastCoord + halfRange);
+            hitTestInfo.isHit = hitTestInfo.isWithinDataBounds;
+        }
+        else {
+            hitTestInfo.isHit = false;
+        }
+        return hitTestInfo;
+    };
+    return ErrorSeriesHitTestProvider;
+}(BaseHitTestProvider_1.BaseHitTestProvider));
+exports.ErrorSeriesHitTestProvider = ErrorSeriesHitTestProvider;

package/Charting/Visuals/RenderableSeries/HitTest/hitTestHelpers.d.ts

@@ -8,6 +8,7 @@ import { XyyDataSeries } from "../../../Model/XyyDataSeries";
 import { CoordinateCalculatorBase } from "../../../Numerics/CoordinateCalculators/CoordinateCalculatorBase";
 import { BaseOhlcRenderableSeries } from "../BaseOhlcRenderableSeries";
 import { FastColumnRenderableSeries } from "../FastColumnRenderableSeries";
+import { FastErrorBarsRenderableSeries } from "../FastErrorBarsRenderableSeries";
 import { FastImpulseRenderableSeries } from "../FastImpulseRenderableSeries";
 import { IRenderableSeries } from "../IRenderableSeries";
 import { HitTestInfo } from "./HitTestInfo";
@@ -42,5 +43,10 @@ export declare const hitTestHelpers: {
         isHit: boolean;
         secondPointIndex: number;
     };
+    testIsHitForErrorBars: (xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, renderableSeries: FastErrorBarsRenderableSeries, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, pointIndex: number, xHitCoord: number, yHitCoord: number) => {
+        isHit: boolean;
+        highValue: number;
+        lowValue: number;
+    };
     testIsHitForImpulse: (xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, renderableSeries: FastImpulseRenderableSeries, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, pointIndex: number, xHitCoord: number, yHitCoord: number, hitTestRadius: number) => boolean;
 };

package/Charting/Visuals/RenderableSeries/HitTest/hitTestHelpers.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hitTestHelpers = void 0;
 var Point_1 = require("../../../../Core/Point");
+var ErrorDirection_1 = require("../../../../types/ErrorDirection");
 var pointUtil_1 = require("../../../../utils/pointUtil");
 var HitTestInfo_1 = require("./HitTestInfo");
 var interpolateLinear = function (x, x1, y1, x2, y2) {
@@ -79,6 +80,7 @@ var getNearestXPoint = function (webAssemblyContext, xCoordinateCalculator, data
     if (isSorted) {
         return webAssemblyContext.NumberUtil.FindIndex(xValues, xHitValue, webAssemblyContext.SCRTFindIndexSearchMode.Nearest, isSorted);
     }
+    // TODO check if could be refactored
     var dataLength = dataSeries.count();
     var nearestPointIndex = -1;
     var currentDistance = Number.MAX_VALUE;
@@ -268,6 +270,39 @@ var testIsHitForColumn = function (xCoordinateCalculator, yCoordinateCalculator,
     var bottomColumnSide = zeroLineYCoord > yCoord ? yCoord : zeroLineYCoord;
     return (0, pointUtil_1.testIsInBounds)(xHitCoord, yHitCoord, xCoord - halfWidth, topColumnSide, xCoord + halfWidth, bottomColumnSide);
 };
+var testIsHitForErrorBars = function (xCoordinateCalculator, yCoordinateCalculator, renderableSeries, xValues, yValues, pointIndex, xHitCoord, yHitCoord) {
+    var getDataPointWidth = renderableSeries.getDataPointWidth, dataPointWidth = renderableSeries.dataPointWidth, errorDirection = renderableSeries.errorDirection;
+    var isCategoryAxis = xCoordinateCalculator.isCategoryCoordinateCalculator;
+    var isVerticalDirection = errorDirection === ErrorDirection_1.EErrorDirection.Vertical;
+    var xValue = isCategoryAxis ? pointIndex : xValues.get(pointIndex);
+    var yValue = yValues.get(pointIndex);
+    var highValue = renderableSeries.dataSeries.getNativeHighValues().get(pointIndex);
+    var lowValue = renderableSeries.dataSeries.getNativeLowValues().get(pointIndex);
+    if (isNaN(highValue))
+        highValue = yValue;
+    if (isNaN(lowValue))
+        lowValue = yValue;
+    var xCoord = xCoordinateCalculator.getCoordinate(xValue);
+    var yCoord = yCoordinateCalculator.getCoordinate(yValue);
+    var highCoord = isVerticalDirection
+        ? yCoordinateCalculator.getCoordinate(highValue)
+        : xCoordinateCalculator.getCoordinate(highValue);
+    var lowCoord = isVerticalDirection
+        ? yCoordinateCalculator.getCoordinate(lowValue)
+        : xCoordinateCalculator.getCoordinate(lowValue);
+    var columnWidth = getDataPointWidth(isVerticalDirection ? xCoordinateCalculator : yCoordinateCalculator, dataPointWidth);
+    var halfWidth = columnWidth / 2;
+    var isHit = false;
+    var upperErrorBoundary = highCoord > lowCoord ? highCoord : lowCoord;
+    var lowerErrorBoundary = highCoord > lowCoord ? lowCoord : highCoord;
+    if (isVerticalDirection) {
+        isHit = (0, pointUtil_1.testIsInBounds)(xHitCoord, yHitCoord, xCoord - halfWidth, upperErrorBoundary, xCoord + halfWidth, lowerErrorBoundary);
+    }
+    else {
+        isHit = (0, pointUtil_1.testIsInBounds)(xHitCoord, yHitCoord, lowerErrorBoundary, yCoord + halfWidth, upperErrorBoundary, yCoord - halfWidth);
+    }
+    return { isHit: isHit, highValue: highValue, lowValue: lowValue };
+};
 var testIsHitForImpulse = function (xCoordinateCalculator, yCoordinateCalculator, renderableSeries, xValues, yValues, pointIndex, xHitCoord, yHitCoord, hitTestRadius) {
     var zeroLineY = renderableSeries.zeroLineY;
     var isCategoryAxis = xCoordinateCalculator.isCategoryCoordinateCalculator;
@@ -357,5 +392,6 @@ exports.hitTestHelpers = {
     testIsHitForColumn: testIsHitForColumn,
     testIsHitForOHLC: testIsHitForOHLC,
     testIsHitForMountain: testIsHitForMountain,
+    testIsHitForErrorBars: testIsHitForErrorBars,
     testIsHitForImpulse: testIsHitForImpulse
 };

package/Charting/Visuals/RenderableSeries/IBaseRenderableSeriesOptions.d.ts

@@ -7,6 +7,10 @@ import { IPointMarker } from "../PointMarkers/IPointMarker";
 import { SeriesAnimation } from "./Animations/SeriesAnimation";
 import { IRenderableSeries } from "./IRenderableSeries";
 import { ShaderEffect } from "./ShaderEffect";
+/**
+ * The type of the {@link IBaseRenderableSeriesOptions.onIsVisibleChanged } callback
+ */
+export declare type TSeriesVisibleChangedCallback = (sourceSeries: IRenderableSeries, isVisible: boolean) => void;
 /**
  * The type of the {@link IBaseRenderableSeriesOptions.onSelectedChanged } callback
  */
@@ -149,6 +153,10 @@ export interface IBaseRenderableSeriesOptions {
      * Initial hovered state for the series. Default to false
      */
     isHovered?: boolean;
+    /**
+     * Optional callback function when isVisible changed. Also see {@link IRenderableSeries.isVisibleChanged} event handler
+     */
+    onIsVisibleChanged?: TSeriesVisibleChangedCallback | string;
     /**
      * Optional callback function when selected changed. Also see {@link IRenderableSeries.selected} event handler
      */

package/Charting/Visuals/RenderableSeries/IRenderableSeries.d.ts

@@ -26,6 +26,7 @@ import { IHitTestProvider } from "./HitTest/IHitTestProvider";
 import { RolloverModifierRenderableSeriesProps } from "./RolloverModifier/RolloverModifierRenderableSeriesProps";
 import { SeriesHoveredArgs } from "./SeriesHoveredArgs";
 import { SeriesSelectedArgs } from "./SeriesSelectedArgs";
+import { SeriesVisibleChangedArgs } from "./SeriesVisibleChangedArgs";
 /**
  * @summary Defines the interface to a Render Series (or Chart Type) in SciChart's High Performance Real-time
  * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
@@ -222,6 +223,11 @@ export interface IRenderableSeries extends IDeletable, IThemeable, INotifyOnDpiC
      * @remarks See {@link EventHandler} for how to subscribe
      */
     readonly hovered: EventHandler<SeriesHoveredArgs>;
+    /**
+     * An isVisible changed EventHandler. This event fires whenever the {@link IRenderableSeries | Series} isVisible changes.
+     * @remarks See {@link EventHandler} for how to subscribe
+     */
+    readonly isVisibleChanged: EventHandler<SeriesVisibleChangedArgs>;
     /**
      * gets if the animation is currently running
      */