scichart 3.1.348 → 3.2.434

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

package/Charting/Numerics/Resamplers/ResamplingParams.js

@@ -7,8 +7,8 @@ var ResamplingParams = /** @class */ (function () {
         this.zeroLineY = 0;
         this.precision = 0;
         this.enableExperimentalResampling = false;
-        this.dataIsFifo = false;
         this.fifoCapacity = 0;
+        this.fifoStartIndex = 0;
         this.viewportRect = seriesViewRect;
         if (rs) {
             var dataSeries = rs.dataSeries;
@@ -16,8 +16,8 @@ var ResamplingParams = /** @class */ (function () {
             this.precision = rs.resamplingPrecision;
             if (xAxis) {
                 this.indexesRange = rs.getIndicesRange(xAxis.visibleRange, xAxis.isCategoryAxis);
-                // console.log("visible range", xAxis.visibleRange.min, xAxis.visibleRange.max);
-                // console.log("indexes range", this.indexesRange.min, this.indexesRange.max);
+                //console.log("visible range", xAxis.visibleRange.min, xAxis.visibleRange.max);
+                //console.log("indexes range", this.indexesRange.min, this.indexesRange.max);
                 this.isCategoryAxis = xAxis.isCategoryAxis;
                 this.isXAxisAutoRanged = xAxis.autoRange === AutoRange_1.EAutoRange.Always;
                 this.xVisibleRange = xAxis.visibleRange;
@@ -25,11 +25,15 @@ var ResamplingParams = /** @class */ (function () {
             if (dataSeries) {
                 this.dataHasNaN = dataSeries === null || dataSeries === void 0 ? void 0 : dataSeries.dataDistributionCalculator.containsNaN;
                 this.dataEvenlySpaced = dataSeries === null || dataSeries === void 0 ? void 0 : dataSeries.isEvenlySpaced;
+                this.fifoCapacity = dataSeries.fifoCapacity;
+                this.fifoStartIndex = dataSeries.fifoStartIndex;
+                // Disabling fifo for sweeping nearly works, but is very unreliable.
+                this.dataIsFifo = dataSeries.fifoCapacity > 0 && !dataSeries.fifoSweeping;
             }
         }
     }
     ResamplingParams.prototype.clone = function (options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
         var rp = new ResamplingParams(undefined, undefined, undefined);
         rp.zeroLineY = (_a = options === null || options === void 0 ? void 0 : options.zeroLineY) !== null && _a !== void 0 ? _a : this.zeroLineY;
         rp.precision = (_b = options === null || options === void 0 ? void 0 : options.precision) !== null && _b !== void 0 ? _b : this.precision;
@@ -42,9 +46,10 @@ var ResamplingParams = /** @class */ (function () {
         rp.renderableSeriesHash = (_j = options === null || options === void 0 ? void 0 : options.renderableSeriesHash) !== null && _j !== void 0 ? _j : this.renderableSeriesHash;
         rp.enableExperimentalResampling = (_k = options === null || options === void 0 ? void 0 : options.enableExperimentalResampling) !== null && _k !== void 0 ? _k : this.enableExperimentalResampling;
         rp.dataHasNaN = (_l = options === null || options === void 0 ? void 0 : options.dataHasNaN) !== null && _l !== void 0 ? _l : this.dataHasNaN;
-        rp.dataIsFifo = (_m = options === null || options === void 0 ? void 0 : options.dataIsFifo) !== null && _m !== void 0 ? _m : this.dataIsFifo;
-        rp.fifoCapacity = (_o = options === null || options === void 0 ? void 0 : options.fifoCapacity) !== null && _o !== void 0 ? _o : this.fifoCapacity;
-        rp.dataEvenlySpaced = (_p = options === null || options === void 0 ? void 0 : options.dataEvenlySpaced) !== null && _p !== void 0 ? _p : this.dataEvenlySpaced;
+        rp.dataEvenlySpaced = (_m = options === null || options === void 0 ? void 0 : options.dataEvenlySpaced) !== null && _m !== void 0 ? _m : this.dataEvenlySpaced;
+        rp.fifoCapacity = (_o = options.fifoCapacity) !== null && _o !== void 0 ? _o : this.fifoCapacity;
+        rp.fifoStartIndex = (_p = options.fifoStartIndex) !== null && _p !== void 0 ? _p : this.fifoStartIndex;
+        rp.dataIsFifo = (_q = options.dataIsFifo) !== null && _q !== void 0 ? _q : this.dataIsFifo;
         return rp;
     };
     return ResamplingParams;

package/Charting/Numerics/TickCoordinateProviders/TickCoordinatesProvider.d.ts

@@ -12,6 +12,11 @@ export declare abstract class TickCoordinatesProvider {
      * @param axis The Axis we are attached to.
      */
     attachedToAxis(axis: AxisCore): void;
+    /**
+     * Called when the {@link TickCoordinatesProvider} is detached from an {@link AxisCore | Axis}
+     * @param axis The Axis we are attached to.
+     */
+    detachedFromAxis(): void;
     /**
      * Converts arrays of major and minor ticks (data values) into structure containing pixel coordinates
      * @param minorTicks

package/Charting/Numerics/TickCoordinateProviders/TickCoordinatesProvider.js

@@ -14,6 +14,13 @@ var TickCoordinatesProvider = /** @class */ (function () {
     TickCoordinatesProvider.prototype.attachedToAxis = function (axis) {
         this.parentAxis = axis;
     };
+    /**
+     * Called when the {@link TickCoordinatesProvider} is detached from an {@link AxisCore | Axis}
+     * @param axis The Axis we are attached to.
+     */
+    TickCoordinatesProvider.prototype.detachedFromAxis = function () {
+        this.parentAxis = undefined;
+    };
     return TickCoordinatesProvider;
 }());
 exports.TickCoordinatesProvider = TickCoordinatesProvider;

package/Charting/Numerics/TickProviders/NumericTickProvider.js

@@ -92,12 +92,11 @@ var NumericTickProvider = /** @class */ (function (_super) {
         var results = [];
         var min = visibleRange.min;
         var max = visibleRange.max;
-        var current = min;
         var calcMajorTicks = delta === majorDelta;
         var numberUtil = this.webAssemblyContext.NumberUtil;
-        if (!numberUtil.IsDivisibleBy(current, delta)) {
-            current = numberUtil.RoundUp(current, delta);
-        }
+        // Skip the divisiblity check here as it can return true if the min is within epsilon of being divisible,
+        // but false for min + delta, leading to only one tick being output.
+        var current = numberUtil.RoundUp(min, delta);
         var start = current;
         var tickCount = 0;
         while (current <= max) {

package/Charting/Numerics/TickProviders/TickProvider.d.ts

@@ -23,6 +23,11 @@ export declare abstract class TickProvider {
      * @param axis
      */
     attachedToAxis(axis: AxisCore): void;
+    /**
+     * Called when the TickProvider is attached from an {@link AxisCore | Axis}
+     * @param axis
+     */
+    detachedFromAxis(): void;
     /**
      * @summary Gets an array of major ticks (data-values values where SciChart will place labels and major gridlines).
      * @description Major ticks are data-values where we will place the major gridlines and labels. For example. if the {@link AxisCore | Axis}

package/Charting/Numerics/TickProviders/TickProvider.js

@@ -24,6 +24,13 @@ var TickProvider = /** @class */ (function () {
     TickProvider.prototype.attachedToAxis = function (axis) {
         this.parentAxis = axis;
     };
+    /**
+     * Called when the TickProvider is attached from an {@link AxisCore | Axis}
+     * @param axis
+     */
+    TickProvider.prototype.detachedFromAxis = function () {
+        this.parentAxis = undefined;
+    };
     return TickProvider;
 }());
 exports.TickProvider = TickProvider;

package/Charting/Services/SciChartRenderer.js

@@ -58,7 +58,7 @@ var SciChartRenderer = /** @class */ (function () {
             return {
                 pointSeries: rs.toPointSeries(),
                 renderableSeries: rs,
-                indicesRange: undefined,
+                indicesRange: rs.isStacked ? undefined : rs.getIndicesRange(xAxis.visibleRange, xAxis.isCategoryAxis),
                 resamplingHash: undefined
             };
         var rp = new ResamplingParams_1.ResamplingParams(seriesViewRect, rs, xAxis);
@@ -66,7 +66,7 @@ var SciChartRenderer = /** @class */ (function () {
             return {
                 pointSeries: rs.toPointSeries(),
                 renderableSeries: rs,
-                indicesRange: undefined,
+                indicesRange: rp.indexesRange,
                 resamplingHash: undefined
             };
         var resamplingHash = SciChartRenderer.calculateResamplingHash(rs, rp);
@@ -110,7 +110,7 @@ var SciChartRenderer = /** @class */ (function () {
         if (this.sciChartSurface.isDeleted) {
             return;
         }
-        // console.log("render start");
+        //console.log("render start");
         var nativeContext = renderContext.getNativeContext();
         var wasmContext = this.sciChartSurface.webAssemblyContext2D;
         var oldBlendMode;
@@ -126,7 +126,7 @@ var SciChartRenderer = /** @class */ (function () {
         this.sciChartSurface.onAnimate(timeElapsed);
         renderContext.enqueueLayeredDraw(function () {
             _this.sciChartSurface.updateBackground();
-        }, this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.AxisBandsLayer));
+        }, this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.Background));
         // Step 2 autorange
         this.sciChartSurface.updateStackedCollectionAccumulatedVectors();
         this.sciChartSurface.xAxes.asArray().forEach(function (axis) { return _this.tryPerformAutoRangeOn(axis, _this.sciChartSurface); });
@@ -164,6 +164,11 @@ var SciChartRenderer = /** @class */ (function () {
                 el.type === IAnnotation_1.EAnnotationType.RenderContextAxisMarkerAnnotation ||
                 el.type === IAnnotation_1.EAnnotationType.RenderContextNativeTextAnnotation);
         });
+        // Draw annotations before axis
+        var annotationsLayerBelowAxis = this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.Background);
+        renderContext.enqueueLayeredDraw(function () {
+            _this.drawRenderContextAnnotations(renderContextAnnotations, xAxesById, yAxesById, IAnnotation_1.EAnnotationLayer.Background, renderContext, seriesViewRect);
+        }, annotationsLayerBelowAxis);
         var annotationsBelowLayer = this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.AnnotationsBelowSeriesLayer);
         renderContext.enqueueLayeredDraw(function () {
             _this.drawRenderContextAnnotations(renderContextAnnotations, xAxesById, yAxesById, IAnnotation_1.EAnnotationLayer.BelowChart, renderContext, seriesViewRect);
@@ -373,7 +378,12 @@ var SciChartRenderer = /** @class */ (function () {
         nativeContext.SetClipRect(viewRect.x, viewRect.y, viewRect.width, viewRect.height);
         // Draw unselected series first
         renderableSeriesArray.forEach(function (rs, index) {
-            if (rs.isVisible && !rs.isSelected)
+            if (rs.isVisible && !rs.isSelected && !rs.isHovered)
+                drawSeriesImpl(index);
+        });
+        // Draw hovered series next
+        renderableSeriesArray.forEach(function (rs, index) {
+            if (rs.isVisible && rs.isHovered)
                 drawSeriesImpl(index);
         });
         // Draw selected series at higher z-index

package/Charting/Services/TitleRenderer.d.ts

@@ -1,3 +1,4 @@
+import { DeletableEntity } from "../../Core/DeletableEntity";
 import { ICacheable } from "../../Core/ICacheable";
 import { IDeletable } from "../../Core/IDeletable";
 import { Rect } from "../../Core/Rect";
@@ -18,7 +19,7 @@ export interface IChartTitleRenderer extends ITitleRenderer {
     titleOffset: Thickness;
     measure(title: string | string[], originalTextStyle: Required<TChartTitleStyle>, renderContext: WebGlRenderContext2D): void;
 }
-export declare class TitleRendererBase<TextStyleType extends TAxisTitleStyle | TChartTitleStyle> implements ITitleRenderer {
+export declare class TitleRendererBase<TextStyleType extends TAxisTitleStyle | TChartTitleStyle> extends DeletableEntity implements ITitleRenderer {
     /**
      * Defines a bounding {@link Rect} containing the title text
      */