scichart 2.2.2417 → 3.0.0-beta.224

package/Charting/Model/IDataSeries.d.ts

@@ -31,10 +31,18 @@ export declare enum EDataSeriesType {
      * Defines a {@link UniformHeatmapDataSeries | DataSeries}
      */
     HeatmapUniform = "UniformHeatmap",
+    /**
+     * Defines a {@link UniformHeatmapDataSeries | DataSeries}
+     */
+    HeatmapNonUniform = "NonUniformHeatmap",
     /**
      * Defines a {@link HlcDataSeries}
      */
-    Hlc = "Hlc"
+    Hlc = "Hlc",
+    /**
+     * Defines a {@link XyTextDataSeries}
+     */
+    XyText = "XyText"
 }
 export declare enum EDataChangeType {
     Append = 0,

package/Charting/Model/IDataSeries.js

@@ -29,10 +29,18 @@ var EDataSeriesType;
      * Defines a {@link UniformHeatmapDataSeries | DataSeries}
      */
     EDataSeriesType["HeatmapUniform"] = "UniformHeatmap";
+    /**
+     * Defines a {@link UniformHeatmapDataSeries | DataSeries}
+     */
+    EDataSeriesType["HeatmapNonUniform"] = "NonUniformHeatmap";
     /**
      * Defines a {@link HlcDataSeries}
      */
     EDataSeriesType["Hlc"] = "Hlc";
+    /**
+     * Defines a {@link XyTextDataSeries}
+     */
+    EDataSeriesType["XyText"] = "XyText";
 })(EDataSeriesType = exports.EDataSeriesType || (exports.EDataSeriesType = {}));
 var EDataChangeType;
 (function (EDataChangeType) {

package/Charting/Model/NonUniformHeatmapDataSeries.d.ts

@@ -0,0 +1,112 @@
+import { TSeriesDataDefinition } from "../../Builder/buildDataSeries";
+import { NumberRange } from "../../Core/NumberRange";
+import { ESearchMode } from "../../types/SearchMode";
+import { SCRTDoubleVector, TSciChart } from "../../types/TSciChart";
+import { BaseHeatmapDataSeries, IBaseHeatmapSeriesOptions } from "./BaseHeatmapDataSeries";
+import { EDataChangeType, EDataSeriesType } from "./IDataSeries";
+export declare type TCellSizeMapper = (index: number) => number;
+/**
+ * Options to pass to the {@link NonUniformHeatmapSeries} constructor
+ */
+export interface INonUniformHeatmapSeriesOptions extends IBaseHeatmapSeriesOptions {
+    /**
+     * xCellOffsets defines cell X offsets on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+     * Can be an array of numbers or a mapping function {@link TCellSizeMapper}
+     * @remarks mapping function would not be preserved by chart serialization
+     */
+    xCellOffsets: number[] | TCellSizeMapper;
+    /**
+     * yCellOffsets defines cell Y offsets on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+     * Can be an array of numbers or a mapping function {@link TCellSizeMapper}
+     * @remarks mapping function would not be preserved by chart serialization
+     */
+    yCellOffsets: number[] | TCellSizeMapper;
+}
+export declare class NonUniformHeatmapDataSeries extends BaseHeatmapDataSeries {
+    /**
+     * @inheritDoc
+     */
+    readonly type: EDataSeriesType;
+    private xRangeProperty;
+    private yRangeProperty;
+    private xCellSizesProperty;
+    private yCellSizesProperty;
+    private xCellOffsetsProperty;
+    private yCellOffsetsProperty;
+    private nativeYOffsetsProperty;
+    private nativeXOffsetsProperty;
+    private xCellOffsetsGeneratorFunction;
+    private yCellOffsetsGeneratorFunction;
+    /**
+     * Creates an instance of {@link UniformHeatmapDataSeries}
+     * @param webAssemblyContext the {@link TSciChart | SciChart WebAssembly Context} containing native methods
+     * and access to our underlying WebGL2 rendering engine
+     * @param options the {@link IUniformHeatmapSeriesOptions} which must be passed to configure the series
+     */
+    constructor(webAssemblyContext: TSciChart, options: INonUniformHeatmapSeriesOptions);
+    /**
+     * Gets or sets cell X sizes on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+     * Can be an array of numbers or a mapping function {@link TCellSizeMapper}
+     */
+    get xCellSizes(): number[];
+    /**
+     * Gets or sets cell Y sizes on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+     * Can be an array of numbers or a mapping function {@link TCellSizeMapper}
+     */
+    get yCellSizes(): number[];
+    /**
+     * Gets X cell offsets on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+     */
+    get xCellOffsets(): number[];
+    /**
+     * Gets Y cell offsets on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+     */
+    get yCellOffsets(): number[];
+    /**
+     * Gets X cell offsets as native vector on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+     */
+    get nativeXCellOffsets(): SCRTDoubleVector;
+    /**
+     * Gets X cell offsets as native vector on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+     */
+    get nativeYCellOffsets(): SCRTDoubleVector;
+    /**
+     * Gets the X-value at the specified index. This will be computed from constructor parameters xCellOffsets and xStart
+     * @param xIndex
+     */
+    getXValue(xIndex: number): number;
+    /**
+     * Gets the Y-value at the specified index. This will be computed from constructor parameters yCellOffsets and yxStart
+     * @param xIndex
+     */
+    getYValue(yIndex: number): number;
+    /**
+     * @inheritDoc
+     */
+    notifyDataChanged(updateType: EDataChangeType, data?: any): void;
+    /**
+     * @inheritDoc
+     */
+    toJSON(excludeData?: boolean): TSeriesDataDefinition;
+    /**
+     * @inheritDoc
+     */
+    getXRange(): NumberRange;
+    /**
+     * @inheritDoc
+     */
+    getYRange(): NumberRange;
+    getXIndicesRange(visibleRange: NumberRange, isCategoryData: boolean, downSearchMode?: ESearchMode, upSearchMode?: ESearchMode): NumberRange;
+    getYIndicesRange(visibleRange: NumberRange, isCategoryData: boolean, downSearchMode?: ESearchMode, upSearchMode?: ESearchMode): NumberRange;
+    delete(): void;
+    /**
+     * @param cellOffsets
+     * @returns an array with cell sizes to heatmap size ratios
+     */
+    protected mapCellSizes(zValuesDimensionSize: number, mapping: TCellSizeMapper): number[];
+    /**
+     * @param cellOffsets
+     * @returns an array with cell sizes to heatmap size ratios
+     */
+    protected calculateCellSizes(cellOffsets: number[]): number[];
+}

package/Charting/Model/NonUniformHeatmapDataSeries.js

@@ -0,0 +1,261 @@
+"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 __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonUniformHeatmapDataSeries = void 0;
+var Deleter_1 = require("../../Core/Deleter");
+var Guard_1 = require("../../Core/Guard");
+var NumberRange_1 = require("../../Core/NumberRange");
+var TSciChart_1 = require("../../types/TSciChart");
+var appendDoubleVectorFromJsArray_1 = require("../../utils/ccall/appendDoubleVectorFromJsArray");
+var BaseDataSeries_1 = require("./BaseDataSeries");
+var BaseHeatmapDataSeries_1 = require("./BaseHeatmapDataSeries");
+var IDataSeries_1 = require("./IDataSeries");
+var NonUniformHeatmapDataSeries = /** @class */ (function (_super) {
+    __extends(NonUniformHeatmapDataSeries, _super);
+    /**
+     * Creates an instance of {@link UniformHeatmapDataSeries}
+     * @param webAssemblyContext the {@link TSciChart | SciChart WebAssembly Context} containing native methods
+     * and access to our underlying WebGL2 rendering engine
+     * @param options the {@link IUniformHeatmapSeriesOptions} which must be passed to configure the series
+     */
+    function NonUniformHeatmapDataSeries(webAssemblyContext, options) {
+        var _this = _super.call(this, webAssemblyContext, options) || this;
+        /**
+         * @inheritDoc
+         */
+        _this.type = IDataSeries_1.EDataSeriesType.HeatmapNonUniform;
+        Guard_1.Guard.notNull(options.xCellOffsets, "options.xCellOffsets");
+        Guard_1.Guard.notNull(options.yCellOffsets, "options.yCellOffsets");
+        // check whether offsets are passed as mappers or arrays;
+        // arrays are saved once, while mappers are used for calculation of the offsets each time we change
+        if (!Array.isArray(options.xCellOffsets)) {
+            _this.xCellOffsetsGeneratorFunction = options.xCellOffsets;
+        }
+        else if (options.xCellOffsets.length < _this.arrayWidth + 1) {
+            throw new Error("xCellOffsets array should not be smaller than zValues width!");
+        }
+        else {
+            _this.xCellOffsetsProperty = options.xCellOffsets;
+        }
+        if (!Array.isArray(options.yCellOffsets)) {
+            _this.yCellOffsetsGeneratorFunction = options.yCellOffsets;
+        }
+        else if (options.yCellOffsets.length < _this.arrayHeight + 1) {
+            throw new Error("yCellOffsets array should not be smaller than zValues height!");
+        }
+        else {
+            _this.yCellOffsetsProperty = options.yCellOffsets;
+        }
+        _this.nativeXOffsetsProperty = new _this.webAssemblyContext.SCRTDoubleVector();
+        _this.nativeYOffsetsProperty = new _this.webAssemblyContext.SCRTDoubleVector();
+        // notify about offsets being parsed
+        if (_this.getZValues()) {
+            _this.notifyDataChanged(IDataSeries_1.EDataChangeType.Append);
+        }
+        return _this;
+    }
+    Object.defineProperty(NonUniformHeatmapDataSeries.prototype, "xCellSizes", {
+        /**
+         * Gets or sets cell X sizes on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+         * Can be an array of numbers or a mapping function {@link TCellSizeMapper}
+         */
+        get: function () {
+            if (!this.xCellSizesProperty) {
+                this.xCellSizesProperty = this.calculateCellSizes(this.xCellOffsetsProperty);
+            }
+            return this.xCellSizesProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NonUniformHeatmapDataSeries.prototype, "yCellSizes", {
+        /**
+         * Gets or sets cell Y sizes on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+         * Can be an array of numbers or a mapping function {@link TCellSizeMapper}
+         */
+        get: function () {
+            if (!this.yCellSizesProperty) {
+                this.yCellSizesProperty = this.calculateCellSizes(this.yCellOffsetsProperty);
+            }
+            return this.yCellSizesProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NonUniformHeatmapDataSeries.prototype, "xCellOffsets", {
+        /**
+         * Gets X cell offsets on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+         */
+        get: function () {
+            return this.xCellOffsetsProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NonUniformHeatmapDataSeries.prototype, "yCellOffsets", {
+        /**
+         * Gets Y cell offsets on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+         */
+        get: function () {
+            return this.yCellOffsetsProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NonUniformHeatmapDataSeries.prototype, "nativeXCellOffsets", {
+        /**
+         * Gets X cell offsets as native vector on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+         */
+        get: function () {
+            if (!this.nativeXOffsetsProperty) {
+                this.nativeXOffsetsProperty = new TSciChart_1.SCRTDoubleVector();
+                (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, this.nativeXOffsetsProperty, this.xCellOffsets);
+            }
+            return this.nativeXOffsetsProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NonUniformHeatmapDataSeries.prototype, "nativeYCellOffsets", {
+        /**
+         * Gets X cell offsets as native vector on {@link NonUniformHeatmapDataSeries} for each cell in the heatmap.
+         */
+        get: function () {
+            if (!this.nativeYOffsetsProperty) {
+                this.nativeYOffsetsProperty = new TSciChart_1.SCRTDoubleVector();
+                (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, this.nativeYOffsetsProperty, this.yCellOffsets);
+            }
+            return this.nativeYOffsetsProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Gets the X-value at the specified index. This will be computed from constructor parameters xCellOffsets and xStart
+     * @param xIndex
+     */
+    NonUniformHeatmapDataSeries.prototype.getXValue = function (xIndex) {
+        var offset = this.xCellOffsetsProperty[xIndex];
+        return offset;
+    };
+    /**
+     * Gets the Y-value at the specified index. This will be computed from constructor parameters yCellOffsets and yxStart
+     * @param xIndex
+     */
+    NonUniformHeatmapDataSeries.prototype.getYValue = function (yIndex) {
+        var offset = this.yCellOffsetsProperty[yIndex];
+        return offset;
+    };
+    /**
+     * @inheritDoc
+     */
+    NonUniformHeatmapDataSeries.prototype.notifyDataChanged = function (updateType, data) {
+        // skip the initial call from base constructor
+        if ((!this.xCellOffsets && !this.xCellOffsetsGeneratorFunction) ||
+            (!this.yCellOffsets && !this.yCellOffsetsGeneratorFunction)) {
+            return;
+        }
+        if (updateType === IDataSeries_1.EDataChangeType.Append) {
+            // set offsets when zValues changes
+            if (this.xCellOffsetsGeneratorFunction) {
+                this.xCellOffsetsProperty = this.mapCellSizes(this.arrayWidth, this.xCellOffsetsGeneratorFunction);
+            }
+            if (this.yCellOffsetsGeneratorFunction) {
+                this.yCellOffsetsProperty = this.mapCellSizes(this.arrayHeight, this.yCellOffsetsGeneratorFunction);
+            }
+            this.nativeXOffsetsProperty.clear();
+            this.nativeYOffsetsProperty.clear();
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, this.nativeXOffsetsProperty, this.xCellOffsetsProperty);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, this.nativeYOffsetsProperty, this.yCellOffsetsProperty);
+        }
+        this.xRangeProperty = new NumberRange_1.NumberRange(this.getXValue(0), this.getXValue(this.arrayWidth));
+        this.yRangeProperty = new NumberRange_1.NumberRange(this.getYValue(0), this.getYValue(this.arrayHeight));
+        _super.prototype.notifyDataChanged.call(this, updateType, data);
+    };
+    /**
+     * @inheritDoc
+     */
+    NonUniformHeatmapDataSeries.prototype.toJSON = function (excludeData) {
+        var options = __assign(__assign({}, _super.prototype.toJSON.call(this, excludeData)), { xCellOffsets: this.xCellOffsetsProperty, yCellOffsets: this.yCellOffsetsProperty });
+        return options;
+    };
+    /**
+     * @inheritDoc
+     */
+    NonUniformHeatmapDataSeries.prototype.getXRange = function () {
+        return this.xRangeProperty;
+    };
+    /**
+     * @inheritDoc
+     */
+    NonUniformHeatmapDataSeries.prototype.getYRange = function () {
+        return this.yRangeProperty;
+    };
+    NonUniformHeatmapDataSeries.prototype.getXIndicesRange = function (visibleRange, isCategoryData, downSearchMode, upSearchMode) {
+        return (0, BaseDataSeries_1.getIndicesRange)(this.webAssemblyContext, this.nativeXCellOffsets, visibleRange, true);
+    };
+    NonUniformHeatmapDataSeries.prototype.getYIndicesRange = function (visibleRange, isCategoryData, downSearchMode, upSearchMode) {
+        return (0, BaseDataSeries_1.getIndicesRange)(this.webAssemblyContext, this.nativeYCellOffsets, visibleRange, true);
+    };
+    NonUniformHeatmapDataSeries.prototype.delete = function () {
+        _super.prototype.delete.call(this);
+        this.nativeXOffsetsProperty = (0, Deleter_1.deleteSafe)(this.nativeXOffsetsProperty);
+        this.nativeYOffsetsProperty = (0, Deleter_1.deleteSafe)(this.nativeYOffsetsProperty);
+    };
+    /**
+     * @param cellOffsets
+     * @returns an array with cell sizes to heatmap size ratios
+     */
+    NonUniformHeatmapDataSeries.prototype.mapCellSizes = function (zValuesDimensionSize, mapping) {
+        var cellSizes = [];
+        var offsetsCount = zValuesDimensionSize + 1;
+        for (var i = 0; i < offsetsCount; ++i) {
+            cellSizes.push(mapping(i));
+        }
+        return cellSizes;
+    };
+    /**
+     * @param cellOffsets
+     * @returns an array with cell sizes to heatmap size ratios
+     */
+    NonUniformHeatmapDataSeries.prototype.calculateCellSizes = function (cellOffsets) {
+        if (!cellOffsets || cellOffsets.length === 0) {
+            return [];
+        }
+        var count = cellOffsets.length;
+        var heatmapRange = cellOffsets[count - 1] - cellOffsets[0];
+        var cellSizeRatios = [];
+        for (var i = 0; i < count - 1; ++i) {
+            var diff = cellOffsets[i + 1] - cellOffsets[i];
+            cellSizeRatios.push(diff / heatmapRange);
+        }
+        return cellSizeRatios;
+    };
+    return NonUniformHeatmapDataSeries;
+}(BaseHeatmapDataSeries_1.BaseHeatmapDataSeries));
+exports.NonUniformHeatmapDataSeries = NonUniformHeatmapDataSeries;

package/Charting/Model/PaletteFactory.d.ts

@@ -1,18 +1,54 @@
 import { GradientParams } from "../../Core/GradientParams";
 import { TGradientStop } from "../../types/TGradientStop";
 import { TSciChart } from "../../types/TSciChart";
-import { IStrokePaletteProvider } from "./IPaletteProvider";
+import { IFillPaletteProvider, IPointMarkerPaletteProvider, IStrokePaletteProvider } from "./IPaletteProvider";
+/**
+ * Placeholder interface that implements all paletteprovider types
+ */
+export interface IAllPaletteProviders extends IStrokePaletteProvider, IFillPaletteProvider, IPointMarkerPaletteProvider {
+}
+/**
+ * Additional options passed to {@link PaletteFactory.createGradient} to define which features are enabled in the gradient paletteprovider
+ */
+export interface IGradientPaletteOptions {
+    /**
+     * When true (default = true), IStrokePaletteProvider is enabled
+     */
+    enableStroke?: boolean;
+    /**
+     * When true (default = false), IFillPaletteProvider is enabled
+     */
+    enableFill?: boolean;
+    /**
+     * When true (default = false), IPointMarkerPaletteProvider is enabled
+     */
+    enablePointMarkers?: boolean;
+    /**
+     * Optional opacity (default = 1) applied to IStrokePaletteProvider calculations
+     */
+    strokeOpacity?: number;
+    /**
+     * Optional opacity (default = 1) applied to IFillPaletteProvider calculations
+     */
+    fillOpacity?: number;
+    /**
+     * Optional opacity (default = 1) applied to IPointMarkerPaletteProvider calculations
+     */
+    pointMarkerOpacity?: number;
+}
 /**
  * The PaletteFactory allows easy creation of palettes for some chart types
  */
 export declare class PaletteFactory {
     static readonly precision: number;
     /**
-     * Creates a Gradient Palette for line series, returning a {@link IStrokePaletteProvider} implementation which
-     * colors data-points of line charts depending on the x-index of the data according to the Gradient Brush passed in
+     * Creates a multi purpose Gradient Palette for line series, scatter, bubble or column and mountain series returning
+     * an {@link IPaletteProvider} implementation which
+     * colors data-points of charts depending on the x-index of the data according to the Gradient Brush passed in
      * @param webAssemblyContext the {@link TSciChart | SciChart WebAssembly Context} containing native methods
      * @param gradientBrush the {@link GradientParams} containing information about the Gradient Brush
+     * @param options the {@link IGradientPaletteOptions} containing additional options to turn stroke, fill or pointmarker sections on or off, and opacity per option
      */
-    static createGradient(webAssemblyContext: TSciChart, gradientBrush: GradientParams): IStrokePaletteProvider;
+    static createGradient(webAssemblyContext: TSciChart, gradientBrush: GradientParams, options?: IGradientPaletteOptions): IAllPaletteProviders;
     static createColorMap(webAssemblyContext: TSciChart, gradientStops: TGradientStop[]): number[];
 }

package/Charting/Model/PaletteFactory.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaletteFactory = void 0;
 var PaletteProviderType_1 = require("../../types/PaletteProviderType");
+var colorUtil_1 = require("../../utils/colorUtil");
 var parseColor_1 = require("../../utils/parseColor");
 var IPaletteProvider_1 = require("./IPaletteProvider");
 /**
@@ -11,32 +12,57 @@ var PaletteFactory = /** @class */ (function () {
     function PaletteFactory() {
     }
     /**
-     * Creates a Gradient Palette for line series, returning a {@link IStrokePaletteProvider} implementation which
-     * colors data-points of line charts depending on the x-index of the data according to the Gradient Brush passed in
+     * Creates a multi purpose Gradient Palette for line series, scatter, bubble or column and mountain series returning
+     * an {@link IPaletteProvider} implementation which
+     * colors data-points of charts depending on the x-index of the data according to the Gradient Brush passed in
      * @param webAssemblyContext the {@link TSciChart | SciChart WebAssembly Context} containing native methods
      * @param gradientBrush the {@link GradientParams} containing information about the Gradient Brush
+     * @param options the {@link IGradientPaletteOptions} containing additional options to turn stroke, fill or pointmarker sections on or off, and opacity per option
      */
-    PaletteFactory.createGradient = function (webAssemblyContext, gradientBrush) {
+    PaletteFactory.createGradient = function (webAssemblyContext, gradientBrush, options) {
         // TODO (Andrew): Adjust createGradient to modify the output based on start/end point of gradient brush
         var xFactor = gradientBrush.endPoint.x - gradientBrush.startPoint.x;
         var yFactor = gradientBrush.endPoint.y - gradientBrush.startPoint.y;
         var colorData = PaletteFactory.createColorMap(webAssemblyContext, gradientBrush.gradientStops.slice(0));
         var renderSeries;
+        var doFunc = function (xValue, yValue, index, opacity) {
+            if (opacity === void 0) { opacity = 1; }
+            var count = renderSeries.getDataSeriesValuesCount();
+            var lerpFactor = index / (count - 1);
+            var mapIndex = webAssemblyContext.NumberUtil.Constrain(Math.round(lerpFactor * (colorData.length - 1)), 0, colorData.length - 1);
+            var result = colorData[mapIndex];
+            // console.log("GradientPalette called!");
+            // console.log(`mapIndex is ${mapIndex}, colorData.length is ${colorData.length}`);
+            // console.log(`count is ${count}, lerp is ${lerpFactor}. result is ${result}`);
+            return (0, colorUtil_1.uintArgbColorMultiplyOpacity)(result, opacity);
+        };
+        var hasStroke = options === undefined || (options === null || options === void 0 ? void 0 : options.enableStroke) === true;
+        var hasFill = (options === null || options === void 0 ? void 0 : options.enableFill) === true;
+        var hasMarker = (options === null || options === void 0 ? void 0 : options.enablePointMarkers) === true;
         var palette = {
             strokePaletteMode: IPaletteProvider_1.EStrokePaletteMode.GRADIENT,
+            fillPaletteMode: IPaletteProvider_1.EFillPaletteMode.GRADIENT,
             onAttached: function (parentSeries) {
                 renderSeries = parentSeries;
             },
             onDetached: function () { },
             overrideStrokeArgb: function (xValue, yValue, index) {
-                var count = renderSeries.getDataSeriesValuesCount();
-                var lerpFactor = index / (count - 1);
-                var mapIndex = webAssemblyContext.NumberUtil.Constrain(Math.round(lerpFactor * (colorData.length - 1)), 0, colorData.length - 1);
-                var result = colorData[mapIndex];
-                // console.log("GradientPalette called!");
-                // console.log(`mapIndex is ${mapIndex}, colorData.length is ${colorData.length}`);
-                // console.log(`count is ${count}, lerp is ${lerpFactor}. result is ${result}`);
-                return result;
+                var _a;
+                return hasStroke ? doFunc(xValue, yValue, index, (_a = options === null || options === void 0 ? void 0 : options.strokeOpacity) !== null && _a !== void 0 ? _a : 1) : undefined;
+            },
+            overrideFillArgb: function (xValue, yValue, index, opacity, metadata) {
+                var _a;
+                return hasFill ? doFunc(xValue, yValue, index, (_a = options === null || options === void 0 ? void 0 : options.fillOpacity) !== null && _a !== void 0 ? _a : 1) : undefined;
+            },
+            overridePointMarkerArgb: function (xValue, yValue, index, opacity, metadata) {
+                var _a;
+                var markerOpacity = (_a = options === null || options === void 0 ? void 0 : options.pointMarkerOpacity) !== null && _a !== void 0 ? _a : 1;
+                return hasMarker
+                    ? {
+                        fill: doFunc(xValue, yValue, index, markerOpacity),
+                        stroke: doFunc(xValue, yValue, index, markerOpacity)
+                    }
+                    : undefined;
             },
             toJSON: function () {
                 return { type: PaletteProviderType_1.EPaletteProviderType.Gradient, options: gradientBrush };

package/Charting/Model/XyTextDataSeries.d.ts

@@ -0,0 +1,121 @@
+import { NumberArray } from "../../types/NumberArray";
+import { TSciChart } from "../../types/TSciChart";
+import { BaseDataSeries } from "./BaseDataSeries";
+import { EDataSeriesType } from "./IDataSeries";
+import { IPointMetadata } from "./IPointMetadata";
+import { IXyDataSeriesOptions } from "./XyDataSeries";
+/**
+ * Options to pass to the {@link XyTextDataSeries} constructor
+ */
+export interface IXyTextDataSeriesOptions extends IXyDataSeriesOptions {
+    /**
+     * The text-values array to pre-populate the {@link XyTextDataSeries}
+     */
+    textValues?: string[];
+}
+export declare class XyTextDataSeries extends BaseDataSeries {
+    /**
+     * @inheritDoc
+     */
+    readonly type = EDataSeriesType.XyText;
+    private textValuesProperty;
+    /**
+     * Creates an instance of {@link XyDataSeries}
+     * @param webAssemblyContext the {@link TSciChart | SciChart WebAssembly Context} containing native methods
+     * and access to our underlying WebGL2 WebAssembly rendering engine
+     * @param options the {@link IXyDataSeriesOptions} which can be passed to configure the DataSeries at construct time
+     */
+    constructor(webAssemblyContext: TSciChart, options?: IXyTextDataSeriesOptions);
+    /** The text values for this series.  Manipulate using append, insert, update etc on the XyTextDataSeries  */
+    get textValues(): readonly string[];
+    /**
+     * Appends a single X, Y, Text point to the DataSeries
+     * @remarks
+     * For best performance on drawing large datasets, use the {@link appendRange} method
+     *
+     * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
+     * @param x The X-value
+     * @param y The Y-value
+     * @param text The text-value
+     * @param metadata The point metadata
+     */
+    append(x: number, y: number, text: string, metadata?: IPointMetadata): void;
+    /**
+     * Appends a range of X, Y, Text points to the DataSeries
+     * @remarks
+     * This method is considerably higher performance than {@link append} which appends a single point
+     *
+     * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
+     * @param xValues The X-values
+     * @param yValues The Y-values
+     * @param textValues The text values
+     * @param metadata The array of point metadata
+     */
+    appendRange(xValues: NumberArray, yValues: NumberArray, textValues: string[], metadata?: IPointMetadata[]): void;
+    /**
+     * Updates a single Y-value by X-index
+     * @remarks Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
+     * @param index the index to update
+     * @param y The new Y value
+     * @param text The new text value
+     * @param metadata The point metadata
+     */
+    update(index: number, y: number, text: string, metadata?: IPointMetadata): void;
+    /**
+     * Updates a single X, Y, Text value, by X-index. Might also need to set isSorted = false
+     * @remarks Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
+     * @param index The index to update
+     * @param x The new X value
+     * @param y The new Y value
+     * @param text The new text value
+     * @param metadata The point metadata
+     */
+    updateXyText(index: number, x: number, y: number, text: string, metadata?: IPointMetadata): void;
+    /**
+     * @summary Inserts a single X,Y,Text value at the start index
+     * @remarks
+     * For best performance on drawing large datasets, use the {@link insertRange} method
+     *
+     * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
+     * @param startIndex the index to insert at
+     * @param x the X value
+     * @param y the Y value
+     * @param text The new text value
+     * @param metadata The point metadata
+     */
+    insert(startIndex: number, x: number, y: number, text: string, metadata?: IPointMetadata): void;
+    /**
+     * @summary Inserts a range of X,Y values at the startIndex
+     * @remarks
+     * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
+     * @param startIndex the index to insert at
+     * @param xValues the XValues
+     * @param yValues the YValues
+     * @param textValues The text values
+     * @param metadata The array of point metadata
+     */
+    insertRange(startIndex: number, xValues: NumberArray, yValues: NumberArray, textValues: string[], metadata?: IPointMetadata[]): void;
+    /**
+     * Removes an X,Y value at the specified index
+     * @remarks Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
+     * @param index the index to remove at
+     */
+    removeAt(index: number): void;
+    /**
+     * @summary Removes a range of X,Y values at the specified index
+     * @remarks Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
+     * @param startIndex the start index to remove at
+     * @param count the number of points to remove
+     */
+    removeRange(startIndex: number, count: number): void;
+    /**
+     * Clears the entire DataSeries.
+     * @remarks
+     * Note this does not free memory, WebAssembly/Native memory is released by calling {@link delete}, after which the
+     * DataSeries is no longer usable.
+     *
+     * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
+     */
+    clear(): void;
+    toJSON(excludeData?: boolean): any;
+}