scichart 2.0.2204 → 2.1.2267

package/Charting/Model/PointSeries/BasePointSeriesResampled.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePointSeriesResampled = void 0;
+var BasePointSeriesResampled = /** @class */ (function () {
+    function BasePointSeriesResampled(wasmContext, xRange) {
+        this.wasmContext = wasmContext;
+        this.intIndexes = new wasmContext.IntVector();
+        this.indexes = new wasmContext.SCRTDoubleVector();
+        this.xValues = new wasmContext.SCRTDoubleVector();
+        this.yValues = new wasmContext.SCRTDoubleVector();
+        this.xRange = xRange;
+    }
+    Object.defineProperty(BasePointSeriesResampled.prototype, "count", {
+        get: function () {
+            return this.xValues.size();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BasePointSeriesResampled.prototype.delete = function () {
+        this.intIndexes.delete();
+        this.indexes.delete();
+        this.xValues.delete();
+        this.yValues.delete();
+    };
+    /**
+     * Updates SCRTDoubleVector from IntVector
+     */
+    BasePointSeriesResampled.prototype.updateIndexes = function () {
+        var resultCount = this.count;
+        // console.log("resultCount", resultCount);
+        // console.log("this.indexes", this.indexes);
+        this.indexes.resizeFast(resultCount);
+        // TODO: Find an effective way to copy indexes
+        for (var i = 0; i < resultCount; i++) {
+            this.indexes.set(i, this.intIndexes.get(i));
+        }
+    };
+    BasePointSeriesResampled.prototype.clearIntIndexes = function () {
+        this.intIndexes.clear();
+    };
+    BasePointSeriesResampled.prototype.debugOutputForUnitTests = function () {
+        console.log("points count ".concat(this.count));
+        console.log("xResampled at min", this.xValues.get(0));
+        console.log("openResampled at min", this.yValues.get(0));
+        var middle = Math.round(this.count / 2);
+        console.log("middle", middle);
+        console.log("xResampled at middle", this.xValues.get(middle));
+        console.log("yValues at middle", this.yValues.get(middle));
+        var end = this.count - 1;
+        console.log("xResampled at end", this.xValues.get(end));
+        console.log("yValues at end", this.yValues.get(end));
+    };
+    return BasePointSeriesResampled;
+}());
+exports.BasePointSeriesResampled = BasePointSeriesResampled;

package/Charting/Model/PointSeries/BasePointSeriesWrapped.d.ts

@@ -0,0 +1,14 @@
+import { NumberRange } from "../../../Core/NumberRange";
+import { SCRTDoubleVector } from "../../../types/TSciChart";
+import { IDataSeries } from "../IDataSeries";
+import { IPointSeries } from "./IPointSeries";
+export declare class BasePointSeriesWrapped implements IPointSeries {
+    readonly count: number;
+    readonly xRange: NumberRange;
+    readonly xValues: SCRTDoubleVector;
+    readonly yValues: SCRTDoubleVector;
+    protected dataSeries: IDataSeries;
+    protected indexesProperty: SCRTDoubleVector;
+    constructor(dataSeries: IDataSeries);
+    get indexes(): SCRTDoubleVector;
+}

package/Charting/Model/PointSeries/BasePointSeriesWrapped.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePointSeriesWrapped = void 0;
+var BasePointSeriesWrapped = /** @class */ (function () {
+    function BasePointSeriesWrapped(dataSeries) {
+        this.dataSeries = dataSeries;
+        this.count = dataSeries.count();
+        this.xValues = this.dataSeries.getNativeXValues();
+        this.yValues = this.dataSeries.getNativeYValues();
+    }
+    Object.defineProperty(BasePointSeriesWrapped.prototype, "indexes", {
+        get: function () {
+            if (!this.indexesProperty) {
+                this.indexesProperty = this.dataSeries.getNativeIndexes();
+            }
+            return this.indexesProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BasePointSeriesWrapped;
+}());
+exports.BasePointSeriesWrapped = BasePointSeriesWrapped;

package/Charting/Model/PointSeries/IPointSeries.d.ts

@@ -0,0 +1,31 @@
+import { NumberRange } from "../../../Core/NumberRange";
+import { IntVector, SCRTDoubleVector } from "../../../types/TSciChart";
+/**
+ * The PointSeries is a set of data for drawing. This might be a reduced set depending on optimisations enabled
+ */
+export interface IPointSeries {
+    readonly indexes: SCRTDoubleVector;
+    readonly xValues: SCRTDoubleVector;
+    readonly yValues: SCRTDoubleVector;
+    readonly count: number;
+    xRange: NumberRange;
+}
+export interface IPointSeriesResampled {
+    readonly intIndexes: IntVector;
+    updateIndexes(): void;
+    clearIntIndexes(): void;
+}
+export interface IXyPointSeries extends IPointSeries {
+}
+export interface IXyyPointSeries extends IPointSeries {
+    readonly y1Values: SCRTDoubleVector;
+}
+export interface IXyzPointSeries extends IPointSeries {
+    readonly zValues: SCRTDoubleVector;
+}
+export interface IOhlcPointSeries extends IPointSeries {
+    readonly openValues: SCRTDoubleVector;
+    readonly highValues: SCRTDoubleVector;
+    readonly lowValues: SCRTDoubleVector;
+    readonly closeValues: SCRTDoubleVector;
+}

package/Charting/Model/PointSeries/IPointSeries.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/Charting/Model/PointSeries/OhlcPointSeriesResampled.d.ts

@@ -0,0 +1,13 @@
+import { NumberRange } from "../../../Core/NumberRange";
+import { SCRTDoubleVector, TSciChart } from "../../../types/TSciChart";
+import { BasePointSeriesResampled } from "./BasePointSeriesResampled";
+import { IOhlcPointSeries } from "./IPointSeries";
+export declare class OhlcPointSeriesResampled extends BasePointSeriesResampled implements IOhlcPointSeries {
+    readonly openValues: SCRTDoubleVector;
+    readonly highValues: SCRTDoubleVector;
+    readonly lowValues: SCRTDoubleVector;
+    readonly closeValues: SCRTDoubleVector;
+    constructor(wasmContext: TSciChart, xRange: NumberRange);
+    delete(): void;
+    debugOutputForUnitTests(): void;
+}

package/Charting/Model/PointSeries/OhlcPointSeriesResampled.js

@@ -0,0 +1,59 @@
+"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.OhlcPointSeriesResampled = void 0;
+var BasePointSeriesResampled_1 = require("./BasePointSeriesResampled");
+var OhlcPointSeriesResampled = /** @class */ (function (_super) {
+    __extends(OhlcPointSeriesResampled, _super);
+    function OhlcPointSeriesResampled(wasmContext, xRange) {
+        var _this = _super.call(this, wasmContext, xRange) || this;
+        _this.openValues = new wasmContext.SCRTDoubleVector();
+        _this.highValues = new wasmContext.SCRTDoubleVector();
+        _this.lowValues = new wasmContext.SCRTDoubleVector();
+        _this.closeValues = _this.yValues;
+        return _this;
+    }
+    OhlcPointSeriesResampled.prototype.delete = function () {
+        _super.prototype.delete.call(this);
+        this.openValues.delete();
+        this.highValues.delete();
+        this.lowValues.delete();
+    };
+    OhlcPointSeriesResampled.prototype.debugOutputForUnitTests = function () {
+        console.log("points count ".concat(this.count));
+        console.log("xResampled at min", this.xValues.get(0));
+        console.log("openResampled at min", this.openValues.get(0));
+        console.log("highResampled at min", this.highValues.get(0));
+        console.log("lowResampled at min", this.lowValues.get(0));
+        console.log("closeResampled at min", this.closeValues.get(0));
+        var middle = Math.round(this.count / 2);
+        console.log("middle", middle);
+        console.log("xResampled at middle", this.xValues.get(middle));
+        console.log("openResampled at middle", this.openValues.get(middle));
+        console.log("highResampled at middle", this.highValues.get(middle));
+        console.log("lowResampled at middle", this.lowValues.get(middle));
+        console.log("closeResampled at middle", this.closeValues.get(middle));
+        var end = this.count - 1;
+        console.log("xResampled at end", this.xValues.get(end));
+        console.log("openResampled at end", this.openValues.get(end));
+        console.log("highResampled at end", this.highValues.get(end));
+        console.log("lowResampled at end", this.lowValues.get(end));
+        console.log("closeResampled at end", this.closeValues.get(end));
+    };
+    return OhlcPointSeriesResampled;
+}(BasePointSeriesResampled_1.BasePointSeriesResampled));
+exports.OhlcPointSeriesResampled = OhlcPointSeriesResampled;

package/Charting/Model/PointSeries/OhlcPointSeriesWrapped.d.ts

@@ -0,0 +1,11 @@
+import { SCRTDoubleVector } from "../../../types/TSciChart";
+import { OhlcDataSeries } from "../OhlcDataSeries";
+import { BasePointSeriesWrapped } from "./BasePointSeriesWrapped";
+import { IOhlcPointSeries } from "./IPointSeries";
+export declare class OhlcPointSeriesWrapped extends BasePointSeriesWrapped implements IOhlcPointSeries {
+    readonly openValues: SCRTDoubleVector;
+    readonly highValues: SCRTDoubleVector;
+    readonly lowValues: SCRTDoubleVector;
+    readonly closeValues: SCRTDoubleVector;
+    constructor(dataSeries: OhlcDataSeries);
+}

package/Charting/Model/PointSeries/OhlcPointSeriesWrapped.js

@@ -0,0 +1,32 @@
+"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.OhlcPointSeriesWrapped = void 0;
+var BasePointSeriesWrapped_1 = require("./BasePointSeriesWrapped");
+var OhlcPointSeriesWrapped = /** @class */ (function (_super) {
+    __extends(OhlcPointSeriesWrapped, _super);
+    function OhlcPointSeriesWrapped(dataSeries) {
+        var _this = _super.call(this, dataSeries) || this;
+        _this.openValues = dataSeries.getNativeOpenValues();
+        _this.highValues = dataSeries.getNativeHighValues();
+        _this.lowValues = dataSeries.getNativeLowValues();
+        _this.closeValues = _this.yValues;
+        return _this;
+    }
+    return OhlcPointSeriesWrapped;
+}(BasePointSeriesWrapped_1.BasePointSeriesWrapped));
+exports.OhlcPointSeriesWrapped = OhlcPointSeriesWrapped;

package/Charting/Model/PointSeries/XyPointSeriesResampled.d.ts

@@ -0,0 +1,7 @@
+import { NumberRange } from "../../../Core/NumberRange";
+import { TSciChart } from "../../../types/TSciChart";
+import { BasePointSeriesResampled } from "./BasePointSeriesResampled";
+import { IXyPointSeries } from "./IPointSeries";
+export declare class XyPointSeriesResampled extends BasePointSeriesResampled implements IXyPointSeries {
+    constructor(wasmContext: TSciChart, xRange: NumberRange);
+}

package/Charting/Model/PointSeries/XyPointSeriesResampled.js

@@ -0,0 +1,27 @@
+"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.XyPointSeriesResampled = void 0;
+var BasePointSeriesResampled_1 = require("./BasePointSeriesResampled");
+var XyPointSeriesResampled = /** @class */ (function (_super) {
+    __extends(XyPointSeriesResampled, _super);
+    function XyPointSeriesResampled(wasmContext, xRange) {
+        return _super.call(this, wasmContext, xRange) || this;
+    }
+    return XyPointSeriesResampled;
+}(BasePointSeriesResampled_1.BasePointSeriesResampled));
+exports.XyPointSeriesResampled = XyPointSeriesResampled;

package/Charting/Model/PointSeries/XyPointSeriesWrapped.d.ts

@@ -0,0 +1,6 @@
+import { IDataSeries } from "../IDataSeries";
+import { BasePointSeriesWrapped } from "./BasePointSeriesWrapped";
+import { IXyPointSeries } from "./IPointSeries";
+export declare class XyPointSeriesWrapped extends BasePointSeriesWrapped implements IXyPointSeries {
+    constructor(dataSeries: IDataSeries);
+}

package/Charting/Model/PointSeries/XyPointSeriesWrapped.js

@@ -0,0 +1,27 @@
+"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.XyPointSeriesWrapped = void 0;
+var BasePointSeriesWrapped_1 = require("./BasePointSeriesWrapped");
+var XyPointSeriesWrapped = /** @class */ (function (_super) {
+    __extends(XyPointSeriesWrapped, _super);
+    function XyPointSeriesWrapped(dataSeries) {
+        return _super.call(this, dataSeries) || this;
+    }
+    return XyPointSeriesWrapped;
+}(BasePointSeriesWrapped_1.BasePointSeriesWrapped));
+exports.XyPointSeriesWrapped = XyPointSeriesWrapped;

package/Charting/Model/PointSeries/XyyPointSeriesResampled.d.ts

@@ -0,0 +1,10 @@
+import { NumberRange } from "../../../Core/NumberRange";
+import { SCRTDoubleVector, TSciChart } from "../../../types/TSciChart";
+import { BasePointSeriesResampled } from "./BasePointSeriesResampled";
+import { IXyyPointSeries } from "./IPointSeries";
+export declare class XyyPointSeriesResampled extends BasePointSeriesResampled implements IXyyPointSeries {
+    readonly y1Values: SCRTDoubleVector;
+    constructor(wasmContext: TSciChart, xRange: NumberRange);
+    delete(): void;
+    debugOutputForUnitTests(): void;
+}

package/Charting/Model/PointSeries/XyyPointSeriesResampled.js

@@ -0,0 +1,48 @@
+"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.XyyPointSeriesResampled = void 0;
+var BasePointSeriesResampled_1 = require("./BasePointSeriesResampled");
+var XyyPointSeriesResampled = /** @class */ (function (_super) {
+    __extends(XyyPointSeriesResampled, _super);
+    function XyyPointSeriesResampled(wasmContext, xRange) {
+        var _this = _super.call(this, wasmContext, xRange) || this;
+        _this.y1Values = new wasmContext.SCRTDoubleVector();
+        return _this;
+    }
+    XyyPointSeriesResampled.prototype.delete = function () {
+        _super.prototype.delete.call(this);
+        this.y1Values.delete();
+    };
+    XyyPointSeriesResampled.prototype.debugOutputForUnitTests = function () {
+        console.log("points count ".concat(this.count));
+        console.log("xResampled at min", this.xValues.get(0));
+        console.log("yValues at min", this.yValues.get(0));
+        console.log("y1Values at min", this.y1Values.get(0));
+        var middle = Math.round(this.count / 2);
+        console.log("middle", middle);
+        console.log("xResampled at middle", this.xValues.get(middle));
+        console.log("yValues at middle", this.yValues.get(middle));
+        console.log("y1Values at middle", this.y1Values.get(middle));
+        var end = this.count - 1;
+        console.log("xResampled at end", this.xValues.get(end));
+        console.log("yValues at end", this.yValues.get(end));
+        console.log("y1Values at end", this.y1Values.get(end));
+    };
+    return XyyPointSeriesResampled;
+}(BasePointSeriesResampled_1.BasePointSeriesResampled));
+exports.XyyPointSeriesResampled = XyyPointSeriesResampled;

package/Charting/Model/PointSeries/XyyPointSeriesWrapped.d.ts

@@ -0,0 +1,8 @@
+import { SCRTDoubleVector } from "../../../types/TSciChart";
+import { XyyDataSeries } from "../XyyDataSeries";
+import { BasePointSeriesWrapped } from "./BasePointSeriesWrapped";
+import { IXyyPointSeries } from "./IPointSeries";
+export declare class XyyPointSeriesWrapped extends BasePointSeriesWrapped implements IXyyPointSeries {
+    readonly y1Values: SCRTDoubleVector;
+    constructor(dataSeries: XyyDataSeries);
+}

package/Charting/Model/PointSeries/XyyPointSeriesWrapped.js

@@ -0,0 +1,29 @@
+"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.XyyPointSeriesWrapped = void 0;
+var BasePointSeriesWrapped_1 = require("./BasePointSeriesWrapped");
+var XyyPointSeriesWrapped = /** @class */ (function (_super) {
+    __extends(XyyPointSeriesWrapped, _super);
+    function XyyPointSeriesWrapped(dataSeries) {
+        var _this = _super.call(this, dataSeries) || this;
+        _this.y1Values = dataSeries.getNativeY1Values();
+        return _this;
+    }
+    return XyyPointSeriesWrapped;
+}(BasePointSeriesWrapped_1.BasePointSeriesWrapped));
+exports.XyyPointSeriesWrapped = XyyPointSeriesWrapped;

package/Charting/Model/PointSeries/XyzPointSeriesWrapped.d.ts

@@ -0,0 +1,8 @@
+import { SCRTDoubleVector } from "../../../types/TSciChart";
+import { XyzDataSeries } from "../XyzDataSeries";
+import { BasePointSeriesWrapped } from "./BasePointSeriesWrapped";
+import { IXyzPointSeries } from "./IPointSeries";
+export declare class XyzPointSeriesWrapped extends BasePointSeriesWrapped implements IXyzPointSeries {
+    readonly zValues: SCRTDoubleVector;
+    constructor(dataSeries: XyzDataSeries);
+}

package/Charting/Model/PointSeries/XyzPointSeriesWrapped.js

@@ -0,0 +1,29 @@
+"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.XyzPointSeriesWrapped = void 0;
+var BasePointSeriesWrapped_1 = require("./BasePointSeriesWrapped");
+var XyzPointSeriesWrapped = /** @class */ (function (_super) {
+    __extends(XyzPointSeriesWrapped, _super);
+    function XyzPointSeriesWrapped(dataSeries) {
+        var _this = _super.call(this, dataSeries) || this;
+        _this.zValues = dataSeries.getNativeZValues();
+        return _this;
+    }
+    return XyzPointSeriesWrapped;
+}(BasePointSeriesWrapped_1.BasePointSeriesWrapped));
+exports.XyzPointSeriesWrapped = XyzPointSeriesWrapped;

package/Charting/Model/XyDataSeries.d.ts

@@ -90,6 +90,7 @@ export declare class XyDataSeries extends BaseDataSeries {
      * @param index The index to update
      * @param x The new X value
      * @param y The new Y value
+     * @param metadata The point metadata
      */
     updateXy(index: number, x: number, y: number, metadata?: IPointMetadata): void;
     /**
@@ -99,8 +100,8 @@ export declare class XyDataSeries extends BaseDataSeries {
      *
      * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
      * @param startIndex the index to insert at
-     * @param x the Xvalue
-     * @param y the Yvalue
+     * @param x the X value
+     * @param y the Y value
      * @param metadata The point metadata
      */
     insert(startIndex: number, x: number, y: number, metadata?: IPointMetadata): void;

package/Charting/Model/XyDataSeries.js

@@ -18,7 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.XyDataSeries = void 0;
 var Guard_1 = require("../../Core/Guard");
 var NumberArray_1 = require("../../types/NumberArray");
-var fillDoubleVectorFromJsArray_1 = require("../../utils/ccall/fillDoubleVectorFromJsArray");
+var appendDoubleVectorFromJsArray_1 = require("../../utils/ccall/appendDoubleVectorFromJsArray");
 var BaseDataSeries_1 = require("./BaseDataSeries");
 var IDataSeries_1 = require("./IDataSeries");
 /**
@@ -79,9 +79,11 @@ var XyDataSeries = /** @class */ (function (_super) {
      */
     XyDataSeries.prototype.append = function (x, y, metadata) {
         if (!this.getIsDeleted()) {
+            var nativeX = this.getNativeXValues();
+            this.dataDistributionCalculator.onAppend(this.isSorted, this.containsNaN, nativeX, [x], [y]);
             // Push metadata should be done before push x values
             this.appendMetadata(metadata);
-            this.getNativeXValues().push_back(x);
+            nativeX.push_back(x);
             this.getNativeYValues().push_back(y);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Append, null, 1);
         }
@@ -98,26 +100,22 @@ var XyDataSeries = /** @class */ (function (_super) {
      */
     XyDataSeries.prototype.appendRange = function (xValues, yValues, metadata) {
         if (!this.getIsDeleted()) {
-            Guard_1.Guard.isTrue(Array.isArray(xValues) || (0, NumberArray_1.isTypedArray)(xValues), "xValues must be an array of numbers");
-            Guard_1.Guard.isTrue(Array.isArray(yValues) || (0, NumberArray_1.isTypedArray)(yValues), "yValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(xValues) || (0, NumberArray_1.isTypedArray)(xValues), "xValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(yValues) || (0, NumberArray_1.isTypedArray)(yValues), "yValues must be an array of numbers");
             Guard_1.Guard.arraysSameLength(xValues, "xValues", yValues, "yValues");
             if (metadata) {
                 Guard_1.Guard.isTrue(Array.isArray(metadata), "metadata must be an array of IPointMetadata");
                 Guard_1.Guard.arraysSameLength(xValues, "xValues", metadata, "metadata");
             }
-            // Push metadata should be done before push x values
-            this.appendMetadataRange(metadata, xValues.length);
             var nativeX = this.getNativeXValues();
             var nativeY = this.getNativeYValues();
-            // Old implementation with copying each element
-            // for (let i = 0; i < xValues.length; i++) {
-            //     nativeX.push_back(xValues[i]);
-            //     nativeY.push_back(yValues[i]);
-            // }
+            this.dataDistributionCalculator.onAppend(this.isSorted, this.containsNaN, nativeX, xValues, yValues);
+            // Push metadata should be done before push x values
+            this.appendMetadataRange(metadata, xValues.length);
             // New implementation passing array from JS
             // TODO: create indexValues from c++
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeX, xValues);
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeY, yValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeX, xValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeY, yValues);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Append, null, xValues.length);
         }
     };
@@ -131,6 +129,7 @@ var XyDataSeries = /** @class */ (function (_super) {
     XyDataSeries.prototype.update = function (index, y, metadata) {
         if (!this.getIsDeleted()) {
             this.validateIndex(index);
+            this.dataDistributionCalculator.onUpdate(this.isSorted, this.containsNaN, undefined, undefined, [y], index);
             this.getNativeYValues().set(index, y);
             this.setMetadataAt(index, metadata);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Update, index, 1);
@@ -142,10 +141,14 @@ var XyDataSeries = /** @class */ (function (_super) {
      * @param index The index to update
      * @param x The new X value
      * @param y The new Y value
+     * @param metadata The point metadata
      */
     XyDataSeries.prototype.updateXy = function (index, x, y, metadata) {
         if (!this.getIsDeleted()) {
-            this.getNativeXValues().set(index, x);
+            this.validateIndex(index);
+            var nativeX = this.getNativeXValues();
+            this.dataDistributionCalculator.onUpdate(this.isSorted, this.containsNaN, nativeX, [x], [y], index);
+            nativeX.set(index, x);
             this.getNativeYValues().set(index, y);
             this.setMetadataAt(index, metadata);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Update, index, 1);
@@ -158,8 +161,8 @@ var XyDataSeries = /** @class */ (function (_super) {
      *
      * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
      * @param startIndex the index to insert at
-     * @param x the Xvalue
-     * @param y the Yvalue
+     * @param x the X value
+     * @param y the Y value
      * @param metadata The point metadata
      */
     XyDataSeries.prototype.insert = function (startIndex, x, y, metadata) {
@@ -167,6 +170,7 @@ var XyDataSeries = /** @class */ (function (_super) {
             this.validateIndex(startIndex, "Start index is out of range");
             var nativeX = this.getNativeXValues();
             var nativeY = this.getNativeYValues();
+            this.dataDistributionCalculator.onInsert(this.isSorted, this.containsNaN, nativeX, [x], [y], startIndex);
             nativeX.insertAt(startIndex, x);
             nativeY.insertAt(startIndex, y);
             this.insertMetadata(startIndex, metadata);
@@ -184,22 +188,18 @@ var XyDataSeries = /** @class */ (function (_super) {
      */
     XyDataSeries.prototype.insertRange = function (startIndex, xValues, yValues, metadata) {
         if (!this.getIsDeleted()) {
-            Guard_1.Guard.isTrue(Array.isArray(xValues) || (0, NumberArray_1.isTypedArray)(xValues), "xValues must be an array of numbers");
-            Guard_1.Guard.isTrue(Array.isArray(yValues) || (0, NumberArray_1.isTypedArray)(xValues), "yValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(xValues) || (0, NumberArray_1.isTypedArray)(xValues), "xValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(yValues) || (0, NumberArray_1.isTypedArray)(yValues), "yValues must be an array of numbers");
             this.validateIndex(startIndex, "Start index is out of range");
             Guard_1.Guard.arraysSameLength(xValues, "xValues", yValues, "yValues");
             if (metadata) {
                 Guard_1.Guard.isTrue(Array.isArray(metadata), "metadata must be an array of IPointMetadata");
                 Guard_1.Guard.arraysSameLength(xValues, "xValues", metadata, "metadata");
             }
-            var rangeLength = xValues.length;
             var nativeX = this.getNativeXValues();
-            var nativeY = this.getNativeYValues();
-            var tempStartIndex = startIndex;
-            for (var i = 0; i < rangeLength; i++, tempStartIndex++) {
-                nativeX.insertAt(tempStartIndex, xValues[i]);
-                nativeY.insertAt(tempStartIndex, yValues[i]);
-            }
+            this.dataDistributionCalculator.onInsert(this.isSorted, this.containsNaN, nativeX, xValues, yValues, startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, xValues, this.getNativeXValues(), startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, yValues, this.getNativeYValues(), startIndex);
             this.insertMetadataRange(startIndex, metadata);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Insert, startIndex, xValues.length);
         }
@@ -243,7 +243,7 @@ var XyDataSeries = /** @class */ (function (_super) {
      */
     XyDataSeries.prototype.clear = function () {
         if (!this.getIsDeleted()) {
-            this.getNativeIndexes().clear();
+            _super.prototype.clear.call(this);
             this.getNativeXValues().clear();
             this.getNativeYValues().clear();
             this.setMetadata(undefined);