scichart 3.2.532 → 3.2.538

package/Charting/Visuals/RenderableSeries/DrawingProviders/MountainSeriesDrawingProvider.js

@@ -17,7 +17,6 @@ var __extends = (this && this.__extends) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MountainSeriesDrawingProvider = void 0;
 var Deleter_1 = require("../../../../Core/Deleter");
-var SeriesType_1 = require("../../../../types/SeriesType");
 var BrushCache_1 = require("../../../Drawing/BrushCache");
 var Pen2DCache_1 = require("../../../Drawing/Pen2DCache");
 var WebGlRenderContext2D_1 = require("../../../Drawing/WebGlRenderContext2D");
@@ -80,7 +79,7 @@ var MountainSeriesDrawingProvider = /** @class */ (function (_super) {
             this.args.SetLinesPen(strokePen);
         }
         // Paletting per point
-        _super.prototype.applyStrokeFillPaletting.call(this, this.parentSeries.stroke, strokePen, this.parentSeries.fill, fillBrush, this.parentSeries.opacity, true, this.parentSeries.fillLinearGradient !== undefined);
+        _super.prototype.applyStrokeFillPaletting.call(this, this.parentSeries.stroke, strokePen, this.parentSeries.fill, fillBrush, this.parentSeries.opacity, true, this.parentSeries.fillLinearGradient !== undefined, renderPassData);
         var paletteTexture = (_a = this.palettingState.paletteTextureCache) === null || _a === void 0 ? void 0 : _a.value;
         if (paletteTexture) {
             this.args.SetPalette(paletteTexture);
@@ -92,16 +91,19 @@ var MountainSeriesDrawingProvider = /** @class */ (function (_super) {
         var xValues = pointSeries.xValues;
         var xDrawValues = isCategoryAxis ? pointSeries.indexes : xValues;
         var yDrawValues = pointSeries.yValues;
-        var isSplineMountainSeries = this.parentSeries.type === SeriesType_1.ESeriesType.SplineMountainSeries && xValues.size() > 1;
-        if (isSplineMountainSeries) {
-            var rs = this.parentSeries;
-            if (!this.parentSeries.isRunningAnimation) {
-                rs.updateSplineValues();
-            }
-            xDrawValues = rs.xSplineValues;
-            yDrawValues = rs.ySplineValues;
-        }
-        var _c = this.getStartAndCount(isSplineMountainSeries ? undefined : renderPassData, xDrawValues), startIndex = _c.startIndex, count = _c.count;
+        // const isSplineMountainSeries =
+        //     this.parentSeries.type === ESeriesType.SplineMountainSeries && xValues.size() > 1;
+        // if (isSplineMountainSeries) {
+        //     const rs = this.parentSeries as any as ISpline;
+        //     if (!this.parentSeries.isRunningAnimation) {
+        //         rs.updateSplineValues();
+        //     }
+        //     xDrawValues = rs.xSplineValues;
+        //     yDrawValues = rs.ySplineValues;
+        // }
+        var _c = this.getStartAndCount(
+        //isSplineMountainSeries ? undefined : renderPassData,
+        renderPassData, xDrawValues), startIndex = _c.startIndex, count = _c.count;
         this.args.count = count;
         this.args.startIndex = startIndex;
         if (fifoSweeping && fifoCapacity === this.parentSeries.dataSeries.count()) {
@@ -151,6 +153,7 @@ var MountainSeriesDrawingProvider = /** @class */ (function (_super) {
         this.createBrush();
     };
     MountainSeriesDrawingProvider.prototype.createBrush = function () {
+        this.palettingState.requiresUpdate = true;
         var _a = this.parentSeries, fill = _a.fill, opacity = _a.opacity, fillLinearGradient = _a.fillLinearGradient, parentSurface = _a.parentSurface;
         var textureHeightRatio = (parentSurface === null || parentSurface === void 0 ? void 0 : parentSurface.isCopyCanvasSurface)
             ? parentSurface.domCanvas2D.height / SciChartSurfaceBase_1.SciChartSurfaceBase.domMasterCanvas.height
@@ -162,6 +165,7 @@ var MountainSeriesDrawingProvider = /** @class */ (function (_super) {
     };
     MountainSeriesDrawingProvider.prototype.createPen = function () {
         var _a = this.parentSeries, stroke = _a.stroke, strokeThickness = _a.strokeThickness, opacity = _a.opacity, strokeDashArray = _a.strokeDashArray;
+        this.palettingState.requiresUpdate = true;
         return (0, Pen2DCache_1.createPenInCache)(this.strokePenCache, stroke, strokeThickness, opacity, strokeDashArray);
     };
     return MountainSeriesDrawingProvider;

package/Charting/Visuals/RenderableSeries/DrawingProviders/PointMarkerDrawingProvider.js

@@ -54,7 +54,7 @@ var PointMarkerDrawingProvider = /** @class */ (function (_super) {
      * @inheritDoc
      */
     PointMarkerDrawingProvider.prototype.draw = function (renderContext, renderPassData) {
-        var _a;
+        var _a, _b;
         var pointMarker = (_a = this.getProperties(this.parentSeries)) === null || _a === void 0 ? void 0 : _a.pointMarker;
         if (pointMarker === undefined) {
             return;
@@ -75,14 +75,19 @@ var PointMarkerDrawingProvider = /** @class */ (function (_super) {
         var isCategoryAxis = renderPassData.xCoordinateCalculator.isCategoryCoordinateCalculator;
         var xValues = this.xSelector(pointSeries);
         var yValues = this.ySelector(pointSeries);
-        if (this.parentSeries.isSpline) {
-            var spline = this.parentSeries;
-            if (spline.xSplineValues.size() > 0 && spline.ySplineValues.size() > 0) {
-                this.pointMarkerXYValuesFromSpline(xValues.size(), spline.xSplineValues, this.ySplineValuesSelector(spline), spline.interpolationPoints);
-                xValues = this.xAnimationPointMarkerValues;
-                yValues = this.yAnimationPointMarkerValues;
-            }
-        }
+        // if (this.parentSeries.isSpline) {
+        //     const spline = this.parentSeries as any as ISpline;
+        //     if (spline.xSplineValues.size() > 0 && spline.ySplineValues.size() > 0) {
+        //         this.pointMarkerXYValuesFromSpline(
+        //             xValues.size(),
+        //             spline.xSplineValues,
+        //             this.ySplineValuesSelector(spline),
+        //             spline.interpolationPoints
+        //         );
+        //         xValues = this.xAnimationPointMarkerValues;
+        //         yValues = this.yAnimationPointMarkerValues;
+        //     }
+        // }
         this.args.Reset();
         this.args.verticalChart = renderPassData.isVerticalChart;
         this.args.forceShaderMethod = true;
@@ -90,7 +95,7 @@ var PointMarkerDrawingProvider = /** @class */ (function (_super) {
         if (strokeMaskTexture) {
             this.args.SetStrokeMask(strokeMaskTexture.getTexture());
         }
-        var _b = this.parentSeries.dataSeries, fifoCapacity = _b.fifoCapacity, fifoSweeping = _b.fifoSweeping, fifoSweepingGap = _b.fifoSweepingGap;
+        var _c = this.parentSeries.dataSeries, fifoCapacity = _c.fifoCapacity, fifoSweeping = _c.fifoSweeping, fifoSweepingGap = _c.fifoSweepingGap;
         var fifoStartIndex = pointSeries.fifoStartIndex;
         if (pointMarker.lastPointOnly && yValues.size() > 0) {
             this.args.count = 1;
@@ -100,7 +105,7 @@ var PointMarkerDrawingProvider = /** @class */ (function (_super) {
                     : yValues.size() - 1;
         }
         else {
-            var _c = this.getStartAndCount(renderPassData, xValues), startIndex = _c.startIndex, count = _c.count;
+            var _d = this.getStartAndCount(renderPassData, xValues), startIndex = _d.startIndex, count = _d.count;
             this.args.count = count;
             this.args.startIndex = startIndex;
             if (fifoSweeping && fifoCapacity === this.parentSeries.dataSeries.count()) {
@@ -110,6 +115,7 @@ var PointMarkerDrawingProvider = /** @class */ (function (_super) {
         // Paletting per point
         this.applyStrokeFillPaletting(pointMarker.stroke, undefined, pointMarker.fill, undefined, this.parentSeries.opacity);
         this.args.SetPalettedColors(this.palettingState.palettedColors);
+        this.args.paletteStart = (_b = this.palettingState.paletteStartIndex) !== null && _b !== void 0 ? _b : 0;
         var nativeContext = renderContext.getNativeContext();
         this.drawPoints(nativeContext, isCategoryAxis ? pointSeries.indexes : xValues, yValues, renderPassData.xCoordinateCalculator.nativeCalculator, renderPassData.yCoordinateCalculator.nativeCalculator, this.args, this.parentSeries.parentSurface.seriesViewRect);
         if (fifoSweeping && fifoCapacity === this.parentSeries.dataSeries.count() && !pointMarker.lastPointOnly) {

package/Charting/Visuals/RenderableSeries/FastErrorBarsRenderableSeries.js

@@ -286,7 +286,7 @@ var FastErrorBarsRenderableSeries = /** @class */ (function (_super) {
         var dataSeriesValueType = this.isRunningDataAnimation
             ? IDataSeries_1.EDataSeriesValueType.FinalAnimationValues
             : IDataSeries_1.EDataSeriesValueType.Default;
-        var range = this.dataSeries.getWindowedYRange(xVisibleRange, true, isXCategoryAxis, dataSeriesValueType, isHorizontalDirection, hasHighCap, hasLowCap);
+        var range = this.dataSeries.getWindowedYRange(xVisibleRange, true, isXCategoryAxis, dataSeriesValueType, this.yRangeMode, isHorizontalDirection, hasHighCap, hasLowCap);
         // Not sure how to adjust this sensibly without having the dataPointWidth in pixels.  Not sure if we can reliably get a valid coordCacluator
         if (this.yAxis.type === AxisType_1.EAxisType.LogarithmicAxis)
             return range;

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

@@ -56,6 +56,7 @@ var createHitTestInfo = function (renderableSeries, xCoordinateCalculator, yCoor
         hitTestInfo.yValue = yValue;
         var xFirstValue = isCategoryAxis ? 0 : xNativeValues.get(0);
         var xLastValue = isCategoryAxis ? xNativeValues.size() - 1 : xNativeValues.get(xNativeValues.size() - 1);
+        // TODO - do this once when data changes
         if (!dataSeries.dataDistributionCalculator.isSortedAscending) {
             for (var i = 0; i < dataSeries.count(); i++) {
                 if (xNativeValues.get(i) < xFirstValue) {

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

@@ -8,6 +8,7 @@ import { SeriesAnimation } from "./Animations/SeriesAnimation";
 import { IRenderableSeries } from "./IRenderableSeries";
 import { ShaderEffect } from "./ShaderEffect";
 import { BaseDataLabelProvider } from "./DataLabels/BaseDataLabelProvider";
+import { EYRangeMode } from "../../../types/YRangeMode";
 /**
  * The type of the {@link IBaseRenderableSeriesOptions.onIsVisibleChanged } callback
  */
@@ -185,4 +186,6 @@ export interface IBaseRenderableSeriesOptions {
      * This is only really relevant if you are using Stacked Y Axes and do not want the series to be drawn outside that axis range
      */
     clipToYRange?: boolean;
+    /** 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;
 }

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/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;