scichart 3.1.348 → 3.2.0-beta

package/Charting/Model/XyzDataSeries.js

@@ -48,13 +48,16 @@ var XyzDataSeries = /** @class */ (function (_super) {
         var _this = _super.call(this, webAssemblyContext, options) || this;
         /** @inheritDoc */
         _this.type = IDataSeries_1.EDataSeriesType.Xyz;
-        _this.zValues = new webAssemblyContext.SCRTDoubleVector();
-        _this.zInitialAnimationValues = new webAssemblyContext.SCRTDoubleVector();
-        _this.zFinalAnimationValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.zValues = _this.doubleVectorProvider.getDoubleVector(webAssemblyContext);
         if (options === null || options === void 0 ? void 0 : options.xValues) {
             Guard_1.Guard.notNull(options.yValues, "options.yValues");
             Guard_1.Guard.notNull(options.zValues, "options.zValues");
             _this.appendRange(options.xValues, options.yValues, options.zValues, options.metadata);
+            if ((options === null || options === void 0 ? void 0 : options.fifoCapacity) && (options === null || options === void 0 ? void 0 : options.fifoStartIndex)) {
+                _this.xValues.notifyAppend(options === null || options === void 0 ? void 0 : options.fifoStartIndex);
+                _this.yValues.notifyAppend(options === null || options === void 0 ? void 0 : options.fifoStartIndex);
+                _this.zValues.notifyAppend(options === null || options === void 0 ? void 0 : options.fifoStartIndex);
+            }
         }
         return _this;
     }
@@ -118,9 +121,9 @@ var XyzDataSeries = /** @class */ (function (_super) {
             this.dataDistributionCalculator.onAppend(this.isSorted, this.containsNaN, nativeX, xValues, yValues);
             // Push metadata should be done before push x values
             this.appendMetadataRange(metadata, xValues.length);
-            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeX, xValues);
-            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeY, yValues);
-            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeZ, zValues);
+            this.doubleVectorProvider.appendArray(this.webAssemblyContext, nativeX, xValues);
+            this.doubleVectorProvider.appendArray(this.webAssemblyContext, nativeY, yValues);
+            this.doubleVectorProvider.appendArray(this.webAssemblyContext, nativeZ, zValues);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Append, null, xValues.length);
         }
     };
@@ -178,6 +181,7 @@ var XyzDataSeries = /** @class */ (function (_super) {
     XyzDataSeries.prototype.insert = function (startIndex, x, y, z, metadata) {
         if (!this.getIsDeleted()) {
             this.validateIndex(startIndex, "Start index is out of range");
+            this.throwIfFifo("insert");
             var nativeX = this.getNativeXValues();
             var nativeY = this.getNativeYValues();
             var nativeZ = this.getNativeZValues();
@@ -205,6 +209,7 @@ var XyzDataSeries = /** @class */ (function (_super) {
             Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(yValues) || (0, NumberArray_1.isTypedArray)(yValues), "yValues must be an array of numbers");
             Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(zValues) || (0, NumberArray_1.isTypedArray)(zValues), "zValues must be an array of numbers");
             this.validateIndex(startIndex, "Start index is out of range");
+            this.throwIfFifo("insertRange");
             Guard_1.Guard.arraysSameLengthArr([
                 { arg: xValues, name: "xValues" },
                 { arg: yValues, name: "yValues" },
@@ -231,6 +236,7 @@ var XyzDataSeries = /** @class */ (function (_super) {
     XyzDataSeries.prototype.removeAt = function (index) {
         if (!this.getIsDeleted()) {
             this.validateIndex(index);
+            this.throwIfFifo("removeAt");
             this.getNativeXValues().removeAt(index);
             this.getNativeYValues().removeAt(index);
             this.getNativeZValues().removeAt(index);
@@ -247,6 +253,7 @@ var XyzDataSeries = /** @class */ (function (_super) {
     XyzDataSeries.prototype.removeRange = function (startIndex, count) {
         if (!this.getIsDeleted()) {
             this.validateIndex(startIndex, "Start index is out of range");
+            this.throwIfFifo("removeRange");
             this.getNativeXValues().removeRange(startIndex, count);
             this.getNativeYValues().removeRange(startIndex, count);
             this.getNativeZValues().removeRange(startIndex, count);
@@ -280,6 +287,12 @@ var XyzDataSeries = /** @class */ (function (_super) {
         _super.prototype.delete.call(this);
     };
     /** @inheritDoc */
+    XyzDataSeries.prototype.createAnimationVectors = function () {
+        _super.prototype.createAnimationVectors.call(this);
+        this.zInitialAnimationValues = this.doubleVectorProvider.getDoubleVector(this.webAssemblyContext);
+        this.zFinalAnimationValues = this.doubleVectorProvider.getDoubleVector(this.webAssemblyContext);
+    };
+    /** @inheritDoc */
     XyzDataSeries.prototype.setInitialAnimationVectors = function (dataSeries) {
         _super.prototype.setInitialAnimationVectors.call(this, dataSeries);
         if (!dataSeries) {
@@ -323,10 +336,19 @@ var XyzDataSeries = /** @class */ (function (_super) {
             var xValues = [];
             var yValues = [];
             var zValues = [];
-            for (var i = 0; i < this.count(); i++) {
-                xValues.push(this.xValues.get(i));
-                yValues.push(this.yValues.get(i));
-                zValues.push(this.zValues.get(i));
+            if (this.fifoCapacity && this.fifoSweeping) {
+                for (var i = 0; i < this.count(); i++) {
+                    xValues.push(this.xValues.getRaw(i));
+                    yValues.push(this.yValues.getRaw(i));
+                    zValues.push(this.zValues.getRaw(i));
+                }
+            }
+            else {
+                for (var i = 0; i < this.count(); i++) {
+                    xValues.push(this.xValues.get(i));
+                    yValues.push(this.yValues.get(i));
+                    zValues.push(this.zValues.get(i));
+                }
             }
             var options = {
                 xValues: xValues,
@@ -337,6 +359,10 @@ var XyzDataSeries = /** @class */ (function (_super) {
         }
         return json;
     };
+    XyzDataSeries.prototype.reserve = function (size) {
+        _super.prototype.reserve.call(this, size);
+        this.zValues.reserve(size);
+    };
     XyzDataSeries.prototype.getYZValues = function (dataSeriesValueType) {
         var yValues;
         var zValues;

package/Charting/Numerics/CoordinateCalculators/CategoryCoordinateCalculator.d.ts

@@ -40,13 +40,11 @@ export declare class CategoryCoordinateCalculator extends CoordinateCalculatorBa
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}
      * containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods
      * @param viewportDimension The size of the associated {@link AxisCore | Axis} at the time of drawing
-     * @param visibleMin The minimum data-value visible on the Axis at the time of drawing
-     * @param visibleMax The maximum data-value visible on the Axis at the time of drawing
-     * @param indexMin The {@link CategoryAxis.visibleRange}.min at the time of drawing, corresponding to the minimum data-index visible
-     * @param indexMax The {@link CategoryAxis.visibleRange}.max at the time of drawing, corresponding to the maximum data-index visible
+     * @param visibleMin The {@link CategoryAxis.visibleRange}.min at the time of drawing, corresponding to the minimum data-index visible
+     * @param visibleMax The {@link CategoryAxis.visibleRange}.max at the time of drawing, corresponding to the maximum data-index visible
      * @param offset A constant pixel offset used in coordinate calculations
      */
-    constructor(webAssemblyContext: TSciChart, viewportDimension: number, visibleMin: number, visibleMax: number, indexMin: number, indexMax: number, offset?: number);
+    constructor(webAssemblyContext: TSciChart, viewportDimension: number, visibleMin: number, visibleMax: number, offset?: number);
     /**
      * Transforms an Index to a Data-value, with extrapolation and interpolation for values found outside of
      * {@link baseXValues | the Primary Chart series X-Values}

package/Charting/Numerics/CoordinateCalculators/CategoryCoordinateCalculator.js

@@ -46,17 +46,15 @@ var CategoryCoordinateCalculator = /** @class */ (function (_super) {
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}
      * containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods
      * @param viewportDimension The size of the associated {@link AxisCore | Axis} at the time of drawing
-     * @param visibleMin The minimum data-value visible on the Axis at the time of drawing
-     * @param visibleMax The maximum data-value visible on the Axis at the time of drawing
-     * @param indexMin The {@link CategoryAxis.visibleRange}.min at the time of drawing, corresponding to the minimum data-index visible
-     * @param indexMax The {@link CategoryAxis.visibleRange}.max at the time of drawing, corresponding to the maximum data-index visible
+     * @param visibleMin The {@link CategoryAxis.visibleRange}.min at the time of drawing, corresponding to the minimum data-index visible
+     * @param visibleMax The {@link CategoryAxis.visibleRange}.max at the time of drawing, corresponding to the maximum data-index visible
      * @param offset A constant pixel offset used in coordinate calculations
      */
-    function CategoryCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, indexMin, indexMax, offset) {
+    function CategoryCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset) {
         if (offset === void 0) { offset = 0; }
         var _this = _super.call(this, webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, true, true) || this;
-        _this.indexMin = indexMin;
-        _this.indexMax = indexMax;
+        _this.indexMin = visibleMin;
+        _this.indexMax = visibleMax;
         _this.nativeCalculator = new webAssemblyContext.CategoryCoordinateCalculatorDouble(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset, _this.indexMin, _this.indexMax);
         return _this;
     }

package/Charting/Numerics/CoordinateCalculators/CoordinateCalculatorBase.d.ts

@@ -1,3 +1,4 @@
+import { DeletableEntity } from "../../../Core/DeletableEntity";
 import { IDeletable } from "../../../Core/IDeletable";
 import { NumberRange } from "../../../Core/NumberRange";
 import { CoordinateCalculator, TSciChart } from "../../../types/TSciChart";
@@ -22,7 +23,7 @@ import { TSciChart3D } from "../../../types/TSciChart3D";
  *
  * Use the Coordinate calculators when drawing, placing markers, annotations or if you want to place a tooltip over the chart.
  */
-export declare abstract class CoordinateCalculatorBase implements IDeletable {
+export declare abstract class CoordinateCalculatorBase extends DeletableEntity implements IDeletable {
     /**
      * Gets or sets the Visible minimum value, corresponding to {@link AxisCore.visibleRange}.min at the time of drawing
      */

package/Charting/Numerics/CoordinateCalculators/CoordinateCalculatorBase.js

@@ -1,6 +1,22 @@
 "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.CoordinateCalculatorBase = void 0;
+var DeletableEntity_1 = require("../../../Core/DeletableEntity");
 var NumberRange_1 = require("../../../Core/NumberRange");
 /**
  * The CoordinateCalculatorBase class provides methods for converting between Pixel and Data coordinates
@@ -22,7 +38,8 @@ var NumberRange_1 = require("../../../Core/NumberRange");
  *
  * Use the Coordinate calculators when drawing, placing markers, annotations or if you want to place a tooltip over the chart.
  */
-var CoordinateCalculatorBase = /** @class */ (function () {
+var CoordinateCalculatorBase = /** @class */ (function (_super) {
+    __extends(CoordinateCalculatorBase, _super);
     /**
      * Creates an instance of the CoordinateCalculatorBase
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}
@@ -37,13 +54,15 @@ var CoordinateCalculatorBase = /** @class */ (function () {
      */
     function CoordinateCalculatorBase(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, hasFlippedCoordinates, isCategoryCoordinateCalculator) {
         if (isCategoryCoordinateCalculator === void 0) { isCategoryCoordinateCalculator = false; }
-        this.webAssemblyContext = webAssemblyContext;
-        this.visibleMax = visibleMax;
-        this.visibleMin = visibleMin;
-        this.viewportDimension = viewportDimension;
-        this.offset = offset;
-        this.hasFlippedCoordinates = hasFlippedCoordinates;
-        this.isCategoryCoordinateCalculator = isCategoryCoordinateCalculator;
+        var _this = _super.call(this) || this;
+        _this.webAssemblyContext = webAssemblyContext;
+        _this.visibleMax = visibleMax;
+        _this.visibleMin = visibleMin;
+        _this.viewportDimension = viewportDimension;
+        _this.offset = offset;
+        _this.hasFlippedCoordinates = hasFlippedCoordinates;
+        _this.isCategoryCoordinateCalculator = isCategoryCoordinateCalculator;
+        return _this;
     }
     /**
      * Converts the Data-value to a pixel coordinate
@@ -95,7 +114,8 @@ var CoordinateCalculatorBase = /** @class */ (function () {
         var _a;
         (_a = this.nativeCalculator) === null || _a === void 0 ? void 0 : _a.delete();
         this.nativeCalculator = undefined;
+        this.webAssemblyContext = undefined;
     };
     return CoordinateCalculatorBase;
-}());
+}(DeletableEntity_1.DeletableEntity));
 exports.CoordinateCalculatorBase = CoordinateCalculatorBase;

package/Charting/Numerics/CoordinateCalculators/FlippedCategoryCoordinateCalculator.d.ts

@@ -41,13 +41,11 @@ export declare class FlippedCategoryCoordinateCalculator extends CoordinateCalcu
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}
      * containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods
      * @param viewportDimension The size of the associated {@link AxisCore | Axis} at the time of drawing
-     * @param visibleMin The minimum data-value visible on the Axis at the time of drawing
-     * @param visibleMax The maximum data-value visible on the Axis at the time of drawing
-     * @param indexMin The {@link CategoryAxis.visibleRange}.min at the time of drawing, corresponding to the minimum data-index visible
-     * @param indexMax The {@link CategoryAxis.visibleRange}.max at the time of drawing, corresponding to the maximum data-index visible
+     * @param visibleMin The {@link CategoryAxis.visibleRange}.min at the time of drawing, corresponding to the minimum data-index visible
+     * @param visibleMax The {@link CategoryAxis.visibleRange}.max at the time of drawing, corresponding to the maximum data-index visible
      * @param offset A constant pixel offset used in coordinate calculations
      */
-    constructor(webAssemblyContext: TSciChart, viewportDimension: number, visibleMin: number, visibleMax: number, indexMin: number, indexMax: number, offset?: number);
+    constructor(webAssemblyContext: TSciChart, viewportDimension: number, visibleMin: number, visibleMax: number, offset?: number);
     /**
      * Transforms an Index to a Data-value, with extrapolation and interpolation for values found outside of
      * {@link baseXValues | the Primary Chart series X-Values}

package/Charting/Numerics/CoordinateCalculators/FlippedCategoryCoordinateCalculator.js

@@ -47,17 +47,15 @@ var FlippedCategoryCoordinateCalculator = /** @class */ (function (_super) {
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}
      * containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods
      * @param viewportDimension The size of the associated {@link AxisCore | Axis} at the time of drawing
-     * @param visibleMin The minimum data-value visible on the Axis at the time of drawing
-     * @param visibleMax The maximum data-value visible on the Axis at the time of drawing
-     * @param indexMin The {@link CategoryAxis.visibleRange}.min at the time of drawing, corresponding to the minimum data-index visible
-     * @param indexMax The {@link CategoryAxis.visibleRange}.max at the time of drawing, corresponding to the maximum data-index visible
+     * @param visibleMin The {@link CategoryAxis.visibleRange}.min at the time of drawing, corresponding to the minimum data-index visible
+     * @param visibleMax The {@link CategoryAxis.visibleRange}.max at the time of drawing, corresponding to the maximum data-index visible
      * @param offset A constant pixel offset used in coordinate calculations
      */
-    function FlippedCategoryCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, indexMin, indexMax, offset) {
+    function FlippedCategoryCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset) {
         if (offset === void 0) { offset = 0; }
         var _this = _super.call(this, webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, false, true) || this;
-        _this.indexMin = indexMin;
-        _this.indexMax = indexMax;
+        _this.indexMin = visibleMin;
+        _this.indexMax = visibleMax;
         _this.nativeCalculator = new webAssemblyContext.FlippedCategoryCoordinateCalculatorDouble(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset, _this.indexMin, _this.indexMax);
         return _this;
     }

package/Charting/Numerics/Resamplers/ExtremeResamplerHelper.d.ts

@@ -1,12 +1,14 @@
+import { DeletableEntity } from "../../../Core/DeletableEntity";
 import { IDeletable } from "../../../Core/IDeletable";
-import { IntVector, SCRTDoubleResamplerMergeIndicesParams, SCRTDoubleVector, TSciChart } from "../../../types/TSciChart";
+import { IntVector, ResamplingMode, SCRTDoubleResamplerMergeIndicesParams, SCRTDoubleVector, TSciChart } from "../../../types/TSciChart";
+import { EResamplingMode } from "./ResamplingMode";
 import { ResamplingParams } from "./ResamplingParams";
 /**
  * Helper class for functions which optimise drawing
  */
-export declare class ExtremeResamplerHelper implements IDeletable {
+export declare class ExtremeResamplerHelper extends DeletableEntity implements IDeletable {
     readonly nativeMergeIndexParams: SCRTDoubleResamplerMergeIndicesParams;
-    private readonly wasmContext;
+    private wasmContext;
     private readonly nativeResampler;
     private readonly xInput;
     private readonly nativeArgs;
@@ -36,19 +38,21 @@ export declare class ExtremeResamplerHelper implements IDeletable {
      * you can set it to False if {@link needsResampling()} was called before this method
      * @returns indicesVector The resampled vector of indices
      */
-    resampleIntoPointSeries(wasmContext: TSciChart, rp: ResamplingParams, xOriginalValues: SCRTDoubleVector, yOriginalValues: SCRTDoubleVector, indexesOut: IntVector, xResampledValuesOut: SCRTDoubleVector, yResampledValuesOut: SCRTDoubleVector, fillBasicNativeArgs?: boolean): void;
+    resampleIntoPointSeries(wasmContext: TSciChart, rp: ResamplingParams, xOriginalValues: SCRTDoubleVector, yOriginalValues: SCRTDoubleVector, indexesOut: IntVector, indexesResampledOut: SCRTDoubleVector, xResampledValuesOut: SCRTDoubleVector, yResampledValuesOut: SCRTDoubleVector, fillBasicNativeArgs?: boolean): {
+        OutputSplitIndex: number;
+    };
     mergeIndexes(indices: IntVector, size1: number, size2: number, mergedIndicesOut: IntVector): number;
-    copyValuesByIndexes(indices: IntVector, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, y1Values: SCRTDoubleVector, count: number, isCategoryAxis: boolean, xValuesOut: SCRTDoubleVector, yValuesOut: SCRTDoubleVector, y1ValuesOut: SCRTDoubleVector, y1Offset?: number): void;
+    copyValuesByIndexes(indices: IntVector, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, y1Values: SCRTDoubleVector, count: number, isCategoryAxis: boolean, isFifoSweeping: boolean, indicesOut: SCRTDoubleVector, xValuesOut: SCRTDoubleVector, yValuesOut: SCRTDoubleVector, y1ValuesOut: SCRTDoubleVector, y1Offset?: number): void;
     /** @inheritDoc */
     delete(): void;
+    getNativeResamplingMode(resamplingMode: EResamplingMode): ResamplingMode;
+    /**
+     * Fills basic native args needed for {@link needsResampling()} and {@link resampleIntoPointSeries} methods
+     */
+    resetAndFillBasicNativeArgs(rp: ResamplingParams, xOriginalValues: SCRTDoubleVector): void;
     private debugParameters;
     private debugRect;
     private debugResamplingDataEnum;
     private debugResamplingModeEnum;
     private getDataDistribution;
-    private getNativeResamplingMode;
-    /**
-     * Fills basic native args needed for {@link needsResampling()} and {@link resampleIntoPointSeries} methods
-     */
-    private resetAndFillBasicNativeArgs;
 }

package/Charting/Numerics/Resamplers/ExtremeResamplerHelper.js

@@ -1,21 +1,40 @@
 "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.ExtremeResamplerHelper = void 0;
+var DeletableEntity_1 = require("../../../Core/DeletableEntity");
 var Deleter_1 = require("../../../Core/Deleter");
 var Guard_1 = require("../../../Core/Guard");
 var ResamplingMode_1 = require("./ResamplingMode");
 /**
  * Helper class for functions which optimise drawing
  */
-var ExtremeResamplerHelper = /** @class */ (function () {
+var ExtremeResamplerHelper = /** @class */ (function (_super) {
+    __extends(ExtremeResamplerHelper, _super);
     function ExtremeResamplerHelper(wasmContext) {
-        this.isDeleted = false;
-        this.nativeMergeIndexParams = new wasmContext.SCRTDoubleResamplerMergeIndicesParams();
-        this.wasmContext = wasmContext;
-        this.nativeResampler = new this.wasmContext.SCRTDoubleResampler();
-        this.xInput = new this.wasmContext.SCRTXvaluesProvider();
-        this.nativeArgs = new this.wasmContext.ResamplingArgs();
-        this.output = new this.wasmContext.SCRTDoubleArraysXyResampleOutput();
+        var _this = _super.call(this) || this;
+        _this.isDeleted = false;
+        _this.nativeMergeIndexParams = new wasmContext.SCRTDoubleResamplerMergeIndicesParams();
+        _this.wasmContext = wasmContext;
+        _this.nativeResampler = new _this.wasmContext.SCRTDoubleResampler();
+        _this.xInput = new _this.wasmContext.SCRTXvaluesProvider();
+        _this.nativeArgs = new _this.wasmContext.ResamplingArgs();
+        _this.output = new _this.wasmContext.SCRTDoubleArraysXyResampleOutput();
+        return _this;
     }
     /**
      * Calls native RequiresReduction method to calculate if resampling is needed
@@ -29,8 +48,9 @@ var ExtremeResamplerHelper = /** @class */ (function () {
         if (updateResamplingMode === void 0) { updateResamplingMode = false; }
         if (fillBasicNativeArgs)
             this.resetAndFillBasicNativeArgs(rp, xOriginalValues);
-        var needsResampling = this.nativeResampler.RequiresReduction(this.nativeArgs);
-        if (updateResamplingMode && !needsResampling) {
+        var requiresReduction = this.nativeResampler.RequiresReduction(this.nativeArgs);
+        var needsResampling = rp.dataIsFifo || requiresReduction;
+        if ((updateResamplingMode && !needsResampling) || (needsResampling && !requiresReduction)) {
             this.nativeArgs.Resampling = this.getNativeResamplingMode(ResamplingMode_1.EResamplingMode.None);
         }
         return needsResampling;
@@ -50,7 +70,7 @@ var ExtremeResamplerHelper = /** @class */ (function () {
      * you can set it to False if {@link needsResampling()} was called before this method
      * @returns indicesVector The resampled vector of indices
      */
-    ExtremeResamplerHelper.prototype.resampleIntoPointSeries = function (wasmContext, rp, xOriginalValues, yOriginalValues, indexesOut, xResampledValuesOut, yResampledValuesOut, fillBasicNativeArgs) {
+    ExtremeResamplerHelper.prototype.resampleIntoPointSeries = function (wasmContext, rp, xOriginalValues, yOriginalValues, indexesOut, indexesResampledOut, xResampledValuesOut, yResampledValuesOut, fillBasicNativeArgs) {
         if (fillBasicNativeArgs === void 0) { fillBasicNativeArgs = true; }
         if (this.isDeleted) {
             throw new Error("should not call resampleIntoPointSeries() if deleted");
@@ -64,9 +84,6 @@ var ExtremeResamplerHelper = /** @class */ (function () {
             this.resetAndFillBasicNativeArgs(rp, xOriginalValues);
         // Set X Values
         this.xInput.SetInput(xOriginalValues);
-        this.nativeArgs.FifoCapacity = rp.fifoCapacity;
-        this.nativeArgs.HasNaN = rp.dataHasNaN;
-        this.nativeArgs.IsFifo = rp.dataIsFifo;
         this.nativeArgs.ResamplingPrecision = rp.precision;
         this.nativeArgs.ZeroLineY = rp.zeroLineY;
         this.nativeArgs.NewDataPointCount = -1;
@@ -78,29 +95,43 @@ var ExtremeResamplerHelper = /** @class */ (function () {
         var requestedSize = this.nativeResampler.UpdateIndices(indexesOut, this.xInput, yOriginalValues, this.nativeArgs.Resampling, this.nativeArgs);
         // SC-5145 Adds +1 to be sure that reserved Capacity is not less than the actual resampled count,
         // otherwise resampledXValues and resampledYValues will be recreated with default 0.0 values
+        if (indexesResampledOut) {
+            indexesResampledOut.resizeFast(requestedSize + 1);
+        }
         xResampledValuesOut.resizeFast(requestedSize + 1);
         yResampledValuesOut.resizeFast(requestedSize + 1);
-        this.output.Reset(xResampledValuesOut, yResampledValuesOut);
+        if (indexesResampledOut) {
+            this.output.ResetWithIndices(indexesResampledOut, xResampledValuesOut, yResampledValuesOut);
+        }
+        else {
+            this.output.Reset(xResampledValuesOut, yResampledValuesOut);
+        }
         // Execute resampling and update indexesOut vector
         this.nativeResampler.Execute(this.xInput, yOriginalValues, this.output, indexesOut, this.nativeArgs.Resampling, this.nativeArgs);
         var resultCount = indexesOut.size();
+        //console.log("indexes from rs",resultCount, indexesOut.get(resultCount - 2), indexesOut.get(resultCount - 1));
+        if (indexesResampledOut) {
+            indexesResampledOut.resizeFast(resultCount);
+        }
         xResampledValuesOut.resizeFast(resultCount);
         yResampledValuesOut.resizeFast(resultCount);
+        return { OutputSplitIndex: this.output.OutputSplitIndex || this.nativeArgs.OutputSplitIndex };
     };
     ExtremeResamplerHelper.prototype.mergeIndexes = function (indices, size1, size2, mergedIndicesOut) {
         return this.nativeResampler.MergeIndices(indices, size1, size2, mergedIndicesOut);
     };
-    ExtremeResamplerHelper.prototype.copyValuesByIndexes = function (indices, xValues, yValues, y1Values, count, isCategoryAxis, xValuesOut, yValuesOut, y1ValuesOut, y1Offset) {
+    ExtremeResamplerHelper.prototype.copyValuesByIndexes = function (indices, xValues, yValues, y1Values, count, isCategoryAxis, isFifoSweeping, indicesOut, xValuesOut, yValuesOut, y1ValuesOut, y1Offset) {
         if (y1Offset === void 0) { y1Offset = 0; }
         var mp = this.nativeMergeIndexParams;
         mp.SetIndices(indices);
-        this.xInput.SetInput(xValues);
-        mp.SetXInput(this.xInput);
+        mp.SetXInput(xValues);
         mp.SetYInput(yValues);
         mp.SetY1Input(y1Values);
         mp.SetY1Offset(y1Offset);
         mp.count = count;
         mp.isCategoryData = isCategoryAxis;
+        mp.isFifoSweeping = isFifoSweeping;
+        mp.SetIndicesOut(indicesOut);
         mp.SetXOut(xValuesOut);
         mp.SetYOut(yValuesOut);
         mp.SetY1Out(y1ValuesOut);
@@ -115,6 +146,61 @@ var ExtremeResamplerHelper = /** @class */ (function () {
             (0, Deleter_1.deleteSafe)(this.output);
             (0, Deleter_1.deleteSafe)(this.nativeMergeIndexParams);
             this.isDeleted = true;
+            this.wasmContext = undefined;
+        }
+    };
+    ExtremeResamplerHelper.prototype.getNativeResamplingMode = function (resamplingMode) {
+        switch (resamplingMode) {
+            case ResamplingMode_1.EResamplingMode.Auto:
+                return this.wasmContext.ResamplingMode.Auto;
+            case ResamplingMode_1.EResamplingMode.Max:
+                return this.wasmContext.ResamplingMode.Max;
+            case ResamplingMode_1.EResamplingMode.Mid:
+                return this.wasmContext.ResamplingMode.Mid;
+            case ResamplingMode_1.EResamplingMode.Min:
+                return this.wasmContext.ResamplingMode.Min;
+            case ResamplingMode_1.EResamplingMode.MinMax:
+                return this.wasmContext.ResamplingMode.MinMax;
+            case ResamplingMode_1.EResamplingMode.MinOrMax:
+                return this.wasmContext.ResamplingMode.MinOrMax;
+            case ResamplingMode_1.EResamplingMode.None:
+                return this.wasmContext.ResamplingMode.None;
+            default:
+                throw new Error("Unknown resamplingMode ".concat(resamplingMode));
+        }
+    };
+    /**
+     * Fills basic native args needed for {@link needsResampling()} and {@link resampleIntoPointSeries} methods
+     */
+    ExtremeResamplerHelper.prototype.resetAndFillBasicNativeArgs = function (rp, xOriginalValues) {
+        this.nativeArgs.Reset();
+        this.nativeArgs.Data = this.getDataDistribution(rp.dataEvenlySpaced, rp.isCategoryAxis);
+        this.nativeArgs.StartIndex = rp.indexesRange.min;
+        this.nativeArgs.EndIndex = rp.indexesRange.max;
+        this.nativeArgs.MaxXInclusive = rp.xVisibleRange.max;
+        this.nativeArgs.MinXInclusive = rp.xVisibleRange.min;
+        this.nativeArgs.Resampling = this.getNativeResamplingMode(rp.resamplingMode);
+        this.nativeArgs.ViewportWidth = rp.viewportRect.width;
+        this.nativeArgs.FifoCapacity = rp.fifoCapacity || 0;
+        this.nativeArgs.HasNaN = rp.dataHasNaN;
+        this.nativeArgs.IsFifo = rp.dataIsFifo;
+        this.nativeArgs.InputBaseIndex = rp.fifoStartIndex || 0;
+        if (rp.isCategoryAxis) {
+            this.nativeArgs.MinXInclusive = rp.indexesRange.min;
+            this.nativeArgs.MaxXInclusive = rp.indexesRange.max;
+        }
+        else if (rp.fifoCapacity && !rp.dataIsFifo) {
+            // Sweeping on numeric axis, which requires x values to be sorted wrt the raw data, eg x % fifoCapactiy
+            var firstPoint = xOriginalValues.getRaw(rp.indexesRange.min);
+            var lastPoint = xOriginalValues.getRaw(rp.indexesRange.max);
+            this.nativeArgs.MinXInclusive = Math.max(firstPoint, rp.xVisibleRange.min);
+            this.nativeArgs.MaxXInclusive = Math.min(lastPoint, rp.xVisibleRange.max);
+        }
+        else {
+            var firstPoint = xOriginalValues.get(rp.indexesRange.min);
+            var lastPoint = xOriginalValues.get(rp.indexesRange.max);
+            this.nativeArgs.MinXInclusive = Math.max(firstPoint, rp.xVisibleRange.min);
+            this.nativeArgs.MaxXInclusive = Math.min(lastPoint, rp.xVisibleRange.max);
         }
     };
     ExtremeResamplerHelper.prototype.debugParameters = function (rp, nativeArgs) {
@@ -179,56 +265,6 @@ var ExtremeResamplerHelper = /** @class */ (function () {
             ? this.wasmContext.ResamplingData.LinearData
             : this.wasmContext.ResamplingData.UnevenlySpacedData;
     };
-    // A different requireReduction method
-    // private requireReduction(resamplingMode: EResamplingMode, indicesRange: NumberRange, viewportWidth: number) {
-    //     const setLength = indicesRange.max - indicesRange.min + 1;
-    //     const resampledLength = 4 * viewportWidth;
-    //
-    //     return resamplingMode !== EResamplingMode.None && setLength > resampledLength;
-    // }
-    ExtremeResamplerHelper.prototype.getNativeResamplingMode = function (resamplingMode) {
-        switch (resamplingMode) {
-            case ResamplingMode_1.EResamplingMode.Auto:
-                return this.wasmContext.ResamplingMode.Auto;
-            case ResamplingMode_1.EResamplingMode.Max:
-                return this.wasmContext.ResamplingMode.Max;
-            case ResamplingMode_1.EResamplingMode.Mid:
-                return this.wasmContext.ResamplingMode.Mid;
-            case ResamplingMode_1.EResamplingMode.Min:
-                return this.wasmContext.ResamplingMode.Min;
-            case ResamplingMode_1.EResamplingMode.MinMax:
-                return this.wasmContext.ResamplingMode.MinMax;
-            case ResamplingMode_1.EResamplingMode.MinOrMax:
-                return this.wasmContext.ResamplingMode.MinOrMax;
-            case ResamplingMode_1.EResamplingMode.None:
-                return this.wasmContext.ResamplingMode.None;
-            default:
-                throw new Error("Unknown resamplingMode ".concat(resamplingMode));
-        }
-    };
-    /**
-     * Fills basic native args needed for {@link needsResampling()} and {@link resampleIntoPointSeries} methods
-     */
-    ExtremeResamplerHelper.prototype.resetAndFillBasicNativeArgs = function (rp, xOriginalValues) {
-        this.nativeArgs.Reset();
-        this.nativeArgs.Data = this.getDataDistribution(rp.dataEvenlySpaced, rp.isCategoryAxis);
-        this.nativeArgs.StartIndex = rp.indexesRange.min;
-        this.nativeArgs.EndIndex = rp.indexesRange.max;
-        this.nativeArgs.MaxXInclusive = rp.xVisibleRange.max;
-        this.nativeArgs.MinXInclusive = rp.xVisibleRange.min;
-        this.nativeArgs.Resampling = this.getNativeResamplingMode(rp.resamplingMode);
-        this.nativeArgs.ViewportWidth = rp.viewportRect.width;
-        if (rp.isCategoryAxis) {
-            this.nativeArgs.MinXInclusive = rp.indexesRange.min;
-            this.nativeArgs.MaxXInclusive = rp.indexesRange.max;
-        }
-        else {
-            var firstPoint = xOriginalValues.get(rp.indexesRange.min);
-            var lastPoint = xOriginalValues.get(rp.indexesRange.max);
-            this.nativeArgs.MinXInclusive = Math.max(firstPoint, rp.xVisibleRange.min);
-            this.nativeArgs.MaxXInclusive = Math.min(lastPoint, rp.xVisibleRange.max);
-        }
-    };
     return ExtremeResamplerHelper;
-}());
+}(DeletableEntity_1.DeletableEntity));
 exports.ExtremeResamplerHelper = ExtremeResamplerHelper;

package/Charting/Numerics/Resamplers/ResamplingParams.d.ts

@@ -17,6 +17,7 @@ export interface IResamplingParamsCloneOptions {
     dataHasNaN?: boolean;
     dataIsFifo?: boolean;
     fifoCapacity?: number;
+    fifoStartIndex?: number;
     dataEvenlySpaced?: boolean;
 }
 export declare class ResamplingParams {
@@ -31,9 +32,10 @@ export declare class ResamplingParams {
     renderableSeriesHash: number;
     enableExperimentalResampling: boolean;
     dataHasNaN: boolean;
-    dataIsFifo: boolean;
     fifoCapacity: number;
+    fifoStartIndex: number;
     dataEvenlySpaced: boolean;
+    dataIsFifo: boolean;
     constructor(seriesViewRect: Rect, rs: IRenderableSeries, xAxis: AxisBase2D);
-    clone(options: IResamplingParamsCloneOptions): ResamplingParams;
+    clone(options?: IResamplingParamsCloneOptions): ResamplingParams;
 }