scichart 2.2.2416 → 3.0.0-beta.224

package/Charting/Visuals/RenderableSeries/FastImpulseRenderableSeries.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastImpulseRenderableSeries = void 0;
 var NumberRange_1 = require("../../../Core/NumberRange");
 var SeriesType_1 = require("../../../types/SeriesType");
+var IThemeProvider_1 = require("../../Themes/IThemeProvider");
 var EllipsePointMarker_1 = require("../PointMarkers/EllipsePointMarker");
 var SciChartSurfaceBase_1 = require("../SciChartSurfaceBase");
 var BaseRenderableSeries_1 = require("./BaseRenderableSeries");
@@ -54,8 +55,9 @@ var FastImpulseRenderableSeries = /** @class */ (function (_super) {
      * @param options optional parameters of type {@link IImpulseRenderableSeries} applied when constructing the series type
      */
     function FastImpulseRenderableSeries(webAssemblyContext, options) {
+        var _this = this;
         var _a, _b, _c, _d;
-        var _this = _super.call(this, webAssemblyContext, options) || this;
+        _this = _super.call(this, webAssemblyContext, options) || this;
         /** @inheritDoc */
         _this.type = SeriesType_1.ESeriesType.ImpulseSeries;
         _this.impulseFillProperty = SciChartSurfaceBase_1.SciChartSurfaceBase.DEFAULT_THEME.impulseFillBrush;
@@ -82,7 +84,7 @@ var FastImpulseRenderableSeries = /** @class */ (function (_super) {
          * Gets or sets the color of each impulse
          */
         get: function () {
-            return this.impulseFillProperty;
+            return (0, IThemeProvider_1.stripAutoColor)(this.impulseFillProperty);
         },
         set: function (htmlColorCode) {
             this.impulseFillProperty = htmlColorCode;
@@ -119,10 +121,11 @@ var FastImpulseRenderableSeries = /** @class */ (function (_super) {
      * @inheritDoc
      */
     FastImpulseRenderableSeries.prototype.getXRange = function () {
+        var _a, _b;
         var range = _super.prototype.getXRange.call(this);
         var delta = (0, BaseRenderableSeries_1.getDelta)({
             pointSize: this.size,
-            areaSize: this.parentSurface.seriesViewRect.width,
+            areaSize: (_b = (_a = this.parentSurface.seriesViewRect) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0,
             range: range
         });
         return new NumberRange_1.NumberRange(range.min - delta, range.max + delta);
@@ -131,6 +134,7 @@ var FastImpulseRenderableSeries = /** @class */ (function (_super) {
      * @inheritDoc
      */
     FastImpulseRenderableSeries.prototype.getYRange = function (xVisibleRange, isXCategoryAxis) {
+        var _a, _b;
         if (isXCategoryAxis === void 0) { isXCategoryAxis = false; }
         var yRange = _super.prototype.getYRange.call(this, xVisibleRange, isXCategoryAxis);
         if (!yRange) {
@@ -138,7 +142,7 @@ var FastImpulseRenderableSeries = /** @class */ (function (_super) {
         }
         var delta = (0, BaseRenderableSeries_1.getDelta)({
             pointSize: this.size,
-            areaSize: this.parentSurface.seriesViewRect.height,
+            areaSize: (_b = (_a = this.parentSurface.seriesViewRect) === null || _a === void 0 ? void 0 : _a.height) !== null && _b !== void 0 ? _b : 0,
             range: yRange
         });
         return new NumberRange_1.NumberRange(yRange.min - delta, yRange.max + delta);
@@ -164,6 +168,14 @@ var FastImpulseRenderableSeries = /** @class */ (function (_super) {
         }
     };
     /** @inheritDoc */
+    FastImpulseRenderableSeries.prototype.resolveAutoColors = function (index, maxSeries, theme) {
+        _super.prototype.resolveAutoColors.call(this, index, maxSeries, theme);
+        if (this.impulseFillProperty.startsWith(IThemeProvider_1.AUTO_COLOR)) {
+            var color = theme.getStrokeColor(index, maxSeries, this.webAssemblyContext);
+            this.fill = IThemeProvider_1.AUTO_COLOR + this.adjustAutoColor("impulseFill", color);
+        }
+    };
+    /** @inheritDoc */
     FastImpulseRenderableSeries.prototype.newHitTestProvider = function () {
         return new ImpulseSeriesHitTestProvider_1.ImpulseSeriesHitTestProvider(this, this.webAssemblyContext);
     };

package/Charting/Visuals/RenderableSeries/FastLineRenderableSeries.js

@@ -49,8 +49,9 @@ var FastLineRenderableSeries = /** @class */ (function (_super) {
      * @param options optional parameters of type {@link IFastLineRenderableSeriesOptions} applied when constructing the series type
      */
     function FastLineRenderableSeries(webAssemblyContext, options) {
+        var _this = this;
         var _a, _b;
-        var _this = _super.call(this, webAssemblyContext, options) || this;
+        _this = _super.call(this, webAssemblyContext, options) || this;
         _this.type = SeriesType_1.ESeriesType.LineSeries;
         // Must be called here for the series type to be available
         if ((_a = _this.paletteProvider) === null || _a === void 0 ? void 0 : _a.onAttached) {

package/Charting/Visuals/RenderableSeries/FastMountainRenderableSeries.js

@@ -48,8 +48,9 @@ var FastMountainRenderableSeries = /** @class */ (function (_super) {
      * @param options optional parameters of type {@link IMountainRenderableSeriesOptions} applied when constructing the series type
      */
     function FastMountainRenderableSeries(webAssemblyContext, options) {
+        var _this = this;
         var _a, _b;
-        var _this = _super.call(this, webAssemblyContext, options) || this;
+        _this = _super.call(this, webAssemblyContext, options) || this;
         _this.type = SeriesType_1.ESeriesType.MountainSeries;
         // Must be called here for the series type to be available
         if ((_a = _this.paletteProvider) === null || _a === void 0 ? void 0 : _a.onAttached) {

package/Charting/Visuals/RenderableSeries/FastOhlcRenderableSeries.js

@@ -48,8 +48,9 @@ var FastOhlcRenderableSeries = /** @class */ (function (_super) {
      * @param options optional parameters of type {@link IOhlcRenderableSeriesOptions} applied when constructing the series type
      */
     function FastOhlcRenderableSeries(webAssemblyContext, options) {
+        var _this = this;
         var _a, _b;
-        var _this = _super.call(this, webAssemblyContext, options) || this;
+        _this = _super.call(this, webAssemblyContext, options) || this;
         _this.type = SeriesType_1.ESeriesType.OhlcSeries;
         // Must be called here for the series type to be available
         if ((_a = _this.paletteProvider) === null || _a === void 0 ? void 0 : _a.onAttached) {

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

@@ -0,0 +1,17 @@
+import { ESeriesType } from "../../../types/SeriesType";
+import { TSciChart } from "../../../types/TSciChart";
+import { BaseRenderableSeries } from "./BaseRenderableSeries";
+import { ITextDataLabelProviderOptions } from "./DataLabels/TextDataLabelProvider";
+import { IHitTestProvider } from "./HitTest/IHitTestProvider";
+import { IBaseRenderableSeriesOptions } from "./IBaseRenderableSeriesOptions";
+export interface ITextRenderableSeriesOptions extends IBaseRenderableSeriesOptions {
+    /**
+     * Options to pass to the DataLabelProvider. Set a style with font and size to enable per-point text for this series.
+     */
+    dataLabels?: ITextDataLabelProviderOptions;
+}
+export declare class FastTextRenderableSeries extends BaseRenderableSeries {
+    type: ESeriesType;
+    constructor(webAssemblyContext: TSciChart, options?: ITextRenderableSeriesOptions);
+    protected newHitTestProvider(): IHitTestProvider;
+}

package/Charting/Visuals/RenderableSeries/FastTextRenderableSeries.js

@@ -0,0 +1,45 @@
+"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.FastTextRenderableSeries = void 0;
+var SeriesType_1 = require("../../../types/SeriesType");
+var BaseRenderableSeries_1 = require("./BaseRenderableSeries");
+var TextDataLabelProvider_1 = require("./DataLabels/TextDataLabelProvider");
+var PointMarkerDrawingProvider_1 = require("./DrawingProviders/PointMarkerDrawingProvider");
+var TextSeriesHitTestProvider_1 = require("./HitTest/TextSeriesHitTestProvider");
+var FastTextRenderableSeries = /** @class */ (function (_super) {
+    __extends(FastTextRenderableSeries, _super);
+    function FastTextRenderableSeries(webAssemblyContext, options) {
+        var _this = _super.call(this, webAssemblyContext, options) || this;
+        _this.type = SeriesType_1.ESeriesType.TextSeries;
+        _this.drawingProviders = [];
+        _this.drawingProviders.push(new PointMarkerDrawingProvider_1.PointMarkerDrawingProvider(webAssemblyContext, _this));
+        if (!_this.dataLabelProviderProperty) {
+            _this.dataLabelProviderProperty = new TextDataLabelProvider_1.TextDataLabelProvider(options === null || options === void 0 ? void 0 : options.dataLabels);
+            _this.dataLabelProviderProperty.onAttach(_this.webAssemblyContext, _this);
+        }
+        if (options === null || options === void 0 ? void 0 : options.animation) {
+            _this.animationQueue.push(options.animation);
+        }
+        return _this;
+    }
+    FastTextRenderableSeries.prototype.newHitTestProvider = function () {
+        return new TextSeriesHitTestProvider_1.TextSeriesHitTestProvider(this, this.webAssemblyContext);
+    };
+    return FastTextRenderableSeries;
+}(BaseRenderableSeries_1.BaseRenderableSeries));
+exports.FastTextRenderableSeries = FastTextRenderableSeries;

package/Charting/Visuals/RenderableSeries/HeatmapColorMap.js

@@ -6,8 +6,9 @@ var PropertyChangedEventArgs_1 = require("../../../Core/PropertyChangedEventArgs
 var constants_1 = require("./constants");
 var HeatmapColorMap = /** @class */ (function () {
     function HeatmapColorMap(options) {
-        this.minimumProperty = (options === null || options === void 0 ? void 0 : options.minimum) || 0;
-        this.maximumProperty = (options === null || options === void 0 ? void 0 : options.maximum) || 100;
+        var _a, _b;
+        this.minimumProperty = (_a = options === null || options === void 0 ? void 0 : options.minimum) !== null && _a !== void 0 ? _a : 0;
+        this.maximumProperty = (_b = options === null || options === void 0 ? void 0 : options.maximum) !== null && _b !== void 0 ? _b : 100;
         this.gradientStops = (options === null || options === void 0 ? void 0 : options.gradientStops) || [
             { offset: 0, color: "Red" },
             { offset: 1, color: "Green" }

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

@@ -45,13 +45,22 @@ var BandSeriesHitTestProvider = /** @class */ (function (_super) {
         var nearestPointIndex = hitTestHelpers_1.hitTestHelpers.getNearestXPoint(this.webAssemblyContext, xCoordinateCalculator, dataSeries, xHitCoord, dataSeries.dataDistributionCalculator.isSortedAscending);
         var xNativeValues = dataSeries.getNativeXValues();
         var yNativeValues = dataSeries.getNativeYValues();
+        var y1NativeValues = dataSeries.getNativeY1Values();
         var hitTestInfo = hitTestHelpers_1.hitTestHelpers.createHitTestInfo(this.parentSeries, xCoordinateCalculator, yCoordinateCalculator, isVerticalChart, dataSeries, xNativeValues, yNativeValues, xHitCoord, yHitCoord, nearestPointIndex, 0);
-        if (nearestPointIndex >= 0) {
-            hitTestInfo.y1Value = dataSeries.getNativeY1Values().get(nearestPointIndex);
+        if (dataSeries.dataDistributionCalculator.isSortedAscending && nearestPointIndex >= 0) {
+            hitTestInfo.y1Value = y1NativeValues.get(nearestPointIndex);
             hitTestInfo.y1Coord = yCoordinateCalculator.getCoordinate(hitTestInfo.y1Value);
-            var hitRes = hitTestHelpers_1.hitTestHelpers.testIsHitForBand(this.parentSeries.isDigitalLine, xCoordinateCalculator, yCoordinateCalculator, dataSeries.getNativeXValues(), function (index) { return dataSeries.getNativeYValues().get(index); }, function (index) { return dataSeries.getNativeY1Values().get(index); }, nearestPointIndex, xHitCoord, yHitCoord);
+            var hitRes = hitTestHelpers_1.hitTestHelpers.testIsHitForBand(this.parentSeries.isDigitalLine, xCoordinateCalculator, yCoordinateCalculator, dataSeries.getNativeXValues(), function (index) { return yNativeValues.get(index); }, function (index) { return y1NativeValues.get(index); }, nearestPointIndex, xHitCoord, yHitCoord);
             hitTestInfo.isHit = hitRes.isHit;
             hitTestInfo.point2dataSeriesIndex = hitRes.secondPointIndex;
+            if (hitRes.secondPointIndex !== undefined) {
+                hitTestInfo.point2xValue = xNativeValues.get(hitRes.secondPointIndex);
+                hitTestInfo.point2xCoord = xCoordinateCalculator.getCoordinate(hitTestInfo.point2xValue);
+                hitTestInfo.point2yValue = yNativeValues.get(hitRes.secondPointIndex);
+                hitTestInfo.point2yCoord = yCoordinateCalculator.getCoordinate(hitTestInfo.point2yValue);
+                hitTestInfo.point2y1Value = y1NativeValues.get(hitRes.secondPointIndex);
+                hitTestInfo.point2y1Coord = yCoordinateCalculator.getCoordinate(hitTestInfo.point2y1Value);
+            }
         }
         else {
             hitTestInfo.isHit = false;
@@ -104,15 +113,36 @@ var BandSeriesHitTestProvider = /** @class */ (function (_super) {
             return HitTestInfo_1.HitTestInfo.empty();
         }
         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, dataSeries.getNativeXValues(), dataSeries.getNativeYValues(), xHitCoord, yHitCoord, nearestPointIndex, 0);
+        var xNativeValues = dataSeries.getNativeXValues();
+        var yNativeValues = dataSeries.getNativeYValues();
+        var y1NativeValues = dataSeries.getNativeY1Values();
+        var hitTestInfo = hitTestHelpers_1.hitTestHelpers.createHitTestInfo(this.parentSeries, xCoordinateCalculator, yCoordinateCalculator, isVerticalChart, dataSeries, xNativeValues, yNativeValues, xHitCoord, yHitCoord, nearestPointIndex, 0);
         if (nearestPointIndex >= 0) {
             hitTestInfo.isHit = hitTestInfo.isWithinDataBounds;
-            hitTestInfo.y1Value = dataSeries.getNativeY1Values().get(nearestPointIndex);
+            hitTestInfo.y1Value = y1NativeValues.get(nearestPointIndex);
             hitTestInfo.y1Coord = yCoordinateCalculator.getCoordinate(hitTestInfo.y1Value);
         }
         else {
             hitTestInfo.isHit = false;
         }
+        if (dataSeries.dataDistributionCalculator.isSortedAscending && nearestPointIndex >= 0) {
+            var dataSeriesCount = xNativeValues.size();
+            var xValue = xNativeValues.get(nearestPointIndex);
+            var xHitValue = xCoordinateCalculator.getDataValue(xHitCoord);
+            if (!(nearestPointIndex === dataSeriesCount - 1 && xHitValue >= xValue) &&
+                !(nearestPointIndex === 0 && xHitValue <= xValue)) {
+                var hitRes = hitTestHelpers_1.hitTestHelpers.testIsHitForLine(xCoordinateCalculator, yCoordinateCalculator, xNativeValues, yNativeValues, nearestPointIndex, xHitCoord, yHitCoord, 0);
+                hitTestInfo.point2dataSeriesIndex = hitRes.secondPointIndex;
+                if (hitRes.secondPointIndex !== undefined) {
+                    hitTestInfo.point2xValue = xNativeValues.get(hitRes.secondPointIndex);
+                    hitTestInfo.point2xCoord = xCoordinateCalculator.getCoordinate(hitTestInfo.point2xValue);
+                    hitTestInfo.point2yValue = yNativeValues.get(hitRes.secondPointIndex);
+                    hitTestInfo.point2yCoord = yCoordinateCalculator.getCoordinate(hitTestInfo.point2yValue);
+                    hitTestInfo.point2y1Value = y1NativeValues.get(hitRes.secondPointIndex);
+                    hitTestInfo.point2y1Coord = yCoordinateCalculator.getCoordinate(hitTestInfo.point2y1Value);
+                }
+            }
+        }
         return hitTestInfo;
     };
     return BandSeriesHitTestProvider;

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

@@ -78,8 +78,24 @@ var BaseHitTestProvider = /** @class */ (function () {
             return HitTestInfo_1.HitTestInfo.empty();
         }
         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, dataSeries.getNativeXValues(), dataSeries.getNativeYValues(), xHitCoord, yHitCoord, nearestPointIndex, 0);
+        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);
         hitTestInfo.isHit = hitTestInfo.isWithinDataBounds;
+        if (dataSeries.dataDistributionCalculator.isSortedAscending && nearestPointIndex >= 0) {
+            var dataSeriesCount = xNativeValues.size();
+            var xValue = xNativeValues.get(nearestPointIndex);
+            var xHitValue = xCoordinateCalculator.getDataValue(xHitCoord);
+            if (!(nearestPointIndex === dataSeriesCount - 1 && xHitValue >= xValue) &&
+                !(nearestPointIndex === 0 && xHitValue <= xValue)) {
+                var hitRes = hitTestHelpers_1.hitTestHelpers.testIsHitForLine(xCoordinateCalculator, yCoordinateCalculator, xNativeValues, yNativeValues, nearestPointIndex, xHitCoord, yHitCoord, 0);
+                hitTestInfo.point2dataSeriesIndex = hitRes.secondPointIndex;
+                hitTestInfo.point2xValue = xNativeValues.get(hitRes.secondPointIndex);
+                hitTestInfo.point2xCoord = xCoordinateCalculator.getCoordinate(hitTestInfo.point2xValue);
+                hitTestInfo.point2yValue = yNativeValues.get(hitRes.secondPointIndex);
+                hitTestInfo.point2yCoord = yCoordinateCalculator.getCoordinate(hitTestInfo.point2yValue);
+            }
+        }
         return hitTestInfo;
     };
     BaseHitTestProvider.prototype.getTranslatedHitTestPoint = function (x, y) {

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

@@ -62,6 +62,10 @@ export declare class HitTestInfo {
      * The Y1-coordinate result of the hit-test operation
      */
     y1Coord: number;
+    /**
+     * The Y1-coordinate result of the hit-test operation for the second data point, X-coordinate for vertical chart
+     */
+    point2y1Coord: number;
     /**
      * The X-value result of the hit-test operation
      */
@@ -86,6 +90,10 @@ export declare class HitTestInfo {
      * XYY Series only: the Y1-value result of the hit-test operation
      */
     y1Value: number;
+    /**
+     * The Y1-value result of the hit-test operation for the second data point
+     */
+    point2y1Value: number;
     /**
      * XYZ Series only: the Z-value result of the hit-test operation
      */

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

@@ -47,10 +47,16 @@ var MountainSeriesHitTestProvider = /** @class */ (function (_super) {
         var xNativeValues = dataSeries.getNativeXValues();
         var yNativeValues = dataSeries.getNativeYValues();
         var hitTestInfo = hitTestHelpers_1.hitTestHelpers.createHitTestInfo(renderableSeries, xCoordinateCalculator, yCoordinateCalculator, isVerticalChart, dataSeries, xNativeValues, yNativeValues, xHitCoord, yHitCoord, nearestPointIndex, 0);
-        if (nearestPointIndex >= 0) {
+        if (dataSeries.dataDistributionCalculator.isSortedAscending && nearestPointIndex >= 0) {
             var res = hitTestHelpers_1.hitTestHelpers.testIsHitForMountain(this.parentSeries.isDigitalLine, xCoordinateCalculator, yCoordinateCalculator, dataSeries, renderableSeries.zeroLineY, nearestPointIndex, xHitCoord, yHitCoord);
             hitTestInfo.isHit = res.isHit;
             hitTestInfo.point2dataSeriesIndex = res.secondPointIndex;
+            if (res.secondPointIndex !== undefined) {
+                hitTestInfo.point2xValue = xNativeValues.get(res.secondPointIndex);
+                hitTestInfo.point2xCoord = xCoordinateCalculator.getCoordinate(hitTestInfo.point2xValue);
+                hitTestInfo.point2yValue = yNativeValues.get(res.secondPointIndex);
+                hitTestInfo.point2yCoord = yCoordinateCalculator.getCoordinate(hitTestInfo.point2yValue);
+            }
         }
         else {
             hitTestInfo.isHit = false;

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

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

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

@@ -0,0 +1,86 @@
+"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.NonUniformHeatmapHitTestProvider = void 0;
+var Point_1 = require("../../../../Core/Point");
+var BaseHitTestProvider_1 = require("./BaseHitTestProvider");
+var hitTestHelpers_1 = require("./hitTestHelpers");
+var HitTestInfo_1 = require("./HitTestInfo");
+/**
+ * Hit-test provider for {@link UniformHeatmapRenderableSeries}. See base class {@link BaseHitTestProvider} for further info
+ */
+var NonUniformHeatmapHitTestProvider = /** @class */ (function (_super) {
+    __extends(NonUniformHeatmapHitTestProvider, _super);
+    function NonUniformHeatmapHitTestProvider() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * @inheritDoc
+     */
+    NonUniformHeatmapHitTestProvider.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;
+        if (!dataSeries) {
+            return HitTestInfo_1.HitTestInfo.empty();
+        }
+        var heatmapPoint = hitTestHelpers_1.hitTestHelpers.getNearestNonUniformHeatmapPoint(xCoordinateCalculator, yCoordinateCalculator, dataSeries, xHitCoord, yHitCoord);
+        var xIndex = heatmapPoint.xIndex, yIndex = heatmapPoint.yIndex, zValue = heatmapPoint.zValue;
+        var hitTestInfo = new HitTestInfo_1.HitTestInfo(this.parentSeries);
+        hitTestInfo.dataSeriesName = this.parentSeries.type;
+        hitTestInfo.dataSeriesType = dataSeries.type;
+        hitTestInfo.hitTestPoint = new Point_1.Point(xHitCoord, yHitCoord);
+        var hitTestPointXValue = xCoordinateCalculator.getDataValue(xHitCoord);
+        var hitTestPointYValue = yCoordinateCalculator.getDataValue(yHitCoord);
+        hitTestInfo.hitTestPointValues = new Point_1.Point(hitTestPointXValue, hitTestPointYValue);
+        hitTestInfo.xValue = hitTestPointXValue;
+        hitTestInfo.yValue = hitTestPointYValue;
+        hitTestInfo.heatmapXIndex = xIndex;
+        hitTestInfo.heatmapYIndex = yIndex;
+        hitTestInfo.zValue = zValue;
+        // TODO: set correct heatmapValue
+        hitTestInfo.heatmapValue = zValue;
+        // TODO maybe calculate coordinates of the cell center?
+        hitTestInfo.xCoord = xHitCoord;
+        hitTestInfo.yCoord = yHitCoord;
+        hitTestInfo.isHit = xIndex !== -1 && yIndex !== -1;
+        hitTestInfo.isWithinDataBounds = hitTestInfo.isHit;
+        if (xIndex !== -1 && yIndex !== -1) {
+            hitTestInfo.metadata = dataSeries.getMetadataAt(yIndex, xIndex);
+        }
+        return hitTestInfo;
+    };
+    /**
+     * @inheritDoc
+     */
+    NonUniformHeatmapHitTestProvider.prototype.hitTestDataPoint = function (x, y) {
+        throw Error("hitTestDataPoint method is not supported for NonUniformHeatmapHitTestProvider");
+    };
+    /**
+     * @inheritDoc
+     */
+    NonUniformHeatmapHitTestProvider.prototype.hitTestXSlice = function (x, y) {
+        return this.hitTest(x, y);
+    };
+    return NonUniformHeatmapHitTestProvider;
+}(BaseHitTestProvider_1.BaseHitTestProvider));
+exports.NonUniformHeatmapHitTestProvider = NonUniformHeatmapHitTestProvider;

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

@@ -0,0 +1,6 @@
+import { BaseRenderableSeries } from "../BaseRenderableSeries";
+import { BaseHitTestProvider } from "./BaseHitTestProvider";
+import { HitTestInfo } from "./HitTestInfo";
+export declare class TextSeriesHitTestProvider extends BaseHitTestProvider<BaseRenderableSeries> {
+    hitTest(x: number, y: number, hitTestRadius?: number): HitTestInfo;
+}

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

@@ -0,0 +1,56 @@
+"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.TextSeriesHitTestProvider = void 0;
+var pointUtil_1 = require("../../../../utils/pointUtil");
+var BaseHitTestProvider_1 = require("./BaseHitTestProvider");
+var hitTestHelpers_1 = require("./hitTestHelpers");
+var HitTestInfo_1 = require("./HitTestInfo");
+var TextSeriesHitTestProvider = /** @class */ (function (_super) {
+    __extends(TextSeriesHitTestProvider, _super);
+    function TextSeriesHitTestProvider() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TextSeriesHitTestProvider.prototype.hitTest = function (x, y, hitTestRadius) {
+        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 nearestPointIndex = hitTestHelpers_1.hitTestHelpers.getNearestXyPoint(xCoordinateCalculator, yCoordinateCalculator, dataSeries, xHitCoord, yHitCoord);
+        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, hitTestRadius);
+        var labels = this.parentSeries.dataLabelProvider.dataLabels;
+        var isHit = false;
+        for (var _i = 0, labels_1 = labels; _i < labels_1.length; _i++) {
+            var label = labels_1[_i];
+            var _b = label.rect, left = _b.left, top_1 = _b.top, right = _b.right, bottom = _b.bottom;
+            if ((0, pointUtil_1.testIsInBounds)(hitTestPoint.x, hitTestPoint.y, left, top_1, right, bottom)) {
+                isHit = true;
+                break;
+            }
+        }
+        hitTestInfo.isHit = isHit;
+        return hitTestInfo;
+    };
+    return TextSeriesHitTestProvider;
+}(BaseHitTestProvider_1.BaseHitTestProvider));
+exports.TextSeriesHitTestProvider = TextSeriesHitTestProvider;

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

@@ -43,7 +43,7 @@ var UniformHeatmapHitTestProvider = /** @class */ (function (_super) {
         if (!dataSeries) {
             return HitTestInfo_1.HitTestInfo.empty();
         }
-        var heatmapPoint = hitTestHelpers_1.hitTestHelpers.getNearestHeatmapPoint(xCoordinateCalculator, yCoordinateCalculator, dataSeries, xHitCoord, yHitCoord);
+        var heatmapPoint = hitTestHelpers_1.hitTestHelpers.getNearestUniformHeatmapPoint(xCoordinateCalculator, yCoordinateCalculator, dataSeries, xHitCoord, yHitCoord);
         var xIndex = heatmapPoint.xIndex, yIndex = heatmapPoint.yIndex, zValue = heatmapPoint.zValue;
         var hitTestInfo = new HitTestInfo_1.HitTestInfo(this.parentSeries);
         hitTestInfo.dataSeriesName = this.parentSeries.type;

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

@@ -1,6 +1,7 @@
 import { SCRTDoubleVector, TSciChart } from "../../../../types/TSciChart";
 import { BaseDataSeries } from "../../../Model/BaseDataSeries";
 import { IDataSeries } from "../../../Model/IDataSeries";
+import { NonUniformHeatmapDataSeries } from "../../../Model/NonUniformHeatmapDataSeries";
 import { OhlcDataSeries } from "../../../Model/OhlcDataSeries";
 import { UniformHeatmapDataSeries } from "../../../Model/UniformHeatmapDataSeries";
 import { XyDataSeries } from "../../../Model/XyDataSeries";
@@ -17,7 +18,12 @@ export declare const hitTestHelpers: {
     getNearestXPoint: (webAssemblyContext: TSciChart, xCoordinateCalculator: CoordinateCalculatorBase, dataSeries: IDataSeries, xHitCoord: number, isSorted: boolean) => number;
     getNearestXyPoint: (xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, dataSeries: IDataSeries, xHitCoord: number, yHitCoord: number) => number;
     getNearestXyyPoint: (xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, dataSeries: XyyDataSeries, xHitCoord: number, yHitCoord: number) => number;
-    getNearestHeatmapPoint: (xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, heatmapDataSeries: UniformHeatmapDataSeries, xHitCoord: number, yHitCoord: number) => {
+    getNearestUniformHeatmapPoint: (xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, heatmapDataSeries: UniformHeatmapDataSeries, xHitCoord: number, yHitCoord: number) => {
+        xIndex: number;
+        yIndex: number;
+        zValue: number;
+    };
+    getNearestNonUniformHeatmapPoint: (xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, heatmapDataSeries: NonUniformHeatmapDataSeries, xHitCoord: number, yHitCoord: number) => {
         xIndex: number;
         yIndex: number;
         zValue: number;

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

@@ -139,7 +139,7 @@ var getNearestXyyPoint = function (xCoordinateCalculator, yCoordinateCalculator,
     }
     return nearestPointIndex;
 };
-var getNearestHeatmapPoint = function (xCoordinateCalculator, yCoordinateCalculator, heatmapDataSeries, xHitCoord, yHitCoord) {
+var getNearestUniformHeatmapPoint = function (xCoordinateCalculator, yCoordinateCalculator, heatmapDataSeries, xHitCoord, yHitCoord) {
     var xHitValue = xCoordinateCalculator.getDataValue(xHitCoord);
     var yHitValue = yCoordinateCalculator.getDataValue(yHitCoord);
     var xIndex = Math.floor((xHitValue - heatmapDataSeries.xStart) / heatmapDataSeries.xStep);
@@ -150,6 +150,37 @@ var getNearestHeatmapPoint = function (xCoordinateCalculator, yCoordinateCalcula
     var zValue = heatmapDataSeries.getZValue(yIndex, xIndex);
     return { xIndex: xIndex, yIndex: yIndex, zValue: zValue };
 };
+var getNearestNonUniformHeatmapPoint = function (xCoordinateCalculator, yCoordinateCalculator, heatmapDataSeries, xHitCoord, yHitCoord) {
+    var xHitValue = xCoordinateCalculator.getDataValue(xHitCoord);
+    var yHitValue = yCoordinateCalculator.getDataValue(yHitCoord);
+    var xCellOffsets = heatmapDataSeries.xCellOffsets, yCellOffsets = heatmapDataSeries.yCellOffsets;
+    var xIndex = -1;
+    if (xHitValue >= xCellOffsets[0] && xHitValue <= xCellOffsets[xCellOffsets.length - 1]) {
+        for (var i = 0; i < xCellOffsets.length; i++) {
+            var isWithinCellOffsets = xHitValue >= xCellOffsets[i] && xHitValue <= xCellOffsets[i + 1];
+            if (isWithinCellOffsets) {
+                xIndex = i;
+                break;
+            }
+        }
+    }
+    var yIndex = -1;
+    if (yHitValue >= yCellOffsets[0] && yHitValue <= yCellOffsets[yCellOffsets.length - 1]) {
+        for (var i = 0; i < yCellOffsets.length - 1; i++) {
+            var isWithinCellOffsets = yHitValue >= yCellOffsets[i] && yHitValue <= yCellOffsets[i + 1];
+            if (isWithinCellOffsets) {
+                yIndex = i;
+                break;
+            }
+        }
+    }
+    // TODO shouldn't we return a neerest cell anyway?
+    if (xIndex < 0 || xIndex >= heatmapDataSeries.arrayWidth || yIndex < 0 || yIndex >= heatmapDataSeries.arrayHeight) {
+        return { xIndex: -1, yIndex: -1, zValue: undefined };
+    }
+    var zValue = heatmapDataSeries.getZValue(yIndex, xIndex);
+    return { xIndex: xIndex, yIndex: yIndex, zValue: zValue };
+};
 var testIsHitForPoint = function (xCoordinateCalculator, yCoordinateCalculator, xValues, yValues, pointIndex, xHitCoord, yHitCoord, hitTestRadius) {
     var isCategoryAxis = xCoordinateCalculator.isCategoryCoordinateCalculator;
     var xValue = isCategoryAxis ? pointIndex : xValues.get(pointIndex);
@@ -385,7 +416,8 @@ exports.hitTestHelpers = {
     getNearestXPoint: getNearestXPoint,
     getNearestXyPoint: getNearestXyPoint,
     getNearestXyyPoint: getNearestXyyPoint,
-    getNearestHeatmapPoint: getNearestHeatmapPoint,
+    getNearestUniformHeatmapPoint: getNearestUniformHeatmapPoint,
+    getNearestNonUniformHeatmapPoint: getNearestNonUniformHeatmapPoint,
     testIsHitForPoint: testIsHitForPoint,
     testIsHitForLine: testIsHitForLine,
     testIsHitForBand: testIsHitForBand,

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

@@ -1,4 +1,4 @@
-import { TAnimationDefinition, TEffectDefinition, TPaletteProviderDefinition, TPointMarkerDefinition } from "../../../Builder/buildSeries";
+import { TAnimationDefinition, TDataLabelProviderDefinition, TEffectDefinition, TPaletteProviderDefinition, TPointMarkerDefinition } from "../../../Builder/buildSeries";
 import { ELineDrawMode } from "../../Drawing/WebGlRenderContext2D";
 import { IDataSeries } from "../../Model/IDataSeries";
 import { IPaletteProvider } from "../../Model/IPaletteProvider";
@@ -7,6 +7,7 @@ import { IPointMarker } from "../PointMarkers/IPointMarker";
 import { SeriesAnimation } from "./Animations/SeriesAnimation";
 import { IRenderableSeries } from "./IRenderableSeries";
 import { ShaderEffect } from "./ShaderEffect";
+import { BaseDataLabelProvider } from "./DataLabels/BaseDataLabelProvider";
 /**
  * The type of the {@link IBaseRenderableSeriesOptions.onIsVisibleChanged } callback
  */
@@ -175,4 +176,8 @@ export interface IBaseRenderableSeriesOptions {
      * Gets or sets the resampling precision for this series
      */
     resamplingPrecision?: number;
+    /**
+     * A {@link SeriesTextProvider} used for creating and drawing per-point text.
+     */
+    dataLabelProvider?: BaseDataLabelProvider | TDataLabelProviderDefinition;
 }