scichart 2.2.2417 → 3.0.0-beta.230

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

@@ -0,0 +1,410 @@
+"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.DataLabelProvider = void 0;
+var Guard_1 = require("../../../../Core/Guard");
+var Point_1 = require("../../../../Core/Point");
+var Rect_1 = require("../../../../Core/Rect");
+var TextPosition_1 = require("../../../../types/TextPosition");
+var DataLabelProviderType_1 = require("../../../../types/DataLabelProviderType");
+var DataLabelSkipMode_1 = require("../../../../types/DataLabelSkipMode");
+var NumericFormat_1 = require("../../../../types/NumericFormat");
+var number_1 = require("../../../../utils/number");
+var NativeObject_1 = require("../../Helpers/NativeObject");
+var BaseDataLabelProvider_1 = require("./BaseDataLabelProvider");
+var DataLabelState_1 = require("./DataLabelState");
+var performanceWarnings_1 = require("../../../../constants/performanceWarnings");
+/**
+ * This is the standard DataLabelProvider which provides a number of options for configuring data labels.
+ * It defines a much richer api than BaseDataLabelProvider and is intended to be used as a base for doing small changes to data label behaviour
+ * generateDataLabels calls the following functions which you can override parts of the behaviour
+ * {@link ySelector} to pick the desired yValues from the pointSeries.
+ * {@link shouldGenerate} to determine if any labels should be generated so you can enable labels depending on zoom or data level.
+ * Then for each data point:
+ *  {@link getText} Build in behaviour can get text from metadata using {@link metaDataSelector} or format the y values using {@link numericFormat} and {@link precision}
+ *  {@link getPosition} By default return the x and y coordinate of the data point.  Series-specific DataLabelProviders eg {@link LineSeriesDataLabelProvider} have logic to adjust text position based on the series
+ *  {@link getColor} Returns the color from the text style. Use {@link parseColorToUIntArgb} to turn color string to the required numeric value if overriding.
+ *  {@link shouldSkipLabel} Decides whether to keep or ship the generated label based on the {@link }
+ */
+var DataLabelProvider = /** @class */ (function (_super) {
+    __extends(DataLabelProvider, _super);
+    /**
+     * Creates an instance of the {@link DataLabelProvider}
+     */
+    function DataLabelProvider(options) {
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        _this = _super.call(this, options) || this;
+        _this.type = DataLabelProviderType_1.EDataLabelProviderType.Default;
+        /**
+         * The text to draw, along with the sizes and positions.  Usually generated, but can be set or updated before final drawing
+         */
+        _this.dataLabels = [];
+        /**
+         * Whether the label text should update when the label position is animating. Default false.
+         */
+        _this.updateTextInAnimation = false;
+        _this.pointGapThresholdProperty = 0;
+        _this.pointCountThresholdProperty = Infinity;
+        _this.numericFormatProperty = NumericFormat_1.ENumericFormat.Decimal;
+        _this.precisionProperty = 1;
+        _this.skipModeProperty = DataLabelSkipMode_1.EDataLabelSkipMode.SkipIfOverlapPrevious;
+        _this.skipNumberProperty = 0;
+        _this.horizontalTextPositionProperty = TextPosition_1.EHorizontalTextPosition.Right;
+        _this.verticalTextPositionProperty = TextPosition_1.EVerticalTextPosition.Top;
+        _this.pointGapThresholdProperty = (_a = options === null || options === void 0 ? void 0 : options.pointGapThreshold) !== null && _a !== void 0 ? _a : _this.pointGapThresholdProperty;
+        _this.pointCountThresholdProperty = (_b = options === null || options === void 0 ? void 0 : options.pointCountThreshold) !== null && _b !== void 0 ? _b : _this.pointCountThresholdProperty;
+        _this.numericFormatProperty = (_c = options === null || options === void 0 ? void 0 : options.numericFormat) !== null && _c !== void 0 ? _c : _this.numericFormatProperty;
+        _this.precision = (_d = options === null || options === void 0 ? void 0 : options.precision) !== null && _d !== void 0 ? _d : _this.precisionProperty;
+        _this.skipNumberProperty = (_e = options === null || options === void 0 ? void 0 : options.skipNumber) !== null && _e !== void 0 ? _e : _this.skipNumberProperty;
+        _this.skipModeProperty = (_f = options === null || options === void 0 ? void 0 : options.skipMode) !== null && _f !== void 0 ? _f : _this.skipModeProperty;
+        _this.metaDataSelector = options === null || options === void 0 ? void 0 : options.metaDataSelector;
+        _this.ySelector = (_g = options === null || options === void 0 ? void 0 : options.ySelector) !== null && _g !== void 0 ? _g : (function (ps) { return ps.yValues; });
+        _this.updateTextInAnimation = (_h = options === null || options === void 0 ? void 0 : options.updateTextInAnimation) !== null && _h !== void 0 ? _h : _this.updateTextInAnimation;
+        _this.horizontalTextPositionProperty = (_j = options === null || options === void 0 ? void 0 : options.horizontalTextPosition) !== null && _j !== void 0 ? _j : _this.horizontalTextPosition;
+        _this.verticalTextPositionProperty = (_k = options === null || options === void 0 ? void 0 : options.verticalTextPosition) !== null && _k !== void 0 ? _k : _this.verticalTextPosition;
+        return _this;
+    }
+    /**
+     * @inheritDoc
+     */
+    DataLabelProvider.prototype.onAttach = function (webAssemblyContext, parentSeries) {
+        Guard_1.Guard.notNull(webAssemblyContext, "webAssemblyContext");
+        Guard_1.Guard.notNull(parentSeries, "parentSeries");
+        this.webAssemblyContext = webAssemblyContext;
+        this.parentSeries = parentSeries;
+    };
+    Object.defineProperty(DataLabelProvider.prototype, "pointGapThreshold", {
+        /**
+         * Gets or sets the zoom threshold above which label drawing will start. Default 0.
+         * This is expressed as the gap between the first points divided by the size of the first text
+         * If data is unevenly spaced, consider {@link pointCountThreshold} or override shouldDrawText
+         */
+        get: function () {
+            return this.pointGapThresholdProperty;
+        },
+        /**
+         * Gets or sets the zoom threshold above which label drawing will start. Default 0.
+         * This is expressed as the gap between the first points divided by the size of the first text
+         * If data is unevenly spaced, consider {@link pointCountThreshold} or override shouldDrawText
+         */
+        set: function (value) {
+            this.pointGapThresholdProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataLabelProvider.prototype, "pointCountThreshold", {
+        /**
+         * Gets or sets the number of points below which drawing will start.  Default Infinity
+         * This can be used instead of {@link pointGapThreshold} when data is unevenly spaced or has large y variation
+         */
+        get: function () {
+            return this.pointCountThresholdProperty;
+        },
+        /**
+         * Gets or sets the number of points below which drawing will start. Default Infinity
+         * This can be used instead of {@link pointGapThreshold} when data is unevenly spaced or has large y variation
+         */
+        set: function (value) {
+            this.pointCountThresholdProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataLabelProvider.prototype, "skipMode", {
+        /**
+         * How do decide whether to keep or skip a label once generated.
+         * Override {@link shouldSkipLabel} for more control
+         */
+        get: function () {
+            return this.skipModeProperty;
+        },
+        /**
+         * How do decide whether to keep or skip a label once generated.
+         * Override {@link shouldSkipLabel} for more control
+         */
+        set: function (value) {
+            this.skipModeProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataLabelProvider.prototype, "skipNumber", {
+        /**
+         * The number of points to skip while generating labels. Default 0 = no skip.  1 = skip every other.
+         * When creating text with many data points, it will help performance to skip points rather than creating and checking overlap for every data point.
+         */
+        get: function () {
+            return this.skipNumberProperty;
+        },
+        /**
+         * The number of points to skip while generating labels. Default 0 = no skip.  1 = skip every other.
+         * When creating text with many data points, it will help performance to skip points rather than creating and checking overlap for every data point.
+         */
+        set: function (value) {
+            this.skipNumberProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataLabelProvider.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) {
+            this.numericFormatProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataLabelProvider.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) {
+            this.precisionProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataLabelProvider.prototype, "horizontalTextPosition", {
+        /**
+         * Gets or sets the horizontal text position for the label
+         * For more control, override getPosition
+         */
+        get: function () {
+            return this.horizontalTextPositionProperty;
+        },
+        set: function (value) {
+            this.horizontalTextPositionProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataLabelProvider.prototype, "verticalTextPosition", {
+        /**
+         * Gets or sets the vertical text position for the label
+         * For more control, override getPosition
+         */
+        get: function () {
+            return this.verticalTextPositionProperty;
+        },
+        set: function (value) {
+            this.verticalTextPositionProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataLabelProvider.prototype.getText = function (state) {
+        var _a, _b;
+        if (this.metaDataSelector) {
+            return this.metaDataSelector(state.getMetaData());
+        }
+        var usefinal = !this.updateTextInAnimation && state.parentSeries.isRunningAnimation;
+        var yval = usefinal ? state.yValAfterAnimation() : state.yVal();
+        if (yval === yval) {
+            //isNaN check
+            return (0, number_1.formatNumber)(yval, (_a = this.numericFormat) !== null && _a !== void 0 ? _a : NumericFormat_1.ENumericFormat.Decimal, (_b = this.precision) !== null && _b !== void 0 ? _b : 1);
+        }
+        else {
+            return undefined;
+        }
+    };
+    /**
+     * Called at the start of generateDataLabels.  If false, no labels will be generated.
+     * Checks {@link pointCountThreshold} then {@link pointGapThreshold}
+     * @param state
+     * @returns
+     */
+    DataLabelProvider.prototype.shouldGenerate = function (state) {
+        var _a, _b;
+        if (state.pointCount > this.pointCountThresholdProperty)
+            return false;
+        var firstlabel = this.getText(state);
+        var bounds = (0, NativeObject_1.getTextBounds)(this.webAssemblyContext);
+        state.font.CalculateStringBounds(firstlabel !== null && firstlabel !== void 0 ? firstlabel : "", bounds, (_b = (_a = this.style) === null || _a === void 0 ? void 0 : _a.lineSpacing) !== null && _b !== void 0 ? _b : 2);
+        return state.pointGap > bounds.m_fWidth * this.pointGapThreshold;
+    };
+    DataLabelProvider.prototype.getPosition = function (state, textBounds) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var x = state.xCoord();
+        if (this.horizontalTextPosition === TextPosition_1.EHorizontalTextPosition.Center) {
+            x -= textBounds.m_fWidth / 2;
+        }
+        else if (this.horizontalTextPosition === TextPosition_1.EHorizontalTextPosition.Left) {
+            x -= textBounds.m_fWidth + ((_b = (_a = this.style.padding) === null || _a === void 0 ? void 0 : _a.right) !== null && _b !== void 0 ? _b : 0);
+        }
+        else {
+            x += (_d = (_c = this.style.padding) === null || _c === void 0 ? void 0 : _c.left) !== null && _d !== void 0 ? _d : 0;
+        }
+        var yOffset = textBounds.m_fHeight - textBounds.GetLineBounds(0).m_fHeight;
+        var y = state.yCoord() - yOffset;
+        if (this.verticalTextPosition === TextPosition_1.EVerticalTextPosition.Center) {
+            y += textBounds.m_fHeight / 2;
+        }
+        else if (this.verticalTextPosition === TextPosition_1.EVerticalTextPosition.Bottom) {
+            y += textBounds.m_fHeight + ((_f = (_e = this.style.padding) === null || _e === void 0 ? void 0 : _e.top) !== null && _f !== void 0 ? _f : 0);
+        }
+        else {
+            y -= (_h = (_g = this.style.padding) === null || _g === void 0 ? void 0 : _g.bottom) !== null && _h !== void 0 ? _h : 0;
+        }
+        return new Point_1.Point(x, y);
+    };
+    DataLabelProvider.prototype.getColor = function (state, text) {
+        return state.color;
+    };
+    DataLabelProvider.prototype.shouldSkipLabel = function (state, label) {
+        var _a;
+        // Skip if out of bounds
+        var svr = state.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;
+        switch (this.skipModeProperty) {
+            case DataLabelSkipMode_1.EDataLabelSkipMode.SkipIfOverlapPrevious:
+                return this.skipIfOverlapPrevious(state, label);
+            case DataLabelSkipMode_1.EDataLabelSkipMode.SkipIfOverlapNext:
+                return this.skipIfOverlapNext(state, label);
+            case DataLabelSkipMode_1.EDataLabelSkipMode.SkipIfSame:
+                return ((_a = state.lastLabel) === null || _a === void 0 ? void 0 : _a.text) === label.text;
+            case DataLabelSkipMode_1.EDataLabelSkipMode.ShowAll:
+                return false;
+            default:
+                return false;
+        }
+    };
+    /** Generates labels using getText, getPosition, getColor.  Overrides manually set labels. */
+    DataLabelProvider.prototype.generateDataLabels = function (renderContext, renderPassData) {
+        var _a, _b;
+        // clear any previous labels
+        this.dataLabels = [];
+        if (!this.style || !this.style.fontFamily || !this.style.fontSize) {
+            return;
+        }
+        var yValues = this.ySelector(renderPassData.pointSeries);
+        if (!yValues || yValues.size() === 0)
+            return;
+        this.state = new DataLabelState_1.DataLabelState(renderContext, renderPassData, this.style, this.color, yValues, this.parentSeries);
+        // console.log(
+        //     "gen ",
+        //     yValues.size(),
+        //     renderPassData.pointSeries.xRange,
+        //     renderPassData.pointSeries.indexes.size()
+        // );
+        var bounds = (0, NativeObject_1.getTextBounds)(this.webAssemblyContext);
+        if (!this.shouldGenerate(this.state))
+            return;
+        var skipCount = 0;
+        for (var i = this.state.indexStart; i <= this.state.indexEnd; i += this.skipNumberProperty + 1) {
+            this.state.index =
+                this.skipModeProperty === DataLabelSkipMode_1.EDataLabelSkipMode.SkipIfOverlapNext
+                    ? this.state.indexEnd - (i - this.state.indexStart)
+                    : i;
+            var text = this.getText(this.state);
+            if (!text)
+                continue;
+            this.state.font.CalculateStringBounds(text !== null && text !== void 0 ? text : "", bounds, (_b = (_a = this.style) === null || _a === void 0 ? void 0 : _a.lineSpacing) !== null && _b !== void 0 ? _b : 2);
+            // console.log(text, bounds.m_fHeight, bounds.GetLinesCount());
+            var position = this.getPosition(this.state, bounds);
+            var color = this.getColor(this.state, text);
+            var firstLineHeight = bounds.GetLineBounds(0).m_fHeight;
+            var label = {
+                text: text,
+                position: position,
+                rect: new Rect_1.Rect(position.x, position.y - firstLineHeight, bounds.m_fWidth, bounds.m_fHeight),
+                color: color,
+                dataX: this.state.xCoord(),
+                dataY: this.state.yCoord()
+            };
+            if (!this.shouldSkipLabel(this.state, label)) {
+                this.state.dataLabels.push(label);
+            }
+            else {
+                skipCount++;
+            }
+        }
+        if (skipCount > 100 && skipCount / (this.state.indexEnd - this.state.indexStart) > 0.8) {
+            performanceWarnings_1.performanceWarnings.dataLabelsSkippingMany.warn();
+        }
+        this.dataLabels = this.state.dataLabels;
+    };
+    DataLabelProvider.prototype.toJSON = function () {
+        var json = _super.prototype.toJSON.call(this);
+        var options = {
+            numericFormat: this.numericFormat,
+            pointGapThreshold: this.pointGapThreshold,
+            precision: this.precision,
+            pointCountThreshold: this.pointCountThreshold,
+            skipNumber: this.skipNumber,
+            skipMode: this.skipMode,
+            updateTextInAnimation: this.updateTextInAnimation,
+            horizontalTextPosition: this.horizontalTextPosition,
+            verticalTextPosition: this.verticalTextPosition
+        };
+        Object.assign(json.options, options);
+        return json;
+    };
+    DataLabelProvider.prototype.skipIfOverlapPrevious = function (state, label) {
+        var previous = state.lastLabel;
+        if (!previous)
+            // First label
+            return false;
+        if (previous.rect.right + state.xPadding < label.rect.left)
+            // x space
+            return false;
+        if (Math.abs(previous.rect.y - label.rect.y) > label.rect.height + state.yPadding)
+            // y space
+            return false;
+        return true;
+    };
+    DataLabelProvider.prototype.skipIfOverlapNext = function (state, label) {
+        // For this case, we generate the labels right to left, so last is the next to the right.
+        var next = state.lastLabel;
+        if (!next)
+            // First label
+            return false;
+        if (label.rect.right + state.xPadding < next.rect.left)
+            // x space
+            return false;
+        if (Math.abs(next.rect.y - label.rect.y) > label.rect.height + state.yPadding)
+            // y space
+            return false;
+        return true;
+    };
+    return DataLabelProvider;
+}(BaseDataLabelProvider_1.BaseDataLabelProvider));
+exports.DataLabelProvider = DataLabelProvider;

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

@@ -0,0 +1,40 @@
+import { TDataLabelStyle } from "../../../../types/TDataLabelStyle";
+import { SCRTDoubleVector, SCRTFont } from "../../../../types/TSciChart";
+import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
+import { RenderPassData } from "../../../Services/RenderPassData";
+import { IRenderableSeries } from "../IRenderableSeries";
+import { TDataLabel } from "./BaseDataLabelProvider";
+export declare class DataLabelState {
+    readonly style: TDataLabelStyle;
+    readonly pointGap: number;
+    readonly xValues: SCRTDoubleVector;
+    readonly yValues: SCRTDoubleVector;
+    readonly yFinalValues: SCRTDoubleVector;
+    readonly font: SCRTFont;
+    readonly parentSeries: IRenderableSeries;
+    readonly renderPassData: RenderPassData;
+    readonly isXFlipped: boolean;
+    readonly pointCount: number;
+    readonly xPadding: number;
+    readonly yPadding: number;
+    readonly color: number;
+    readonly dataLabels: TDataLabel[];
+    readonly indexStart: number;
+    readonly indexEnd: number;
+    private indexProperty;
+    private xCoordCache;
+    private yCoordCache;
+    constructor(renderContext: WebGlRenderContext2D, renderPassData: RenderPassData, style: TDataLabelStyle, color: string, yValues: SCRTDoubleVector, parentSeries: IRenderableSeries);
+    get index(): number;
+    set index(value: number);
+    xVal(index?: number): number;
+    yVal(index?: number): number;
+    yValAfterAnimation(index?: number): number;
+    xCoord(index?: number): number;
+    yCoord(index?: number): number;
+    hasNext(index?: number): boolean;
+    get lastLabel(): TDataLabel;
+    getMetaData(): import("../../../Model/IPointMetadata").IPointMetadata;
+    private xCoordInternal;
+    private yCoordInternal;
+}

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataLabelState = void 0;
+var NumberRange_1 = require("../../../../Core/NumberRange");
+var parseColor_1 = require("../../../../utils/parseColor");
+var DpiHelper_1 = require("../../TextureManager/DpiHelper");
+var DataLabelState = /** @class */ (function () {
+    function DataLabelState(renderContext, renderPassData, style, color, yValues, parentSeries) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        this.dataLabels = [];
+        this.indexProperty = 0;
+        this.xCoordCache = undefined;
+        this.yCoordCache = undefined;
+        var pointSeries = renderPassData.pointSeries;
+        var isCategoryAxis = renderPassData.xCoordinateCalculator.isCategoryCoordinateCalculator;
+        this.style = DpiHelper_1.DpiHelper.adjustTextStyle(style);
+        this.color = (0, parseColor_1.parseColorToUIntArgb)(color);
+        this.xValues = isCategoryAxis ? pointSeries.indexes : pointSeries.xValues;
+        this.yValues = yValues;
+        this.parentSeries = parentSeries;
+        this.renderPassData = renderPassData;
+        this.yFinalValues = (_a = this.parentSeries.dataSeries) === null || _a === void 0 ? void 0 : _a.yFinalAnimationValues;
+        this.isXFlipped = (renderPassData.isVerticalChart
+            ? this.renderPassData.yCoordinateCalculator
+            : this.renderPassData.xCoordinateCalculator).hasFlippedCoordinates;
+        if (!renderPassData.indexRange) {
+            var indicesRange = this.parentSeries.dataSeries.getIndicesRange(new NumberRange_1.NumberRange(renderPassData.xCoordinateCalculator.visibleMin, renderPassData.xCoordinateCalculator.visibleMax), isCategoryAxis);
+            this.indexStart = indicesRange.min;
+            this.indexEnd = indicesRange.max;
+            this.pointCount = indicesRange.diff;
+            if (this.pointCount > 1)
+                this.pointGap = Math.abs(this.xCoord(this.indexStart) - this.xCoord(this.indexEnd)) / this.pointCount;
+            else
+                this.pointGap = Infinity; // Single point
+        }
+        else {
+            this.indexStart = 0;
+            this.pointCount = this.xValues.size();
+            this.indexEnd = this.pointCount - 1;
+            this.pointGap = Math.abs(this.xCoord(this.indexStart) - this.xCoord(this.indexEnd)) / this.pointCount;
+        }
+        this.index = this.indexStart;
+        this.font = renderContext.getFont(this.style);
+        this.xPadding = ((_c = (_b = this.style.padding) === null || _b === void 0 ? void 0 : _b.left) !== null && _c !== void 0 ? _c : 0) + ((_e = (_d = this.style.padding) === null || _d === void 0 ? void 0 : _d.right) !== null && _e !== void 0 ? _e : 0);
+        this.yPadding = ((_g = (_f = this.style.padding) === null || _f === void 0 ? void 0 : _f.top) !== null && _g !== void 0 ? _g : 0) + ((_j = (_h = this.style.padding) === null || _h === void 0 ? void 0 : _h.bottom) !== null && _j !== void 0 ? _j : 0);
+    }
+    Object.defineProperty(DataLabelState.prototype, "index", {
+        get: function () {
+            return this.indexProperty;
+        },
+        set: function (value) {
+            this.xCoordCache = undefined;
+            this.yCoordCache = undefined;
+            this.indexProperty = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataLabelState.prototype.xVal = function (index) {
+        var i = index !== null && index !== void 0 ? index : this.indexProperty;
+        if (!this.isXFlipped) {
+            i = this.indexEnd - (i - this.indexStart);
+        }
+        return this.xValues.get(i);
+    };
+    DataLabelState.prototype.yVal = function (index) {
+        var i = index !== null && index !== void 0 ? index : this.indexProperty;
+        if (!this.isXFlipped) {
+            i = this.indexEnd - (i - this.indexStart);
+        }
+        return this.yValues.get(i);
+    };
+    DataLabelState.prototype.yValAfterAnimation = function (index) {
+        if (!this.yFinalValues)
+            return this.yVal(index);
+        var i = index !== null && index !== void 0 ? index : this.indexProperty;
+        if (!this.isXFlipped) {
+            i = this.indexEnd - (i - this.indexStart);
+        }
+        return this.yFinalValues.get(i);
+    };
+    DataLabelState.prototype.xCoord = function (index) {
+        if (this.renderPassData.isVerticalChart)
+            return this.yCoordInternal(index);
+        else
+            return this.xCoordInternal(index);
+    };
+    DataLabelState.prototype.yCoord = function (index) {
+        if (this.renderPassData.isVerticalChart)
+            return this.xCoordInternal(index);
+        else
+            return this.yCoordInternal(index);
+    };
+    DataLabelState.prototype.hasNext = function (index) {
+        var i = index !== null && index !== void 0 ? index : this.indexProperty;
+        if (!this.isXFlipped)
+            return i > 0;
+        else
+            return i < this.indexEnd;
+    };
+    Object.defineProperty(DataLabelState.prototype, "lastLabel", {
+        get: function () {
+            if (this.dataLabels.length > 0) {
+                return this.dataLabels[this.dataLabels.length - 1];
+            }
+            else {
+                return undefined;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataLabelState.prototype.getMetaData = function () {
+        var index = this.renderPassData.pointSeries.indexes.get(this.index);
+        return this.parentSeries.dataSeries.getMetadataAt(index);
+    };
+    DataLabelState.prototype.xCoordInternal = function (index) {
+        if (index !== undefined)
+            return this.renderPassData.xCoordinateCalculator.getCoordinate(this.xVal(index));
+        else {
+            if (this.xCoordCache !== undefined)
+                return this.xCoordCache;
+            else
+                this.xCoordCache = this.renderPassData.xCoordinateCalculator.getCoordinate(this.xVal());
+            return this.xCoordCache;
+        }
+    };
+    DataLabelState.prototype.yCoordInternal = function (index) {
+        if (index !== undefined)
+            return this.renderPassData.yCoordinateCalculator.getCoordinate(this.yVal(index));
+        else {
+            if (this.yCoordCache !== undefined)
+                return this.yCoordCache;
+            else
+                this.yCoordCache = this.renderPassData.yCoordinateCalculator.getCoordinate(this.yVal());
+            return this.yCoordCache;
+        }
+    };
+    return DataLabelState;
+}());
+exports.DataLabelState = DataLabelState;

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

@@ -0,0 +1,63 @@
+import { Point } from "../../../../Core/Point";
+import { EDataLabelProviderType } from "../../../../types/DataLabelProviderType";
+import { ENumericFormat } from "../../../../types/NumericFormat";
+import { Size } from "../../../../types/Size";
+import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
+import { BaseHeatmapDataSeries } from "../../../Model/BaseHeatmapDataSeries";
+import { IPointMetadata } from "../../../Model/IPointMetadata";
+import { RenderPassData } from "../../../Services/RenderPassData";
+import { BaseDataLabelProvider, IBaseDataLabelProviderOptions, TDataLabel } from "./BaseDataLabelProvider";
+export interface IHeatmapDataLabelProviderOptions extends IBaseDataLabelProviderOptions {
+    /**
+     * Gets or sets numeric format to use for formatting values to text. For a list of values, see {@link ENumericFormat}
+     */
+    numericFormat?: ENumericFormat;
+    /**
+     * Gets or sets the precision to use when formatting values to text.
+     */
+    precision?: number;
+    /**
+     * If this is set it will be used to get text values from metaData, rather than formatting y values.
+     * The selector will be called even if the metaData for an index is undefined.
+     */
+    metaDataSelector?: (metadata: IPointMetadata) => string;
+}
+export declare class HeatMapDataLabelProvider extends BaseDataLabelProvider {
+    readonly type: EDataLabelProviderType;
+    /**
+     * If this is set it will be used to get text values from metaData, rather than formatting y values.
+     * The selector will be called even if the metaData for an index is undefined.
+     */
+    metaDataSelector: (metadata: IPointMetadata) => string;
+    protected dataSeries: BaseHeatmapDataSeries;
+    protected zValues: number[][];
+    protected colorValue: number;
+    private numericFormatProperty;
+    private precisionProperty;
+    constructor(options?: IHeatmapDataLabelProviderOptions);
+    /**
+     * 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 numericFormat(): ENumericFormat;
+    set numericFormat(value: ENumericFormat);
+    /**
+     * Gets or sets the precision to use when formatting values to text
+     * For more control, override getText
+     */
+    get precision(): number;
+    set precision(value: number);
+    getText(xIndex: number, yIndex: number): string;
+    getPosition(xIndex: number, yIndex: number, xVal: number, yVal: number, textSize: Size, cellWidth: number, cellHeight: number, renderPassData: RenderPassData): Point;
+    shouldGenerate(textSize: Size, cellWidth: number, cellHeight: number): boolean;
+    getColor(xIndex: number, yIndex: number, text: string): number;
+    shouldSkipLabel(xIndex: number, yIndex: number, label: TDataLabel, cellWidth: number, cellHeight: number): boolean;
+    generateDataLabels(renderContext: WebGlRenderContext2D, renderPassData: RenderPassData): void;
+    toJSON(): {
+        type: EDataLabelProviderType;
+        options: {
+            style: import("../../../../types/TDataLabelStyle").TDataLabelStyle;
+            color: string;
+        };
+    };
+}