scichart 2.0.2228 → 2.1.2273

package/Charting/Model/OhlcDataSeries.d.ts

@@ -1,6 +1,6 @@
 import { NumberRange } from "../../Core/NumberRange";
 import { NumberArray } from "../../types/NumberArray";
-import { DoubleVector, TSciChart } from "../../types/TSciChart";
+import { SCRTDoubleVector, TSciChart } from "../../types/TSciChart";
 import { SeriesAnimation } from "../Visuals/RenderableSeries/Animations/SeriesAnimation";
 import { BaseDataSeries, IBaseDataSeriesOptions } from "./BaseDataSeries";
 import { EDataSeriesType, EDataSeriesValueType } from "./IDataSeries";
@@ -50,27 +50,27 @@ export declare class OhlcDataSeries extends BaseDataSeries {
     /**
      * Open vector with initial animation values
      */
-    openInitialAnimationValues: DoubleVector;
+    openInitialAnimationValues: SCRTDoubleVector;
     /**
      * Open vector with final animation values
      */
-    openFinalAnimationValues: DoubleVector;
+    openFinalAnimationValues: SCRTDoubleVector;
     /**
      * High vector with initial animation values
      */
-    highInitialAnimationValues: DoubleVector;
+    highInitialAnimationValues: SCRTDoubleVector;
     /**
      * High vector with final animation values
      */
-    highFinalAnimationValues: DoubleVector;
+    highFinalAnimationValues: SCRTDoubleVector;
     /**
      * Low vector with initial animation values
      */
-    lowInitialAnimationValues: DoubleVector;
+    lowInitialAnimationValues: SCRTDoubleVector;
     /**
      * Low vector with final animation values
      */
-    lowFinalAnimationValues: DoubleVector;
+    lowFinalAnimationValues: SCRTDoubleVector;
     private openValues;
     private highValues;
     private lowValues;
@@ -84,19 +84,19 @@ export declare class OhlcDataSeries extends BaseDataSeries {
     /**
      * Gets a native / WebAssembly vector of Open-values in the DataSeries
      */
-    getNativeOpenValues(): DoubleVector;
+    getNativeOpenValues(): SCRTDoubleVector;
     /**
      * Gets a native / WebAssembly vector of High-values in the DataSeries
      */
-    getNativeHighValues(): DoubleVector;
+    getNativeHighValues(): SCRTDoubleVector;
     /**
      * Gets a native / WebAssembly vector of Low-values in the DataSeries
      */
-    getNativeLowValues(): DoubleVector;
+    getNativeLowValues(): SCRTDoubleVector;
     /**
      * Gets a native / WebAssembly vector of Close-values in the DataSeries
      */
-    getNativeCloseValues(): DoubleVector;
+    getNativeCloseValues(): SCRTDoubleVector;
     /**
      * Appends a single X (Date), Open, High, Low, Close point to the DataSeries
      * @remarks
@@ -147,6 +147,7 @@ export declare class OhlcDataSeries extends BaseDataSeries {
      * @param high The new High value
      * @param low The new Low value
      * @param close The new Close value
+     * @param metadata The point metadata
      */
     updateXohlc(index: number, x: number, open: number, high: number, low: number, close: number, metadata?: IPointMetadata): void;
     /**

package/Charting/Model/OhlcDataSeries.js

@@ -20,7 +20,7 @@ var Deleter_1 = require("../../Core/Deleter");
 var Guard_1 = require("../../Core/Guard");
 var NumberRange_1 = require("../../Core/NumberRange");
 var NumberArray_1 = require("../../types/NumberArray");
-var fillDoubleVectorFromJsArray_1 = require("../../utils/ccall/fillDoubleVectorFromJsArray");
+var appendDoubleVectorFromJsArray_1 = require("../../utils/ccall/appendDoubleVectorFromJsArray");
 var animationHelpers_1 = require("../Visuals/RenderableSeries/Animations/animationHelpers");
 var BaseDataSeries_1 = require("./BaseDataSeries");
 var IDataSeries_1 = require("./IDataSeries");
@@ -50,15 +50,15 @@ var OhlcDataSeries = /** @class */ (function (_super) {
         var _this = _super.call(this, webAssemblyContext, options) || this;
         /** @inheritDoc */
         _this.type = IDataSeries_1.EDataSeriesType.Ohlc;
-        _this.openValues = new webAssemblyContext.DoubleVector();
-        _this.highValues = new webAssemblyContext.DoubleVector();
-        _this.lowValues = new webAssemblyContext.DoubleVector();
-        _this.openInitialAnimationValues = new webAssemblyContext.DoubleVector();
-        _this.highInitialAnimationValues = new webAssemblyContext.DoubleVector();
-        _this.lowInitialAnimationValues = new webAssemblyContext.DoubleVector();
-        _this.openFinalAnimationValues = new webAssemblyContext.DoubleVector();
-        _this.highFinalAnimationValues = new webAssemblyContext.DoubleVector();
-        _this.lowFinalAnimationValues = new webAssemblyContext.DoubleVector();
+        _this.openValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.highValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.lowValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.openInitialAnimationValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.highInitialAnimationValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.lowInitialAnimationValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.openFinalAnimationValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.highFinalAnimationValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.lowFinalAnimationValues = new webAssemblyContext.SCRTDoubleVector();
         if (options === null || options === void 0 ? void 0 : options.xValues) {
             _this.appendRange(options.xValues, options.openValues, options.highValues, options.lowValues, options.closeValues, options.metadata);
         }
@@ -104,9 +104,11 @@ var OhlcDataSeries = /** @class */ (function (_super) {
      */
     OhlcDataSeries.prototype.append = function (x, open, high, low, close, metadata) {
         if (!this.getIsDeleted()) {
+            var nativeX = this.getNativeXValues();
+            this.dataDistributionCalculator.onAppend(this.isSorted, this.containsNaN, nativeX, [x], [close]);
             // Push metadata should be done before push x values
             this.appendMetadata(metadata);
-            this.getNativeXValues().push_back(x);
+            nativeX.push_back(x);
             this.getNativeOpenValues().push_back(open);
             this.getNativeHighValues().push_back(high);
             this.getNativeLowValues().push_back(low);
@@ -146,19 +148,20 @@ var OhlcDataSeries = /** @class */ (function (_super) {
                 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 nativeOpen = this.getNativeOpenValues();
             var nativeHigh = this.getNativeHighValues();
             var nativeLow = this.getNativeLowValues();
             var nativeClose = this.getNativeCloseValues();
+            this.dataDistributionCalculator.onAppend(this.isSorted, this.containsNaN, nativeX, xValues, closeValues);
+            // Push metadata should be done before push x values
+            this.appendMetadataRange(metadata, xValues.length);
             // New implementation passing array from JS
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeX, xValues);
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeOpen, openValues);
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeHigh, highValues);
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeLow, lowValues);
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeClose, closeValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeX, xValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeOpen, openValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeHigh, highValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeLow, lowValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeClose, closeValues);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Append, null, xValues.length);
         }
     };
@@ -175,6 +178,7 @@ var OhlcDataSeries = /** @class */ (function (_super) {
     OhlcDataSeries.prototype.update = function (index, open, high, low, close, metadata) {
         if (!this.getIsDeleted()) {
             this.validateIndex(index);
+            this.dataDistributionCalculator.onUpdate(this.isSorted, this.containsNaN, undefined, undefined, [close], index);
             this.getNativeOpenValues().set(index, open);
             this.getNativeHighValues().set(index, high);
             this.getNativeLowValues().set(index, low);
@@ -192,10 +196,14 @@ var OhlcDataSeries = /** @class */ (function (_super) {
      * @param high The new High value
      * @param low The new Low value
      * @param close The new Close value
+     * @param metadata The point metadata
      */
     OhlcDataSeries.prototype.updateXohlc = function (index, x, open, high, low, close, 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], [close], index);
+            nativeX.set(index, x);
             this.getNativeOpenValues().set(index, open);
             this.getNativeHighValues().set(index, high);
             this.getNativeLowValues().set(index, low);
@@ -218,7 +226,9 @@ var OhlcDataSeries = /** @class */ (function (_super) {
     OhlcDataSeries.prototype.insert = function (startIndex, x, open, high, low, close, metadata) {
         if (!this.getIsDeleted()) {
             this.validateIndex(startIndex, "Start index is out of range");
-            this.getNativeXValues().insertAt(startIndex, x);
+            var nativeX = this.getNativeXValues();
+            this.dataDistributionCalculator.onInsert(this.isSorted, this.containsNaN, nativeX, [x], [close], startIndex);
+            nativeX.insertAt(startIndex, x);
             this.getNativeOpenValues().insertAt(startIndex, open);
             this.getNativeHighValues().insertAt(startIndex, high);
             this.getNativeLowValues().insertAt(startIndex, low);
@@ -257,20 +267,13 @@ var OhlcDataSeries = /** @class */ (function (_super) {
                 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 nativeOpen = this.getNativeOpenValues();
-            var nativeHigh = this.getNativeHighValues();
-            var nativeLow = this.getNativeLowValues();
-            var nativeY = this.getNativeCloseValues();
-            var tempStartIndex = startIndex;
-            for (var i = 0; i < rangeLength; i++, tempStartIndex++) {
-                nativeX.insertAt(tempStartIndex, xValues[i]);
-                nativeOpen.insertAt(tempStartIndex, openValues[i]);
-                nativeHigh.insertAt(tempStartIndex, highValues[i]);
-                nativeLow.insertAt(tempStartIndex, lowValues[i]);
-                nativeY.insertAt(tempStartIndex, closeValues[i]);
-            }
+            this.dataDistributionCalculator.onInsert(this.isSorted, this.containsNaN, nativeX, xValues, closeValues, startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, xValues, nativeX, startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, openValues, this.getNativeOpenValues(), startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, highValues, this.getNativeHighValues(), startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, lowValues, this.getNativeLowValues(), startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, closeValues, this.getNativeCloseValues(), startIndex);
             this.insertMetadataRange(startIndex, metadata);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Insert, startIndex, xValues.length);
         }
@@ -320,7 +323,7 @@ var OhlcDataSeries = /** @class */ (function (_super) {
      */
     OhlcDataSeries.prototype.clear = function () {
         if (!this.getIsDeleted()) {
-            this.getNativeIndexes().clear();
+            _super.prototype.clear.call(this);
             this.getNativeXValues().clear();
             this.getNativeOpenValues().clear();
             this.getNativeHighValues().clear();

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

@@ -0,0 +1,21 @@
+import { IDeletable } from "../../../Core/IDeletable";
+import { NumberRange } from "../../../Core/NumberRange";
+import { IntVector, SCRTDoubleVector, TSciChart } from "../../../types/TSciChart";
+import { IPointSeries, IPointSeriesResampled } from "./IPointSeries";
+export declare abstract class BasePointSeriesResampled implements IPointSeries, IPointSeriesResampled, IDeletable {
+    readonly intIndexes: IntVector;
+    readonly indexes: SCRTDoubleVector;
+    readonly xValues: SCRTDoubleVector;
+    readonly yValues: SCRTDoubleVector;
+    xRange: NumberRange;
+    protected wasmContext: TSciChart;
+    constructor(wasmContext: TSciChart, xRange: NumberRange);
+    get count(): number;
+    delete(): void;
+    /**
+     * Updates SCRTDoubleVector from IntVector
+     */
+    updateIndexes(): void;
+    clearIntIndexes(): void;
+    debugOutputForUnitTests(): void;
+}

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