scichart 2.0.0-alpha.1930 → 2.0.0-alpha.1991

package/Charting/Model/Filters/XyyScaleOffsetFilter.js

@@ -12,8 +12,20 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XyyScaleOffsetFilter = void 0;
+var DataFilterType_1 = require("../../../types/DataFilterType");
 var XyyCustomFilter_1 = require("./XyyCustomFilter");
 var XyyScaleOffsetFilter = /** @class */ (function (_super) {
     __extends(XyyScaleOffsetFilter, _super);
@@ -51,6 +63,15 @@ var XyyScaleOffsetFilter = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    // @ts-ignore
+    XyyScaleOffsetFilter.prototype.toJSON = function (excludeData) {
+        if (excludeData === void 0) { excludeData = false; }
+        var original = this.originalSeries.toJSON(excludeData);
+        return __assign(__assign({}, original), { filter: {
+                type: DataFilterType_1.EDataFilterType.XyyScaleOffset,
+                options: { yfield: this.yfield, y1field: this.y1field, scale: this.scale, offset: this.offset }
+            } });
+    };
     XyyScaleOffsetFilter.prototype.filterFunctionProperty = function (index, y) {
         return y * this.scaleProperty + this.offsetProperty;
     };

package/Charting/Model/Filters/XyzScaleOffsetFilter.d.ts

@@ -1,3 +1,4 @@
+import { EDataFilterType } from "../../../types/DataFilterType";
 import { BaseDataSeries } from "../BaseDataSeries";
 import { XyzCustomFilter } from "./XyzCustomFilter";
 import { IXyzFilterOptions } from "./XyzFilterBase";
@@ -13,5 +14,120 @@ export declare class XyzScaleOffsetFilter extends XyzCustomFilter {
     get offset(): number;
     set offset(value: number);
     constructor(originalSeries: BaseDataSeries, options?: IXyzScaleOffsetFilterOptions);
+    toJSON(excludeData?: boolean): {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                zfield: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                zfield: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        y1DataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        y1Values?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                zfield: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        zDataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        zValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                zfield: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        openDataId?: string | number;
+        highDataId?: string | number;
+        lowDataId?: string | number;
+        closeDataId?: string | number;
+        xValues?: number[];
+        openValues?: number[];
+        highValues?: number[];
+        lowValues?: number[];
+        closeValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                zfield: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xStart: number;
+        xStep: number;
+        yStart: number;
+        yStep: number;
+        dataSeriesName?: string;
+        zValues?: number[][];
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[][] | {
+            type: string;
+            data?: any;
+        };
+    };
     protected filterFunctionProperty(index: number, y: number): number;
 }

package/Charting/Model/Filters/XyzScaleOffsetFilter.js

@@ -12,8 +12,20 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XyzScaleOffsetFilter = void 0;
+var DataFilterType_1 = require("../../../types/DataFilterType");
 var XyzCustomFilter_1 = require("./XyzCustomFilter");
 var XyzScaleOffsetFilter = /** @class */ (function (_super) {
     __extends(XyzScaleOffsetFilter, _super);
@@ -51,6 +63,15 @@ var XyzScaleOffsetFilter = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    // @ts-ignore
+    XyzScaleOffsetFilter.prototype.toJSON = function (excludeData) {
+        if (excludeData === void 0) { excludeData = false; }
+        var original = this.originalSeries.toJSON(excludeData);
+        return __assign(__assign({}, original), { filter: {
+                type: DataFilterType_1.EDataFilterType.XyzScaleOffset,
+                options: { yfield: this.yfield, zfield: this.zfield, scale: this.scale, offset: this.offset }
+            } });
+    };
     XyzScaleOffsetFilter.prototype.filterFunctionProperty = function (index, y) {
         return y * this.scaleProperty + this.offsetProperty;
     };

package/Charting/Model/IDataSeries.d.ts

@@ -1,4 +1,3 @@
-import { TSeriesDataDefinition } from "../../Builder/buildDataSeries";
 import { EventHandler } from "../../Core/EventHandler";
 import { IDeletable } from "../../Core/IDeletable";
 import { NumberRange } from "../../Core/NumberRange";
@@ -39,6 +38,16 @@ export declare enum EDataChangeType {
     Clear = 4,
     Property = 5
 }
+/**
+ * Defines what values to use when dealing with an {@link IDataSeries}
+ * For example, when getWindowedYRange() is called we can use Default values, which are xValues and yValues
+ * or if an animation is running we can use InitialAnimationValues or FinalAnimationValues
+ */
+export declare enum EDataSeriesValueType {
+    Default = "Default",
+    InitialAnimationValues = "InitialAnimationValues",
+    FinalAnimationValues = "FinalAnimationValues"
+}
 export interface IDataChangeArgs {
     changeType: EDataChangeType;
     index?: number;
@@ -129,6 +138,11 @@ export interface IDataSeries extends IDeletable {
      * Returns true if this DataSeries has been deleted and native memory destroyed
      */
     getIsDeleted(): boolean;
+    /**
+     * Gets the range in the X-direction for this DataSeries
+     * @param dataSeriesValueType The data series values to use {@link EDataSeriesValueType}
+     */
+    getXRange(dataSeriesValueType?: EDataSeriesValueType): NumberRange;
     /**
      * Gets the Y-range of the data within the specified X-Range: a 'windowed'
      * Y-range used for zooming into series on the {@link SciChartSurface}
@@ -136,11 +150,12 @@ export interface IDataSeries extends IDeletable {
      * @param getPositiveRange When true, return the positive part of the Y-range only
      * @param isCategoryAxis When true, treat the XAxis as a {@link CategoryAxis} -
      * an axis type which measures by x-index not x-value
+     * @param dataSeriesValueType The data series values to use {@link EDataSeriesValueType}
      */
-    getWindowedYRange(xRange: NumberRange, getPositiveRange: boolean, isCategoryAxis: boolean): NumberRange;
+    getWindowedYRange(xRange: NumberRange, getPositiveRange: boolean, isCategoryAxis: boolean, dataSeriesValueType?: EDataSeriesValueType): NumberRange;
     /**
      * Convert the object to a definition that can be serialized to JSON, or used directly with the builder api
      * @param excludeData if set true, data values will not be included in the json.
      */
-    toJSON(excludeData?: boolean): TSeriesDataDefinition;
+    toJSON(excludeData?: boolean): any;
 }

package/Charting/Model/IDataSeries.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EDataChangeType = exports.EDataSeriesType = void 0;
+exports.EDataSeriesValueType = exports.EDataChangeType = exports.EDataSeriesType = void 0;
 /**
  * Defines {@link BaseDataSeries | DataSeries} types available within SciChart's
  * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
@@ -39,3 +39,14 @@ var EDataChangeType;
     EDataChangeType[EDataChangeType["Clear"] = 4] = "Clear";
     EDataChangeType[EDataChangeType["Property"] = 5] = "Property";
 })(EDataChangeType = exports.EDataChangeType || (exports.EDataChangeType = {}));
+/**
+ * Defines what values to use when dealing with an {@link IDataSeries}
+ * For example, when getWindowedYRange() is called we can use Default values, which are xValues and yValues
+ * or if an animation is running we can use InitialAnimationValues or FinalAnimationValues
+ */
+var EDataSeriesValueType;
+(function (EDataSeriesValueType) {
+    EDataSeriesValueType["Default"] = "Default";
+    EDataSeriesValueType["InitialAnimationValues"] = "InitialAnimationValues";
+    EDataSeriesValueType["FinalAnimationValues"] = "FinalAnimationValues";
+})(EDataSeriesValueType = exports.EDataSeriesValueType || (exports.EDataSeriesValueType = {}));

package/Charting/Model/IPaletteProvider.d.ts

@@ -1,4 +1,4 @@
-import { TPalletProviderDefinition } from "../../Builder/buildSeries";
+import { TPaletteProviderDefinition } from "../../Builder/buildSeries";
 import { IRenderableSeries } from "../Visuals/RenderableSeries/IRenderableSeries";
 import { IPointMetadata } from "./IPointMetadata";
 /**
@@ -20,7 +20,7 @@ export interface IPaletteProvider {
      */
     onDetached(): void;
     /** Convert the object to a definition that can be serialized to JSON, or used directly with the builder api */
-    toJSON?(): TPalletProviderDefinition;
+    toJSON?(): TPaletteProviderDefinition;
 }
 export declare enum EStrokePaletteMode {
     GRADIENT = "GRADIENT",
@@ -36,7 +36,7 @@ export interface IStrokePaletteProvider extends IPaletteProvider {
     /**
      * Gets the stroke palette mode
      */
-    readonly strokePaletteMode: EStrokePaletteMode;
+    strokePaletteMode: EStrokePaletteMode;
     /**
      * Called by SciChart and may be used to override the color of a line segment or
      * stroke outline in various chart types.
@@ -64,7 +64,7 @@ export interface IFillPaletteProvider extends IPaletteProvider {
     /**
      * Gets the stroke palette mode
      */
-    readonly fillPaletteMode: EFillPaletteMode;
+    fillPaletteMode: EFillPaletteMode;
     /**
      * Called by SciChart and may be used to override the color of filled polygon in various chart types.
      * @remarks WARNING: CALLED PER-VERTEX, MAY RESULT IN PERFORMANCE DEGREDATION IF COMPLEX CODE EXECUTED HERE
@@ -92,7 +92,7 @@ export interface IPointMarkerPaletteProvider extends IPaletteProvider {
     /**
      * Gets the stroke palette mode
      */
-    readonly strokePaletteMode: EStrokePaletteMode;
+    strokePaletteMode: EStrokePaletteMode;
     /**
      * Called by SciChart and may be used to override the color of fill/stroke on pointmarkers
      * WARNING: CALLED PER-VERTEX, MAY RESULT IN PERFORMANCE DEGREDATION IF COMPLEX CODE EXECUTED HERE
@@ -120,8 +120,8 @@ export interface IPointMarkerPaletteProvider extends IPaletteProvider {
  */
 export declare class DefaultPaletteProvider implements IStrokePaletteProvider, IFillPaletteProvider, IPointMarkerPaletteProvider {
     static createEmpty(): DefaultPaletteProvider;
-    readonly strokePaletteMode: EStrokePaletteMode;
-    readonly fillPaletteMode: EFillPaletteMode;
+    strokePaletteMode: EStrokePaletteMode;
+    fillPaletteMode: EFillPaletteMode;
     /**
      * @inheritDoc
      */
@@ -142,5 +142,5 @@ export declare class DefaultPaletteProvider implements IStrokePaletteProvider, I
      * @inheritDoc
      */
     overridePointMarkerArgb(xValue: number, yValue: number, index: number, opacity?: number, metadata?: IPointMetadata): TPointMarkerArgb;
-    toJSON(): TPalletProviderDefinition;
+    toJSON(): TPaletteProviderDefinition;
 }

package/Charting/Model/OhlcDataSeries.d.ts

@@ -1,7 +1,8 @@
 import { NumberRange } from "../../Core/NumberRange";
 import { DoubleVector, TSciChart } from "../../types/TSciChart";
+import { BaseAnimation } from "../Visuals/RenderableSeries/Animations/BaseAnimation";
 import { BaseDataSeries, IBaseDataSeriesOptions } from "./BaseDataSeries";
-import { EDataSeriesType } from "./IDataSeries";
+import { EDataSeriesType, EDataSeriesValueType } from "./IDataSeries";
 import { IPointMetadata } from "./IPointMetadata";
 /**
  * Options to pass to the {@link OhlcDataSeries} constructor
@@ -43,10 +44,32 @@ export interface IOhlcDataSeriesOptions extends IBaseDataSeriesOptions {
  * See derived types of {@link IRenderableSeries} to find out what 2D JavaScript Chart types are available.
  */
 export declare class OhlcDataSeries extends BaseDataSeries {
+    /** @inheritDoc */
+    readonly type = EDataSeriesType.Ohlc;
     /**
-     * @inheritDoc
+     * Open vector with initial animation values
      */
-    readonly type = EDataSeriesType.Ohlc;
+    openInitialAnimationValues: DoubleVector;
+    /**
+     * Open vector with final animation values
+     */
+    openFinalAnimationValues: DoubleVector;
+    /**
+     * High vector with initial animation values
+     */
+    highInitialAnimationValues: DoubleVector;
+    /**
+     * High vector with final animation values
+     */
+    highFinalAnimationValues: DoubleVector;
+    /**
+     * Low vector with initial animation values
+     */
+    lowInitialAnimationValues: DoubleVector;
+    /**
+     * Low vector with final animation values
+     */
+    lowFinalAnimationValues: DoubleVector;
     private openValues;
     private highValues;
     private lowValues;
@@ -171,13 +194,19 @@ export declare class OhlcDataSeries extends BaseDataSeries {
      * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
      */
     clear(): void;
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     delete(): void;
-    /**
-     * @inheritDoc
-     */
-    getWindowedYRange(xRange: NumberRange, getPositiveRange: boolean, isXCategoryAxis?: boolean): NumberRange;
+    /** @inheritDoc */
+    getWindowedYRange(xRange: NumberRange, getPositiveRange: boolean, isXCategoryAxis?: boolean, dataSeriesValueType?: EDataSeriesValueType): NumberRange;
+    /** @inheritDoc */
+    setInitialAnimationVectors(dataSeries?: OhlcDataSeries): void;
+    /** @inheritDoc */
+    setFinalAnimationVectors(dataSeries?: OhlcDataSeries): void;
+    /** @inheritDoc */
+    validateAnimationVectors(): void;
+    /** @inheritDoc */
+    updateAnimationProperties(progress: number, animation: BaseAnimation): void;
+    /** @inheritDoc */
     toJSON(excludeData?: boolean): import("../../Builder/buildDataSeries").TSeriesDataDefinition;
+    private getOHLCValues;
 }

package/Charting/Model/OhlcDataSeries.js

@@ -18,6 +18,7 @@ var Deleter_1 = require("../../Core/Deleter");
 var Guard_1 = require("../../Core/Guard");
 var NumberRange_1 = require("../../Core/NumberRange");
 var fillDoubleVectorFromJsArray_1 = require("../../utils/ccall/fillDoubleVectorFromJsArray");
+var animationHelpers_1 = require("../Visuals/RenderableSeries/Animations/animationHelpers");
 var BaseDataSeries_1 = require("./BaseDataSeries");
 var IDataSeries_1 = require("./IDataSeries");
 /**
@@ -44,13 +45,17 @@ var OhlcDataSeries = /** @class */ (function (_super) {
      */
     function OhlcDataSeries(webAssemblyContext, options) {
         var _this = _super.call(this, webAssemblyContext, options) || this;
-        /**
-         * @inheritDoc
-         */
+        /** @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();
         if (options === null || options === void 0 ? void 0 : options.xValues) {
             _this.appendRange(options.xValues, options.openValues, options.highValues, options.lowValues, options.closeValues, options.metadata);
         }
@@ -322,27 +327,27 @@ var OhlcDataSeries = /** @class */ (function (_super) {
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Clear, null, null);
         }
     };
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     OhlcDataSeries.prototype.delete = function () {
-        this.indexes = Deleter_1.deleteSafe(this.indexes);
-        this.xValues = Deleter_1.deleteSafe(this.xValues);
         this.openValues = Deleter_1.deleteSafe(this.openValues);
         this.highValues = Deleter_1.deleteSafe(this.highValues);
         this.lowValues = Deleter_1.deleteSafe(this.lowValues);
-        this.yValues = Deleter_1.deleteSafe(this.yValues);
-        this.setMetadata(undefined);
-        this.isDeleted = true;
+        this.openInitialAnimationValues = Deleter_1.deleteSafe(this.openInitialAnimationValues);
+        this.openInitialAnimationValues = Deleter_1.deleteSafe(this.openInitialAnimationValues);
+        this.openInitialAnimationValues = Deleter_1.deleteSafe(this.openInitialAnimationValues);
+        this.openFinalAnimationValues = Deleter_1.deleteSafe(this.openFinalAnimationValues);
+        this.openFinalAnimationValues = Deleter_1.deleteSafe(this.openFinalAnimationValues);
+        this.openFinalAnimationValues = Deleter_1.deleteSafe(this.openFinalAnimationValues);
+        _super.prototype.delete.call(this);
     };
-    /**
-     * @inheritDoc
-     */
-    OhlcDataSeries.prototype.getWindowedYRange = function (xRange, getPositiveRange, isXCategoryAxis) {
+    /** @inheritDoc */
+    OhlcDataSeries.prototype.getWindowedYRange = function (xRange, getPositiveRange, isXCategoryAxis, dataSeriesValueType) {
         if (isXCategoryAxis === void 0) { isXCategoryAxis = false; }
+        if (dataSeriesValueType === void 0) { dataSeriesValueType = IDataSeries_1.EDataSeriesValueType.Default; }
+        var _a = this.getOHLCValues(dataSeriesValueType), closeValues = _a.closeValues, highValues = _a.highValues, lowValues = _a.lowValues;
         if (this.count() === 1) {
-            var min = this.yValues.get(0) - 1;
-            var max = this.yValues.get(0) + 1;
+            var min = closeValues.get(0) - 1;
+            var max = closeValues.get(0) + 1;
             return new NumberRange_1.NumberRange(min, max);
         }
         var indicesRange = isXCategoryAxis ? xRange : this.getIndicesRange(xRange);
@@ -354,8 +359,8 @@ var OhlcDataSeries = /** @class */ (function (_super) {
             return undefined;
         }
         for (var i = iMin; i <= iMax; i++) {
-            var highVal = this.highValues.get(i);
-            var lowVal = this.lowValues.get(i);
+            var highVal = highValues.get(i);
+            var lowVal = lowValues.get(i);
             if (lowVal < yMin) {
                 yMin = lowVal;
             }
@@ -365,6 +370,62 @@ var OhlcDataSeries = /** @class */ (function (_super) {
         }
         return new NumberRange_1.NumberRange(yMin, yMax);
     };
+    /** @inheritDoc */
+    OhlcDataSeries.prototype.setInitialAnimationVectors = function (dataSeries) {
+        _super.prototype.setInitialAnimationVectors.call(this, dataSeries);
+        if (!dataSeries) {
+            this.openInitialAnimationValues.resize(0, 0);
+            this.highInitialAnimationValues.resize(0, 0);
+            this.lowInitialAnimationValues.resize(0, 0);
+            return;
+        }
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeOpenValues(), this.openInitialAnimationValues);
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeHighValues(), this.highInitialAnimationValues);
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeLowValues(), this.lowInitialAnimationValues);
+    };
+    /** @inheritDoc */
+    OhlcDataSeries.prototype.setFinalAnimationVectors = function (dataSeries) {
+        _super.prototype.setFinalAnimationVectors.call(this, dataSeries);
+        if (!dataSeries) {
+            this.openFinalAnimationValues.resize(0, 0);
+            this.highFinalAnimationValues.resize(0, 0);
+            this.lowFinalAnimationValues.resize(0, 0);
+            return;
+        }
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeOpenValues(), this.openFinalAnimationValues);
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeHighValues(), this.highFinalAnimationValues);
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeLowValues(), this.lowFinalAnimationValues);
+    };
+    /** @inheritDoc */
+    OhlcDataSeries.prototype.validateAnimationVectors = function () {
+        var size = this.xInitialAnimationValues.size();
+        if (size !== this.yInitialAnimationValues.size() ||
+            size !== this.openInitialAnimationValues.size() ||
+            size !== this.highInitialAnimationValues.size() ||
+            size !== this.lowInitialAnimationValues.size() ||
+            size !== this.xFinalAnimationValues.size() ||
+            size !== this.yFinalAnimationValues.size() ||
+            size !== this.openFinalAnimationValues.size() ||
+            size !== this.highFinalAnimationValues.size() ||
+            size !== this.lowFinalAnimationValues.size()) {
+            throw Error("initialAnimationValues and finalAnimationValues must have the same length");
+        }
+    };
+    /** @inheritDoc */
+    OhlcDataSeries.prototype.updateAnimationProperties = function (progress, animation) {
+        _super.prototype.updateAnimationProperties.call(this, progress, animation);
+        if (animation.isOnStartAnimation) {
+            animation.calculateAnimationValues(this.webAssemblyContext, this.openFinalAnimationValues, this.getNativeOpenValues(), progress);
+            animation.calculateAnimationValues(this.webAssemblyContext, this.highFinalAnimationValues, this.getNativeHighValues(), progress);
+            animation.calculateAnimationValues(this.webAssemblyContext, this.lowFinalAnimationValues, this.getNativeLowValues(), progress);
+        }
+        else if (animation.isDataSeriesAnimation) {
+            animation.calculateDataSeriesAnimationValues(this.webAssemblyContext, this.openInitialAnimationValues, this.openFinalAnimationValues, this.getNativeOpenValues(), progress);
+            animation.calculateDataSeriesAnimationValues(this.webAssemblyContext, this.highInitialAnimationValues, this.highFinalAnimationValues, this.getNativeHighValues(), progress);
+            animation.calculateDataSeriesAnimationValues(this.webAssemblyContext, this.lowInitialAnimationValues, this.lowFinalAnimationValues, this.getNativeLowValues(), progress);
+        }
+    };
+    /** @inheritDoc */
     OhlcDataSeries.prototype.toJSON = function (excludeData) {
         if (excludeData === void 0) { excludeData = false; }
         var json = _super.prototype.toJSON.call(this);
@@ -392,6 +453,32 @@ var OhlcDataSeries = /** @class */ (function (_super) {
         }
         return json;
     };
+    OhlcDataSeries.prototype.getOHLCValues = function (dataSeriesValueType) {
+        var openValues;
+        var highValues;
+        var lowValues;
+        var closeValues;
+        switch (dataSeriesValueType) {
+            case IDataSeries_1.EDataSeriesValueType.FinalAnimationValues:
+                openValues = this.openFinalAnimationValues;
+                highValues = this.highFinalAnimationValues;
+                lowValues = this.lowFinalAnimationValues;
+                closeValues = this.yFinalAnimationValues;
+                break;
+            case IDataSeries_1.EDataSeriesValueType.InitialAnimationValues:
+                openValues = this.openInitialAnimationValues;
+                highValues = this.highInitialAnimationValues;
+                lowValues = this.lowInitialAnimationValues;
+                closeValues = this.yInitialAnimationValues;
+                break;
+            default:
+                openValues = this.openValues;
+                highValues = this.highValues;
+                lowValues = this.lowValues;
+                closeValues = this.yValues;
+        }
+        return { openValues: openValues, highValues: highValues, lowValues: lowValues, closeValues: closeValues };
+    };
     return OhlcDataSeries;
 }(BaseDataSeries_1.BaseDataSeries));
 exports.OhlcDataSeries = OhlcDataSeries;