scichart 3.2.528 → 3.2.538

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

@@ -28,6 +28,7 @@ import { SeriesHoveredArgs } from "./SeriesHoveredArgs";
 import { SeriesSelectedArgs } from "./SeriesSelectedArgs";
 import { SeriesVisibleChangedArgs } from "./SeriesVisibleChangedArgs";
 import { BaseDataLabelProvider } from "./DataLabels/BaseDataLabelProvider";
+import { EYRangeMode } from "../../../types/YRangeMode";
 /**
  * @summary Defines the interface to a Render Series (or Chart Type) in SciChart's High Performance Real-time
  * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
@@ -251,6 +252,8 @@ export interface IRenderableSeries extends IDeletable, IThemeable, INotifyOnDpiC
      * Gets or sets the {@link BaseDataLabelProvider} used for creating and drawing per-point text
      */
     dataLabelProvider: BaseDataLabelProvider;
+    /** Determines whether the y range for this series should consider only the visible data (the default), or include the drawn points just outside the visible range */
+    yRangeMode: EYRangeMode;
     /**
      * Called when the {@link BaseRenderableSeries} must be drawn
      * @param renderContext The {@link WebGL2RenderingContext} with methods for drawing on the WebGL Canvas via our WebAssembly Rendering Engine
@@ -285,11 +288,11 @@ export interface IRenderableSeries extends IDeletable, IThemeable, INotifyOnDpiC
      */
     hasStrokePaletteProvider(): boolean;
     /**
-     * Returns true if the {@link BaseRenderableSeries} has an {@ IFillPaletteProvider }
+     * Returns true if the {@link BaseRenderableSeries} has an {@link IFillPaletteProvider }
      */
     hasFillPaletteProvider(): boolean;
     /**
-     * Returns true if the {@link BaseRenderableSeries} has an {@ IPointMarkerPaletteProvider}
+     * Returns true if the {@link BaseRenderableSeries} has an {@link IPointMarkerPaletteProvider}
      */
     hasPointMarkerPaletteProvider(): boolean;
     /**

package/Charting/Visuals/RenderableSeries/RenderDataTransforms/BaseRenderDataTransform.d.ts

@@ -0,0 +1,30 @@
+import { DeletableEntity } from "../../../../Core/DeletableEntity";
+import { IDeletable } from "../../../../Core/IDeletable";
+import { IDataChangeArgs } from "../../../Model/IDataSeries";
+import { BasePointSeriesResampled } from "../../../Model/PointSeries/BasePointSeriesResampled";
+import { IPointSeries } from "../../../Model/PointSeries/IPointSeries";
+import { RenderPassData } from "../../../Services/RenderPassData";
+import { TSciChart } from "../../SciChartSurface";
+import { BaseRenderableSeries } from "../BaseRenderableSeries";
+import { ISeriesDrawingProvider } from "../DrawingProviders/ISeriesDrawingProvider";
+export interface IRenderDataTransform extends IDeletable {
+    readonly parentSeries: BaseRenderableSeries;
+    requiresTransform: boolean;
+    drawingProviders: Array<ISeriesDrawingProvider>;
+    runTransform(renderPassData: RenderPassData): RenderPassData;
+    onDataChange(args: IDataChangeArgs): void;
+}
+export declare abstract class BaseRenderDataTransform<T extends BasePointSeriesResampled> extends DeletableEntity implements IRenderDataTransform {
+    protected wasmContext: TSciChart;
+    readonly parentSeries: BaseRenderableSeries;
+    readonly drawingProviders: Array<ISeriesDrawingProvider>;
+    protected pointSeries: T;
+    requiresTransform: boolean;
+    constructor(parentSeries: BaseRenderableSeries, wasmContext: TSciChart, drawingProviders?: Array<ISeriesDrawingProvider>);
+    runTransform(renderPassData: RenderPassData): RenderPassData;
+    onDataChange(args: IDataChangeArgs): void;
+    delete(): void;
+    protected makeRenderPassData(originalRPD: RenderPassData, pointSeries: IPointSeries): RenderPassData;
+    protected abstract createPointSeries(): T;
+    protected abstract runTransformInternal(renderPassData: RenderPassData): IPointSeries;
+}

package/Charting/Visuals/RenderableSeries/RenderDataTransforms/BaseRenderDataTransform.js

@@ -0,0 +1,63 @@
+"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.BaseRenderDataTransform = void 0;
+var DeletableEntity_1 = require("../../../../Core/DeletableEntity");
+var Deleter_1 = require("../../../../Core/Deleter");
+var Guard_1 = require("../../../../Core/Guard");
+var NumberRange_1 = require("../../../../Core/NumberRange");
+var RenderPassData_1 = require("../../../Services/RenderPassData");
+var BaseRenderDataTransform = /** @class */ (function (_super) {
+    __extends(BaseRenderDataTransform, _super);
+    function BaseRenderDataTransform(parentSeries, wasmContext, drawingProviders) {
+        var _this = _super.call(this) || this;
+        _this.requiresTransform = true;
+        _this.parentSeries = parentSeries;
+        _this.wasmContext = wasmContext;
+        _this.parentSeries.dataSeries;
+        _this.pointSeries = _this.createPointSeries();
+        _this.drawingProviders = drawingProviders !== null && drawingProviders !== void 0 ? drawingProviders : [];
+        return _this;
+    }
+    BaseRenderDataTransform.prototype.runTransform = function (renderPassData) {
+        if (this.requiresTransform) {
+            Guard_1.Guard.notNull(renderPassData, "renderPassData");
+            Guard_1.Guard.notNull(renderPassData.pointSeries, "renderPassData.pointSeries");
+            var ps = this.runTransformInternal(renderPassData);
+            if (ps === this.pointSeries) {
+                this.requiresTransform = false;
+            }
+            return this.makeRenderPassData(renderPassData, ps);
+        }
+        return this.makeRenderPassData(renderPassData, this.pointSeries);
+    };
+    BaseRenderDataTransform.prototype.onDataChange = function (args) {
+        this.requiresTransform = true;
+    };
+    BaseRenderDataTransform.prototype.delete = function () {
+        this.pointSeries = (0, Deleter_1.deleteSafe)(this.pointSeries);
+        this.wasmContext = undefined;
+    };
+    BaseRenderDataTransform.prototype.makeRenderPassData = function (originalRPD, pointSeries) {
+        var indexRange = new NumberRange_1.NumberRange(0, pointSeries.xValues.size() - 1);
+        pointSeries.xRange = originalRPD.pointSeries.xRange;
+        pointSeries.fifoStartIndex = originalRPD.pointSeries.fifoStartIndex;
+        return new RenderPassData_1.RenderPassData(indexRange, originalRPD.getxCoordinateCalculator, originalRPD.getyCoordinateCalculator, originalRPD.isVerticalChart, pointSeries, originalRPD.resamplingHash);
+    };
+    return BaseRenderDataTransform;
+}(DeletableEntity_1.DeletableEntity));
+exports.BaseRenderDataTransform = BaseRenderDataTransform;

package/Charting/Visuals/RenderableSeries/RenderDataTransforms/SplineRenderDataTransform.d.ts

@@ -0,0 +1,10 @@
+import { IPointSeries } from "../../../Model/PointSeries/IPointSeries";
+import { XyPointSeriesResampled } from "../../../Model/PointSeries/XyPointSeriesResampled";
+import { RenderPassData } from "../../../Services/RenderPassData";
+import { BaseRenderDataTransform } from "./BaseRenderDataTransform";
+export declare class SplineRenderDataTransform extends BaseRenderDataTransform<XyPointSeriesResampled> {
+    interpolationPoints: number;
+    warnOnSplineFailure: boolean;
+    protected createPointSeries(): XyPointSeriesResampled;
+    protected runTransformInternal(renderPassData: RenderPassData): IPointSeries;
+}

package/Charting/Visuals/RenderableSeries/RenderDataTransforms/SplineRenderDataTransform.js

@@ -0,0 +1,53 @@
+"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.SplineRenderDataTransform = void 0;
+var NumberRange_1 = require("../../../../Core/NumberRange");
+var XyPointSeriesResampled_1 = require("../../../Model/PointSeries/XyPointSeriesResampled");
+var BaseRenderDataTransform_1 = require("./BaseRenderDataTransform");
+var SplineRenderDataTransform = /** @class */ (function (_super) {
+    __extends(SplineRenderDataTransform, _super);
+    function SplineRenderDataTransform() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.interpolationPoints = 10;
+        _this.warnOnSplineFailure = true;
+        return _this;
+    }
+    SplineRenderDataTransform.prototype.createPointSeries = function () {
+        return new XyPointSeriesResampled_1.XyPointSeriesResampled(this.wasmContext, new NumberRange_1.NumberRange(0, 0));
+    };
+    SplineRenderDataTransform.prototype.runTransformInternal = function (renderPassData) {
+        var xValues = this.parentSeries.xAxis.isCategoryAxis
+            ? renderPassData.pointSeries.indexes
+            : renderPassData.pointSeries.xValues;
+        var yValues = renderPassData.pointSeries.yValues;
+        var initialSize = xValues.size();
+        var containsNaN = this.parentSeries.dataSeries.dataDistributionCalculator.containsNaN;
+        this.wasmContext.SCRTSplineHelperCubicSpline(xValues, yValues, this.pointSeries.xValues, this.pointSeries.yValues, initialSize, this.interpolationPoints, this.parentSeries.dataSeries.dataDistributionCalculator.containsNaN);
+        if (!containsNaN && isNaN(this.pointSeries.yValues.get(0))) {
+            if (this.warnOnSplineFailure) {
+                console.warn("Could not calculate spline values.  X data may contain duplicates.  Falling back to original values.\n    To disable this warning set warnOnSplineFailure = false.");
+            }
+            return renderPassData.pointSeries;
+        }
+        else {
+            return this.pointSeries;
+        }
+    };
+    return SplineRenderDataTransform;
+}(BaseRenderDataTransform_1.BaseRenderDataTransform));
+exports.SplineRenderDataTransform = SplineRenderDataTransform;

package/Charting/Visuals/RenderableSeries/RenderDataTransforms/XyySplineRenderDataTransform.d.ts

@@ -0,0 +1,10 @@
+import { IPointSeries } from "../../../Model/PointSeries/IPointSeries";
+import { XyyPointSeriesResampled } from "../../../Model/PointSeries/XyyPointSeriesResampled";
+import { RenderPassData } from "../../../Services/RenderPassData";
+import { BaseRenderDataTransform } from "./BaseRenderDataTransform";
+export declare class XyySplineRenderDataTransform extends BaseRenderDataTransform<XyyPointSeriesResampled> {
+    interpolationPoints: number;
+    warnOnSplineFailure: boolean;
+    protected createPointSeries(): XyyPointSeriesResampled;
+    protected runTransformInternal(renderPassData: RenderPassData): IPointSeries;
+}

package/Charting/Visuals/RenderableSeries/RenderDataTransforms/XyySplineRenderDataTransform.js

@@ -0,0 +1,55 @@
+"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.XyySplineRenderDataTransform = void 0;
+var NumberRange_1 = require("../../../../Core/NumberRange");
+var XyyPointSeriesResampled_1 = require("../../../Model/PointSeries/XyyPointSeriesResampled");
+var BaseRenderDataTransform_1 = require("./BaseRenderDataTransform");
+var XyySplineRenderDataTransform = /** @class */ (function (_super) {
+    __extends(XyySplineRenderDataTransform, _super);
+    function XyySplineRenderDataTransform() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.interpolationPoints = 10;
+        _this.warnOnSplineFailure = true;
+        return _this;
+    }
+    XyySplineRenderDataTransform.prototype.createPointSeries = function () {
+        return new XyyPointSeriesResampled_1.XyyPointSeriesResampled(this.wasmContext, new NumberRange_1.NumberRange(0, 0));
+    };
+    XyySplineRenderDataTransform.prototype.runTransformInternal = function (renderPassData) {
+        var xValues = this.parentSeries.xAxis.isCategoryAxis
+            ? renderPassData.pointSeries.indexes
+            : renderPassData.pointSeries.xValues;
+        var yValues = renderPassData.pointSeries.yValues;
+        var y1Values = renderPassData.pointSeries.y1Values;
+        var initialSize = xValues.size();
+        var containsNaN = this.parentSeries.dataSeries.dataDistributionCalculator.containsNaN;
+        this.wasmContext.SCRTSplineHelperCubicSpline(xValues, yValues, this.pointSeries.xValues, this.pointSeries.yValues, initialSize, this.interpolationPoints, containsNaN);
+        if (!containsNaN && isNaN(this.pointSeries.yValues.get(0))) {
+            if (this.warnOnSplineFailure) {
+                console.warn("Could not calculate spline values.  X data may contain duplicates.  Falling back to original values.\n    To disable this warning set warnOnSplineFailure = false.");
+            }
+            return renderPassData.pointSeries;
+        }
+        else {
+            this.wasmContext.SCRTSplineHelperCubicSpline(xValues, y1Values, this.pointSeries.xValues, this.pointSeries.y1Values, initialSize, this.interpolationPoints, containsNaN);
+            return this.pointSeries;
+        }
+    };
+    return XyySplineRenderDataTransform;
+}(BaseRenderDataTransform_1.BaseRenderDataTransform));
+exports.XyySplineRenderDataTransform = XyySplineRenderDataTransform;

package/Charting/Visuals/RenderableSeries/RolloverModifier/RolloverModifierRenderableSeriesProps.js

@@ -143,9 +143,11 @@ var RolloverModifierRenderableSeriesProps = /** @class */ (function () {
         if (!((_a = this.marker) === null || _a === void 0 ? void 0 : _a.isDeleted)) {
             this.marker = (0, Deleter_1.deleteSafe)(this.marker);
         }
+        this.marker = undefined;
         if (!((_b = this.tooltip) === null || _b === void 0 ? void 0 : _b.isDeleted)) {
             this.tooltip = (0, Deleter_1.deleteSafe)(this.tooltip);
         }
+        this.tooltip = undefined;
     };
     RolloverModifierRenderableSeriesProps.prototype.notifyPropertyChanged = function (propertyName) {
         if (this.invalidateParentCallback) {

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

@@ -40,13 +40,9 @@ export interface ISplineBandRenderableSeriesOptions extends IBaseBandRenderableS
  */
 export declare class SplineBandRenderableSeries extends BaseBandRenderableSeries implements ISpline {
     readonly type = ESeriesType.SplineBandSeries;
-    xSplineValues: SCRTDoubleVector;
-    ySplineValues: SCRTDoubleVector;
-    y1SplineValues: SCRTDoubleVector;
-    warnOnSplineFailure: boolean;
     protected isSplineProperty: boolean;
-    private recalculateSpline;
     private interpolationPointsProperty;
+    private splineRenderPassData;
     /**
      * Creates an instance of the {@link SplineBandRenderableSeries}
      * @param webAssemblyContext The {@link TSciChart | SciChart WebAssembly Context} containing
@@ -63,13 +59,24 @@ export declare class SplineBandRenderableSeries extends BaseBandRenderableSeries
      * Gets or sets the interpolationPoints being used for the Spline
      */
     set interpolationPoints(value: number);
+    get xSplineValues(): SCRTDoubleVector;
+    get ySplineValues(): SCRTDoubleVector;
+    get y1SplineValues(): SCRTDoubleVector;
     /** @inheritDoc */
     delete(): void;
+    /**
+     * Set false to disable the warning if the spline cannot be calculated
+     */
+    get warnOnSplineFailure(): boolean;
+    /**
+     * Set false to disable the warning if the spline cannot be calculated
+     */
+    set warnOnSplineFailure(value: boolean);
     /**
      * Updates spline values
      */
     updateSplineValues(): void;
-    /** @inheritDoc */
+    /** @deprecated This is now handled within the renderDataTransform */
     onSplineFailure(): void;
     /** @inheritDoc */
     getYRange(xVisibleRange: NumberRange, isXCategoryAxis?: boolean): NumberRange;
@@ -79,6 +86,4 @@ export declare class SplineBandRenderableSeries extends BaseBandRenderableSeries
     protected setAnimationVectors(animation: SeriesAnimation): void;
     /** @inheritDoc */
     protected updateAnimationProperties(progress: number, animationFSM: SeriesAnimationFiniteStateMachine): void;
-    /** @inheritDoc */
-    protected dataSeriesDataChanged(): void;
 }

package/Charting/Visuals/RenderableSeries/SplineBandRenderableSeries.js

@@ -19,12 +19,15 @@ exports.SplineBandRenderableSeries = void 0;
 var Deleter_1 = require("../../../Core/Deleter");
 var NumberRange_1 = require("../../../Core/NumberRange");
 var SeriesType_1 = require("../../../types/SeriesType");
-var copyVector_1 = require("../../../utils/copyVector");
 var isRealNumber_1 = require("../../../utils/isRealNumber");
 var BaseDataSeries_1 = require("../../Model/BaseDataSeries");
+var IDataSeries_1 = require("../../Model/IDataSeries");
+var XyyPointSeriesWrapped_1 = require("../../Model/PointSeries/XyyPointSeriesWrapped");
+var RenderPassData_1 = require("../../Services/RenderPassData");
 var animationHelpers_1 = require("./Animations/animationHelpers");
 var BaseBandRenderableSeries_1 = require("./BaseBandRenderableSeries");
 var constants_1 = require("./constants");
+var XyySplineRenderDataTransform_1 = require("./RenderDataTransforms/XyySplineRenderDataTransform");
 /**
  * Defines a JavaScript Spline Band-series or High-Low polygon fill chart type in the SciChart's High Performance Real-time
  * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
@@ -61,14 +64,13 @@ var SplineBandRenderableSeries = /** @class */ (function (_super) {
         var _a, _b, _c;
         _this = _super.call(this, webAssemblyContext, options) || this;
         _this.type = SeriesType_1.ESeriesType.SplineBandSeries;
-        _this.warnOnSplineFailure = true;
         _this.isSplineProperty = true;
-        _this.recalculateSpline = true;
         _this.interpolationPointsProperty = 10;
-        _this.xSplineValues = new webAssemblyContext.SCRTDoubleVector();
-        _this.ySplineValues = new webAssemblyContext.SCRTDoubleVector();
-        _this.y1SplineValues = new webAssemblyContext.SCRTDoubleVector();
         _this.interpolationPointsProperty = (_a = options === null || options === void 0 ? void 0 : options.interpolationPoints) !== null && _a !== void 0 ? _a : _this.interpolationPointsProperty;
+        _this.renderDataTransform = new XyySplineRenderDataTransform_1.XyySplineRenderDataTransform(_this, webAssemblyContext, [
+            _this.drawingProviders[0]
+        ]);
+        _this.renderDataTransform.interpolationPoints = _this.interpolationPoints;
         // Must be called here for the series type to be available
         if ((_b = _this.paletteProvider) === null || _b === void 0 ? void 0 : _b.onAttached) {
             (_c = _this.paletteProvider) === null || _c === void 0 ? void 0 : _c.onAttached(_this);
@@ -94,63 +96,83 @@ var SplineBandRenderableSeries = /** @class */ (function (_super) {
          */
         set: function (value) {
             this.interpolationPointsProperty = value;
+            this.renderDataTransform.interpolationPoints = this.interpolationPoints;
+            this.renderDataTransform.requiresTransform = true;
             this.notifyPropertyChanged(constants_1.PROPERTY.INTERPOLATION_POINTS);
         },
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(SplineBandRenderableSeries.prototype, "xSplineValues", {
+        get: function () {
+            if (!this.splineRenderPassData) {
+                throw Error("Spline values are not available until after first render, or call updateSplineValues");
+            }
+            return this.splineRenderPassData.pointSeries.xValues;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SplineBandRenderableSeries.prototype, "ySplineValues", {
+        get: function () {
+            if (!this.splineRenderPassData) {
+                throw Error("Spline values are not available until after first render, or call updateSplineValues");
+            }
+            return this.splineRenderPassData.pointSeries.yValues;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SplineBandRenderableSeries.prototype, "y1SplineValues", {
+        get: function () {
+            if (!this.splineRenderPassData) {
+                throw Error("Spline values are not available until after first render, or call updateSplineValues");
+            }
+            return this.splineRenderPassData.pointSeries.y1Values;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /** @inheritDoc */
     SplineBandRenderableSeries.prototype.delete = function () {
-        this.xSplineValues = (0, Deleter_1.deleteSafe)(this.xSplineValues);
-        this.ySplineValues = (0, Deleter_1.deleteSafe)(this.ySplineValues);
-        this.y1SplineValues = (0, Deleter_1.deleteSafe)(this.y1SplineValues);
         _super.prototype.delete.call(this);
     };
+    Object.defineProperty(SplineBandRenderableSeries.prototype, "warnOnSplineFailure", {
+        /**
+         * Set false to disable the warning if the spline cannot be calculated
+         */
+        get: function () {
+            return this.renderDataTransform.warnOnSplineFailure;
+        },
+        /**
+         * Set false to disable the warning if the spline cannot be calculated
+         */
+        set: function (value) {
+            this.renderDataTransform.warnOnSplineFailure = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Updates spline values
      */
     SplineBandRenderableSeries.prototype.updateSplineValues = function () {
-        if (!(this.dataSeries && this.recalculateSpline && this.parentSurface)) {
+        if (!this.dataSeries || !this.parentSurface) {
             return;
         }
-        this.isSplineProperty = true;
-        var dataSeries = this.dataSeries;
-        if (dataSeries.fifoCapacity) {
-            throw new Error("Sorry, fifo is not currently supported for spline series");
-        }
-        var xValues = this.xAxis.isCategoryAxis ? dataSeries.getNativeIndexes() : dataSeries.getNativeXValues();
-        var yValues = dataSeries.getNativeYValues();
-        var y1Values = dataSeries.getNativeY1Values();
-        var initialSize = xValues.size();
-        this.webAssemblyContext.SCRTSplineHelperCubicSpline(xValues, yValues, this.xSplineValues, this.ySplineValues, initialSize, this.interpolationPoints, dataSeries.dataDistributionCalculator.containsNaN);
-        if (isNaN(this.ySplineValues.get(0))) {
-            this.onSplineFailure();
+        if (!this.currentRenderPassData) {
+            this.currentRenderPassData = new RenderPassData_1.RenderPassData(this.getIndicesRange(this.xAxis.visibleRange, this.xAxis.isCategoryAxis), this.xAxis.getCurrentCoordinateCalculator, this.yAxis.getCurrentCoordinateCalculator, this.xAxis.isVerticalChart, new XyyPointSeriesWrapped_1.XyyPointSeriesWrapped(this.dataSeries));
         }
-        else {
-            this.webAssemblyContext.SCRTSplineHelperCubicSpline(xValues, y1Values, this.xSplineValues, this.y1SplineValues, initialSize, this.interpolationPoints, dataSeries.dataDistributionCalculator.containsNaN);
-        }
-        this.recalculateSpline = false;
-    };
-    /** @inheritDoc */
-    SplineBandRenderableSeries.prototype.onSplineFailure = function () {
-        if (this.warnOnSplineFailure) {
-            console.warn("Could not calculate spline values.  X data may contain duplicates.  Falling back to original values.\nTo disable this warning set warnOnSplineFailure = false.  To change this behaviour, override onSplineFailure");
-        }
-        var xValues = this.xAxis.isCategoryAxis
-            ? this.dataSeries.getNativeIndexes()
-            : this.dataSeries.getNativeXValues();
-        (0, copyVector_1.copyDoubleVector)(xValues, this.xSplineValues, this.webAssemblyContext);
-        (0, copyVector_1.copyDoubleVector)(this.dataSeries.getNativeYValues(), this.ySplineValues, this.webAssemblyContext);
-        (0, copyVector_1.copyDoubleVector)(this.dataSeries.getNativeY1Values(), this.y1SplineValues, this.webAssemblyContext);
-        // This tells the drawing providers not to treat the data as interpolated
-        this.isSplineProperty = false;
+        this.splineRenderPassData = this.renderDataTransform.runTransform(this.currentRenderPassData);
     };
+    /** @deprecated This is now handled within the renderDataTransform */
+    SplineBandRenderableSeries.prototype.onSplineFailure = function () { };
     /** @inheritDoc */
     SplineBandRenderableSeries.prototype.getYRange = function (xVisibleRange, isXCategoryAxis) {
         var _a;
         if (isXCategoryAxis === void 0) { isXCategoryAxis = false; }
         if (this.isRunningAnimation) {
-            return this.dataSeries.getWindowedYRange(xVisibleRange, true, isXCategoryAxis);
+            return this.dataSeries.getWindowedYRange(xVisibleRange, true, isXCategoryAxis, IDataSeries_1.EDataSeriesValueType.Default, this.yRangeMode);
         }
         this.updateSplineValues();
         var xValues = this.xSplineValues;
@@ -220,11 +242,6 @@ var SplineBandRenderableSeries = /** @class */ (function (_super) {
             this.invalidateParentCallback();
         }
     };
-    /** @inheritDoc */
-    SplineBandRenderableSeries.prototype.dataSeriesDataChanged = function () {
-        this.recalculateSpline = true;
-        _super.prototype.dataSeriesDataChanged.call(this);
-    };
     return SplineBandRenderableSeries;
 }(BaseBandRenderableSeries_1.BaseBandRenderableSeries));
 exports.SplineBandRenderableSeries = SplineBandRenderableSeries;

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

@@ -4,7 +4,6 @@ import { ESeriesType } from "../../../types/SeriesType";
 import { SCRTDoubleVector, TSciChart } from "../../../types/TSciChart";
 import { SeriesAnimation } from "./Animations/SeriesAnimation";
 import { BaseLineRenderableSeries, IBaseLineRenderableSeriesOptions } from "./BaseLineRenderableSeries";
-import { TPalettingState } from "./DrawingProviders/BaseSeriesDrawingProvider";
 import { ISpline } from "./ISpline";
 export interface ISplineLineRenderableSeriesOptions extends IBaseLineRenderableSeriesOptions {
     /**
@@ -36,12 +35,9 @@ export interface ISplineLineRenderableSeriesOptions extends IBaseLineRenderableS
  */
 export declare class SplineLineRenderableSeries extends BaseLineRenderableSeries implements ISpline {
     readonly type = ESeriesType.SplineLineSeries;
-    xSplineValues: SCRTDoubleVector;
-    ySplineValues: SCRTDoubleVector;
-    warnOnSplineFailure: boolean;
     protected isSplineProperty: boolean;
     private interpolationPointsProperty;
-    private recalculateSpline;
+    private splineRenderPassData;
     /**
      * Creates an instance of the {@link SplineLineRenderableSeries}
      * @param webAssemblyContext The {@link TSciChart | SciChart WebAssembly Context} containing
@@ -49,6 +45,8 @@ export declare class SplineLineRenderableSeries extends BaseLineRenderableSeries
      * @param options optional parameters of type {@link ISplineLineRenderableSeriesOptions} applied when constructing the series type
      */
     constructor(webAssemblyContext: TSciChart, options?: ISplineLineRenderableSeriesOptions);
+    get xSplineValues(): SCRTDoubleVector;
+    get ySplineValues(): SCRTDoubleVector;
     get isSpline(): boolean;
     /**
      * Gets or sets the interpolationPoints being used for the Spline
@@ -58,27 +56,28 @@ export declare class SplineLineRenderableSeries extends BaseLineRenderableSeries
      * Gets or sets the interpolationPoints being used for the Spline
      */
     set interpolationPoints(value: number);
+    /**
+     * Set false to disable the warning if the spline cannot be calculated
+     */
+    get warnOnSplineFailure(): boolean;
+    /**
+     * Set false to disable the warning if the spline cannot be calculated
+     */
+    set warnOnSplineFailure(value: boolean);
     /** @inheritDoc */
     delete(): void;
     /**
      * Updates spline values
      */
     updateSplineValues(): void;
-    /** @inheritDoc */
+    /** @deprecated This is now handled within the renderDataTransform */
     onSplineFailure(): void;
     /** @inheritDoc */
     getYRange(xVisibleRange: NumberRange, isXCategoryAxis?: boolean): NumberRange;
     /** @inheritDoc */
     toJSON(excludeData?: boolean): import("../../..").TSeriesDefinition;
-    /**
-     * @param color The color for palette
-     * @param palettingState The palleting state
-     */
-    pushPalettedColors(color: number, palettingState: TPalettingState): void;
     /** @inheritDoc */
     protected setAnimationVectors(animation: SeriesAnimation): void;
     /** @inheritDoc */
     protected updateAnimationProperties(progress: number, animationFSM: SeriesAnimationFiniteStateMachine): void;
-    /** @inheritDoc */
-    protected dataSeriesDataChanged(): void;
 }