scichart 2.2.2417 → 3.0.0-beta.230

package/Charting/Visuals/RenderableSeries/DataLabels/HeatMapDataLabelProvider.js

@@ -0,0 +1,198 @@
+"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.HeatMapDataLabelProvider = void 0;
+var Point_1 = require("../../../../Core/Point");
+var Rect_1 = require("../../../../Core/Rect");
+var DataLabelProviderType_1 = require("../../../../types/DataLabelProviderType");
+var NumericFormat_1 = require("../../../../types/NumericFormat");
+var Size_1 = require("../../../../types/Size");
+var number_1 = require("../../../../utils/number");
+var parseColor_1 = require("../../../../utils/parseColor");
+var NativeObject_1 = require("../../Helpers/NativeObject");
+var DpiHelper_1 = require("../../TextureManager/DpiHelper");
+var BaseDataLabelProvider_1 = require("./BaseDataLabelProvider");
+var HeatMapDataLabelProvider = /** @class */ (function (_super) {
+    __extends(HeatMapDataLabelProvider, _super);
+    function HeatMapDataLabelProvider(options) {
+        var _this = this;
+        var _a, _b;
+        _this = _super.call(this, options) || this;
+        _this.type = DataLabelProviderType_1.EDataLabelProviderType.Heatmap;
+        _this.numericFormatProperty = NumericFormat_1.ENumericFormat.Decimal;
+        _this.precisionProperty = 1;
+        _this.numericFormatProperty = (_a = options === null || options === void 0 ? void 0 : options.numericFormat) !== null && _a !== void 0 ? _a : _this.numericFormatProperty;
+        _this.precision = (_b = options === null || options === void 0 ? void 0 : options.precision) !== null && _b !== void 0 ? _b : _this.precisionProperty;
+        _this.metaDataSelector = options === null || options === void 0 ? void 0 : options.metaDataSelector;
+        return _this;
+    }
+    Object.defineProperty(HeatMapDataLabelProvider.prototype, "numericFormat", {
+        /**
+         * Gets or sets numeric format to use when formatting values to text. For a list of values, see {@link ENumericFormat}
+         * For more control, override getText
+         */
+        get: function () {
+            return this.numericFormatProperty;
+        },
+        set: function (value) {
+            var _a;
+            this.numericFormatProperty = value;
+            (_a = this.parentSeries) === null || _a === void 0 ? void 0 : _a.invalidateParentCallback();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HeatMapDataLabelProvider.prototype, "precision", {
+        /**
+         * Gets or sets the precision to use when formatting values to text
+         * For more control, override getText
+         */
+        get: function () {
+            return this.precisionProperty;
+        },
+        set: function (value) {
+            var _a;
+            this.precisionProperty = value;
+            (_a = this.parentSeries) === null || _a === void 0 ? void 0 : _a.invalidateParentCallback();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HeatMapDataLabelProvider.prototype.getText = function (xIndex, yIndex) {
+        var _a, _b;
+        if (this.metaDataSelector) {
+            return this.metaDataSelector(this.dataSeries.getMetadataAt(yIndex, xIndex));
+        }
+        var z = this.zValues[yIndex][xIndex];
+        if (z === z) {
+            // Fast isNaN check
+            return (0, number_1.formatNumber)(z, (_a = this.numericFormat) !== null && _a !== void 0 ? _a : NumericFormat_1.ENumericFormat.Decimal, (_b = this.precision) !== null && _b !== void 0 ? _b : 1);
+        }
+        else {
+            return undefined;
+        }
+    };
+    HeatMapDataLabelProvider.prototype.getPosition = function (xIndex, yIndex, xVal, yVal, textSize, cellWidth, cellHeight, renderPassData) {
+        var x = renderPassData.xCoordinateCalculator.getCoordinate(xVal);
+        var y = renderPassData.yCoordinateCalculator.getCoordinate(yVal);
+        if (renderPassData.isVerticalChart) {
+            var c = x;
+            x = y;
+            y = c;
+        }
+        if (renderPassData.xCoordinateCalculator.hasFlippedCoordinates) {
+            x += (cellWidth - textSize.width) / 2;
+        }
+        else {
+            x -= cellWidth - (cellWidth - textSize.width) / 2;
+        }
+        if (renderPassData.yCoordinateCalculator.hasFlippedCoordinates) {
+            y += cellHeight - (cellHeight - textSize.height) / 2;
+        }
+        else {
+            y -= (cellHeight - textSize.height) / 2;
+        }
+        return new Point_1.Point(x, y);
+    };
+    HeatMapDataLabelProvider.prototype.shouldGenerate = function (textSize, cellWidth, cellHeight) {
+        return textSize.height < cellHeight && textSize.width < cellWidth;
+    };
+    HeatMapDataLabelProvider.prototype.getColor = function (xIndex, yIndex, text) {
+        return this.colorValue;
+    };
+    HeatMapDataLabelProvider.prototype.shouldSkipLabel = function (xIndex, yIndex, label, cellWidth, cellHeight) {
+        // Skip if out of bounds
+        var svr = this.parentSeries.parentSurface.seriesViewRect;
+        // const yMax = state.renderPassData.isVerticalChart ? svr.width : svr.height;
+        if (label.rect.y < 0 || label.rect.bottom > svr.height)
+            return true;
+        // const xMax = state.renderPassData.isVerticalChart ? svr.height : svr.width;
+        if (label.rect.x < 0 || label.rect.right > svr.width)
+            return true;
+        return false;
+    };
+    HeatMapDataLabelProvider.prototype.generateDataLabels = function (renderContext, renderPassData) {
+        var _a;
+        var _b, _c;
+        // clear any previous labels
+        this.dataLabels = [];
+        if (!this.style || !this.style.fontFamily || !this.style.fontSize) {
+            return;
+        }
+        this.dataSeries = this.parentSeries.dataSeries;
+        this.zValues = this.dataSeries.getZValues();
+        // this.state = new DataLabelState(renderContext, renderPassData, this.style, yValues, this.parentSeries);
+        var bounds = (0, NativeObject_1.getTextBounds)(this.webAssemblyContext);
+        var dpiAdjustedStyle = DpiHelper_1.DpiHelper.adjustTextStyle(this.style);
+        var font = renderContext.getFont(dpiAdjustedStyle);
+        var cellWidth = Math.abs(renderPassData.xCoordinateCalculator.getCoordinate(this.dataSeries.getXValue(1)) -
+            renderPassData.xCoordinateCalculator.getCoordinate(this.dataSeries.getXValue(0)));
+        var cellHeight = Math.abs(renderPassData.yCoordinateCalculator.getCoordinate(this.dataSeries.getYValue(1)) -
+            renderPassData.yCoordinateCalculator.getCoordinate(this.dataSeries.getYValue(0)));
+        font.CalculateStringBounds((_b = this.getText(0, 0)) !== null && _b !== void 0 ? _b : "", bounds, (_c = this.style.lineSpacing) !== null && _c !== void 0 ? _c : 2);
+        if (renderPassData.isVerticalChart) {
+            _a = [cellWidth, cellHeight], cellHeight = _a[0], cellWidth = _a[1];
+        }
+        if (!this.shouldGenerate(new Size_1.Size(bounds.m_fWidth, bounds.m_fHeight), cellWidth, cellHeight))
+            return;
+        this.colorValue = (0, parseColor_1.parseColorToUIntArgb)(this.color);
+        var _d = this.parentSeries.dataSeries, xStart = _d.xStart, xStep = _d.xStep, yStart = _d.yStart, yStep = _d.yStep;
+        for (var yIndex = 0; yIndex < this.dataSeries.arrayHeight; yIndex++) {
+            var y = yStart + yStep * yIndex;
+            if (renderPassData.yCoordinateCalculator.visibleMin > y + yStep ||
+                renderPassData.yCoordinateCalculator.visibleMax < y)
+                continue;
+            for (var xIndex = 0; xIndex < this.dataSeries.arrayWidth; xIndex++) {
+                var x = xStart + xStep * xIndex;
+                if (renderPassData.xCoordinateCalculator.visibleMin > x + xStep ||
+                    renderPassData.xCoordinateCalculator.visibleMax < x)
+                    continue;
+                var text = this.getText(xIndex, yIndex);
+                if (!text) {
+                    continue;
+                }
+                font.CalculateStringBounds(text !== null && text !== void 0 ? text : "", bounds, 2);
+                var textSize = new Size_1.Size(bounds.m_fWidth, bounds.m_fHeight);
+                var xVal = this.dataSeries.getXValue(xIndex);
+                var yVal = this.dataSeries.getYValue(yIndex);
+                var position = this.getPosition(xIndex, yIndex, xVal, yVal, textSize, cellWidth, cellHeight, renderPassData);
+                var label = {
+                    text: text,
+                    position: position,
+                    rect: new Rect_1.Rect(position.x, position.y - bounds.GetLineBounds(0).m_fHeight, textSize.width, textSize.height),
+                    color: this.getColor(xIndex, yIndex, text),
+                    dataX: this.dataSeries.getXValue(xIndex),
+                    dataY: this.dataSeries.getYValue(yIndex)
+                };
+                if (!this.shouldSkipLabel(xIndex, yIndex, label, cellWidth, cellHeight)) {
+                    this.dataLabels.push(label);
+                }
+            }
+        }
+    };
+    HeatMapDataLabelProvider.prototype.toJSON = function () {
+        var json = _super.prototype.toJSON.call(this);
+        var options = {
+            numericFormat: this.numericFormat,
+            precision: this.precision
+        };
+        Object.assign(json.options, options);
+        return json;
+    };
+    return HeatMapDataLabelProvider;
+}(BaseDataLabelProvider_1.BaseDataLabelProvider));
+exports.HeatMapDataLabelProvider = HeatMapDataLabelProvider;

package/Charting/Visuals/RenderableSeries/DataLabels/LineSeriesDataLabelProvider.d.ts

@@ -0,0 +1,35 @@
+import { Point } from "../../../../Core/Point";
+import { EDataLabelProviderType } from "../../../../types/DataLabelProviderType";
+import { TSRTextBounds } from "../../../../types/TSciChart";
+import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
+import { RenderPassData } from "../../../Services/RenderPassData";
+import { DataLabelProvider, IDataLabelProviderOptions } from "./DataLabelProvider";
+import { DataLabelState } from "./DataLabelState";
+export interface ILineSeriesDataLabelProviderOptions extends IDataLabelProviderOptions {
+    /**
+     * Sets whether text should be positioned above the line if it is going down, and below the line if it going up.
+     * Default true.  When true this overrides horizontalAnchorPoint and verticalAnchorPoint to be left, bottom.
+     */
+    aboveBelow?: boolean;
+}
+export declare class LineSeriesDataLabelProvider extends DataLabelProvider {
+    readonly type: EDataLabelProviderType;
+    private yAdj;
+    private aboveBelowProperty;
+    constructor(options?: ILineSeriesDataLabelProviderOptions);
+    /**
+     * Gets or Sets whether text should be positioned above the line if it is going down, and below the line if it going up.
+     * Default true.  When true this overrides horizontalAnchorPoint and verticalAnchorPoint to be left, bottom.
+     */
+    get aboveBelow(): boolean;
+    set aboveBelow(value: boolean);
+    generateDataLabels(renderContext: WebGlRenderContext2D, renderPassData: RenderPassData): void;
+    getPosition(state: DataLabelState, textBounds: TSRTextBounds): Point;
+    toJSON(): {
+        type: EDataLabelProviderType;
+        options: {
+            style: import("../../../../types/TDataLabelStyle").TDataLabelStyle;
+            color: string;
+        };
+    };
+}

package/Charting/Visuals/RenderableSeries/DataLabels/LineSeriesDataLabelProvider.js

@@ -0,0 +1,92 @@
+"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.LineSeriesDataLabelProvider = void 0;
+var Point_1 = require("../../../../Core/Point");
+var DataLabelProviderType_1 = require("../../../../types/DataLabelProviderType");
+var DataLabelProvider_1 = require("./DataLabelProvider");
+var LineSeriesDataLabelProvider = /** @class */ (function (_super) {
+    __extends(LineSeriesDataLabelProvider, _super);
+    function LineSeriesDataLabelProvider(options) {
+        var _this = this;
+        var _a;
+        _this = _super.call(this, options) || this;
+        _this.type = DataLabelProviderType_1.EDataLabelProviderType.Line;
+        _this.aboveBelowProperty = true;
+        _this.aboveBelowProperty = (_a = options === null || options === void 0 ? void 0 : options.aboveBelow) !== null && _a !== void 0 ? _a : _this.aboveBelow;
+        return _this;
+    }
+    Object.defineProperty(LineSeriesDataLabelProvider.prototype, "aboveBelow", {
+        /**
+         * Gets or Sets whether text should be positioned above the line if it is going down, and below the line if it going up.
+         * Default true.  When true this overrides horizontalAnchorPoint and verticalAnchorPoint to be left, bottom.
+         */
+        get: function () {
+            return this.aboveBelowProperty;
+        },
+        set: function (value) {
+            this.aboveBelowProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LineSeriesDataLabelProvider.prototype.generateDataLabels = function (renderContext, renderPassData) {
+        var parent = this.parentSeries;
+        this.yAdj = Math.ceil(parent.strokeThickness / 2);
+        if (parent.pointMarker) {
+            this.yAdj = Math.max(this.yAdj, Math.ceil(parent.pointMarker.height / 2));
+        }
+        _super.prototype.generateDataLabels.call(this, renderContext, renderPassData);
+    };
+    LineSeriesDataLabelProvider.prototype.getPosition = function (state, textBounds) {
+        var _a, _b, _c, _d, _e, _f;
+        if (this.aboveBelow) {
+            var x = state.xCoord() + ((_b = (_a = this.style.padding) === null || _a === void 0 ? void 0 : _a.left) !== null && _b !== void 0 ? _b : 0);
+            // Handle multiline
+            var yOffset = textBounds.m_fHeight - textBounds.GetLineBounds(0).m_fHeight;
+            var y = state.yCoord() - yOffset;
+            if (state.hasNext()) {
+                var nextY = state.yCoord(state.index + 1);
+                var nextX = state.xCoord(state.index + 1);
+                // Text anchor point is bottom left
+                if ((nextX > x && nextY > y) || (nextX < x && nextY < y)) {
+                    // going down - draw above
+                    y -= this.yAdj + ((_d = (_c = state.style.padding) === null || _c === void 0 ? void 0 : _c.bottom) !== null && _d !== void 0 ? _d : 1);
+                }
+                else {
+                    // going up - draw below
+                    y += textBounds.m_fHeight + this.yAdj + ((_f = (_e = state.style.padding) === null || _e === void 0 ? void 0 : _e.top) !== null && _f !== void 0 ? _f : 1);
+                }
+            }
+            return new Point_1.Point(x, y);
+        }
+        else {
+            return _super.prototype.getPosition.call(this, state, textBounds);
+        }
+    };
+    LineSeriesDataLabelProvider.prototype.toJSON = function () {
+        var json = _super.prototype.toJSON.call(this);
+        var options = {
+            aboveBelow: this.aboveBelow
+        };
+        Object.assign(json.options, options);
+        return json;
+    };
+    return LineSeriesDataLabelProvider;
+}(DataLabelProvider_1.DataLabelProvider));
+exports.LineSeriesDataLabelProvider = LineSeriesDataLabelProvider;

package/Charting/Visuals/RenderableSeries/DataLabels/NonUniformHeatmapDataLabelProvider.d.ts

@@ -0,0 +1,12 @@
+import { Point } from "../../../../Core/Point";
+import { EDataLabelProviderType } from "../../../../types/DataLabelProviderType";
+import { Size } from "../../../../types/Size";
+import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
+import { RenderPassData } from "../../../Services/RenderPassData";
+import { HeatMapDataLabelProvider } from "./HeatMapDataLabelProvider";
+export declare class NonUniformHeatMapDataLabelProvider extends HeatMapDataLabelProvider {
+    readonly type: EDataLabelProviderType;
+    cellSizeThresholdCoefficient: number;
+    getPosition(xIndex: number, yIndex: number, xVal: number, yVal: number, textSize: Size, cellWidth: number, cellHeight: number, renderPassData: RenderPassData): Point;
+    generateDataLabels(renderContext: WebGlRenderContext2D, renderPassData: RenderPassData): void;
+}

package/Charting/Visuals/RenderableSeries/DataLabels/NonUniformHeatmapDataLabelProvider.js

@@ -0,0 +1,134 @@
+"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.NonUniformHeatMapDataLabelProvider = void 0;
+var Point_1 = require("../../../../Core/Point");
+var Rect_1 = require("../../../../Core/Rect");
+var DataLabelProviderType_1 = require("../../../../types/DataLabelProviderType");
+var Size_1 = require("../../../../types/Size");
+var parseColor_1 = require("../../../../utils/parseColor");
+var NativeObject_1 = require("../../Helpers/NativeObject");
+var DpiHelper_1 = require("../../TextureManager/DpiHelper");
+var HeatMapDataLabelProvider_1 = require("./HeatMapDataLabelProvider");
+var NonUniformHeatMapDataLabelProvider = /** @class */ (function (_super) {
+    __extends(NonUniformHeatMapDataLabelProvider, _super);
+    function NonUniformHeatMapDataLabelProvider() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.type = DataLabelProviderType_1.EDataLabelProviderType.NonUniformHeatmap;
+        _this.cellSizeThresholdCoefficient = 1;
+        return _this;
+    }
+    NonUniformHeatMapDataLabelProvider.prototype.getPosition = function (xIndex, yIndex, xVal, yVal, textSize, cellWidth, cellHeight, renderPassData) {
+        var x = renderPassData.xCoordinateCalculator.getCoordinate(xVal);
+        var y = renderPassData.yCoordinateCalculator.getCoordinate(yVal);
+        if (renderPassData.isVerticalChart) {
+            var c = x;
+            x = y;
+            y = c;
+        }
+        if (renderPassData.xCoordinateCalculator.hasFlippedCoordinates) {
+            x += (cellWidth - textSize.width) / 2;
+        }
+        else {
+            x -= cellWidth - (cellWidth - textSize.width) / 2;
+        }
+        if (renderPassData.yCoordinateCalculator.hasFlippedCoordinates) {
+            y += cellHeight - (cellHeight - textSize.height) / 2;
+        }
+        else {
+            y -= (cellHeight - textSize.height) / 2;
+        }
+        return new Point_1.Point(x, y);
+    };
+    NonUniformHeatMapDataLabelProvider.prototype.generateDataLabels = function (renderContext, renderPassData) {
+        var _a, _b;
+        // clear any previous labels
+        this.dataLabels = [];
+        if (!this.style || !this.style.fontFamily || !this.style.fontSize) {
+            return;
+        }
+        this.dataSeries = this.parentSeries.dataSeries;
+        this.zValues = this.dataSeries.getZValues();
+        // this.state = new DataLabelState(renderContext, renderPassData, this.style, yValues, this.parentSeries);
+        var bounds = (0, NativeObject_1.getTextBounds)(this.webAssemblyContext);
+        var dpiAdjustedStyle = DpiHelper_1.DpiHelper.adjustTextStyle(this.style);
+        var font = renderContext.getFont(dpiAdjustedStyle);
+        // NonUniform-specific logic
+        var heatmapWidth = Math.abs(renderPassData.xCoordinateCalculator.getCoordinate(this.dataSeries.getXValue(this.dataSeries.arrayWidth)) -
+            renderPassData.xCoordinateCalculator.getCoordinate(this.dataSeries.getXValue(0)));
+        var heatmapHeight = Math.abs(renderPassData.yCoordinateCalculator.getCoordinate(this.dataSeries.getYValue(this.dataSeries.arrayHeight)) -
+            renderPassData.yCoordinateCalculator.getCoordinate(this.dataSeries.getYValue(0)));
+        var relativeXCellSizes = this.dataSeries.xCellSizes;
+        var relativeYCellSizes = this.dataSeries.yCellSizes;
+        font.CalculateStringBounds((_a = this.getText(0, 0)) !== null && _a !== void 0 ? _a : "", bounds, (_b = this.style.lineSpacing) !== null && _b !== void 0 ? _b : 2);
+        var minCellHeight = bounds.m_fHeight * this.cellSizeThresholdCoefficient;
+        var minCellWidth = bounds.m_fWidth * this.cellSizeThresholdCoefficient;
+        // TODO figure out how it should work for NonUniform
+        // if (!this.shouldGenerate(new Size(bounds.m_fWidth, bounds.m_fHeight), cellWidth, cellHeight)) return;
+        this.colorValue = (0, parseColor_1.parseColorToUIntArgb)(this.color);
+        for (var yIndex = 0; yIndex < this.dataSeries.arrayHeight; yIndex++) {
+            var cellHeight = heatmapHeight * relativeYCellSizes[yIndex];
+            if (cellHeight < minCellHeight) {
+                continue;
+            }
+            var yVal = this.dataSeries.getYValue(yIndex);
+            var yValNext = this.dataSeries.yCellOffsets[yIndex + 1];
+            if (renderPassData.yCoordinateCalculator.visibleMin > yVal ||
+                renderPassData.yCoordinateCalculator.visibleMax < yValNext) {
+                continue;
+            }
+            for (var xIndex = 0; xIndex < this.dataSeries.arrayWidth; xIndex++) {
+                var cellWidth = heatmapWidth * relativeXCellSizes[xIndex];
+                if (cellWidth < minCellWidth) {
+                    continue;
+                }
+                var xVal = this.dataSeries.getXValue(xIndex);
+                var xValNext = this.dataSeries.xCellOffsets[xIndex + 1];
+                console.log(xIndex, xVal, xValNext, renderPassData.xCoordinateCalculator.visibleMax);
+                if (renderPassData.xCoordinateCalculator.visibleMin > xVal ||
+                    renderPassData.xCoordinateCalculator.visibleMax < xValNext) {
+                    continue;
+                }
+                var text = this.getText(xIndex, yIndex);
+                if (!text) {
+                    continue;
+                }
+                font.CalculateStringBounds(text !== null && text !== void 0 ? text : "", bounds, 2);
+                var textSize = new Size_1.Size(bounds.m_fWidth, bounds.m_fHeight);
+                if (renderPassData.isVerticalChart) {
+                    var c = cellHeight;
+                    cellHeight = cellWidth;
+                    cellWidth = c;
+                }
+                var position = this.getPosition(xIndex, yIndex, xVal, yVal, textSize, cellWidth, cellHeight, renderPassData);
+                var label = {
+                    text: text,
+                    position: position,
+                    rect: new Rect_1.Rect(position.x, position.y - bounds.GetLineBounds(0).m_fHeight, textSize.width, textSize.height),
+                    color: this.getColor(xIndex, yIndex, text),
+                    dataX: xVal,
+                    dataY: yVal
+                };
+                if (!this.shouldSkipLabel(xIndex, yIndex, label, cellWidth, cellHeight)) {
+                    this.dataLabels.push(label);
+                }
+            }
+        }
+    };
+    return NonUniformHeatMapDataLabelProvider;
+}(HeatMapDataLabelProvider_1.HeatMapDataLabelProvider));
+exports.NonUniformHeatMapDataLabelProvider = NonUniformHeatMapDataLabelProvider;

package/Charting/Visuals/RenderableSeries/DataLabels/TextDataLabelProvider.d.ts

@@ -0,0 +1,56 @@
+import { Point } from "../../../../Core/Point";
+import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
+import { RenderPassData } from "../../../Services/RenderPassData";
+import { BaseDataLabelProvider, IBaseDataLabelProviderOptions } from "./BaseDataLabelProvider";
+import { EDataLabelProviderType } from "../../../../types/DataLabelProviderType";
+import { DataLabelState } from "./DataLabelState";
+import { EHorizontalTextPosition, EVerticalTextPosition } from "../../../../types/TextPosition";
+import { TSRTextBounds } from "../../../../types/TSciChart";
+import { TDataLabelStyle } from "../../../../types/TDataLabelStyle";
+export interface ITextDataLabelProviderOptions extends IBaseDataLabelProviderOptions {
+    /**
+     * If you want to be able to look at the position and size of labels before they are drawn, set this true
+     * otherwise it is faster to leave it false.
+     */
+    calculateTextBounds?: boolean;
+    /** Sets the horizontal text position for the label */
+    horizontalTextPosition?: EHorizontalTextPosition;
+    /** Sets the vertical text position for the label */
+    verticalTextPosition?: EVerticalTextPosition;
+}
+/**
+ * A DataLabelProvider sepcifically designed to work with {@link FastTextRenderableSeries } or any series that uses an {@link XYTextDataSeries }
+ * Text is taken directly from the textValues on the dataSeries and placed at the x,y coordinates (anchored top, left)
+ */
+export declare class TextDataLabelProvider extends BaseDataLabelProvider {
+    type: EDataLabelProviderType;
+    /**
+     * If your labels are all the same size, or you are not changing the alignment, you can set this false to gain performance
+     */
+    calculateTextBounds: boolean;
+    protected horizontalTextPositionProperty: EHorizontalTextPosition;
+    protected verticalTextPositionProperty: EVerticalTextPosition;
+    constructor(options?: ITextDataLabelProviderOptions);
+    /**
+     * Gets or sets the horizontal text position for the label
+     * For more control, override getPosition
+     */
+    get horizontalTextPosition(): EHorizontalTextPosition;
+    set horizontalTextPosition(value: EHorizontalTextPosition);
+    /**
+     * Gets or sets the vertical text position for the label
+     * For more control, override getPosition
+     */
+    get verticalTextPosition(): EVerticalTextPosition;
+    set verticalTextPosition(value: EVerticalTextPosition);
+    getPosition(state: DataLabelState, textBounds: TSRTextBounds): Point;
+    getColor(state: DataLabelState, text: string): number;
+    generateDataLabels(renderContext: WebGlRenderContext2D, renderPassData: RenderPassData): void;
+    toJSON(): {
+        type: EDataLabelProviderType;
+        options: {
+            style: TDataLabelStyle;
+            color: string;
+        };
+    };
+}