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

package/Charting/Model/UniformHeatmapDataSeries.d.ts

@@ -75,9 +75,9 @@ export declare class UniformHeatmapDataSeries extends BaseHeatmapDataSeries {
     /**
      * @inheritDoc
      */
-    protected getXRange(): NumberRange;
+    getXRange(): NumberRange;
     /**
      * @inheritDoc
      */
-    protected getYRange(): NumberRange;
+    getYRange(): NumberRange;
 }

package/Charting/Model/XyyDataSeries.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 XyDataSeries} constructor
@@ -34,14 +35,16 @@ export interface IXyyDataSeriesOptions extends IBaseDataSeriesOptions {
  * See derived types of {@link IRenderableSeries} to find out what 2D JavaScript Chart types are available.
  */
 export declare class XyyDataSeries extends BaseDataSeries {
+    /** @inheritDoc */
+    readonly type = EDataSeriesType.Xyy;
     /**
-     * @inheritDoc
+     * Y1 vector with initial animation values
      */
-    readonly type = EDataSeriesType.Xyy;
+    y1InitialAnimationValues: DoubleVector;
     /**
-     * Y1 values animation vector
+     * Y1 vector with final animation values
      */
-    y1AnimationValues: DoubleVector;
+    y1FinalAnimationValues: DoubleVector;
     protected y1Values: DoubleVector;
     /**
      * Creates an instance of {@link XyyDataSeries}
@@ -143,13 +146,19 @@ export declare class XyyDataSeries extends BaseDataSeries {
      * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
      */
     clear(): void;
-    /**
-     * @inheritDoc
-     */
-    getWindowedYRange(xRange: NumberRange, getPositiveRange: boolean, isXCategoryAxis?: boolean): NumberRange;
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
+    getWindowedYRange(xRange: NumberRange, getPositiveRange: boolean, isXCategoryAxis?: boolean, dataSeriesValueType?: EDataSeriesValueType): NumberRange;
+    /** @inheritDoc */
     delete(): void;
+    /** @inheritDoc */
+    setInitialAnimationVectors(dataSeries?: XyyDataSeries): void;
+    /** @inheritDoc */
+    setFinalAnimationVectors(dataSeries?: XyyDataSeries): void;
+    /** @inheritDoc */
+    validateAnimationVectors(): void;
+    /** @inheritDoc */
+    updateAnimationProperties(progress: number, animation: BaseAnimation): void;
+    /** @inheritDoc */
     toJSON(excludeData?: boolean): import("../../Builder/buildDataSeries").TSeriesDataDefinition;
+    private getYY1Values;
 }

package/Charting/Model/XyyDataSeries.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");
 /**
@@ -43,12 +44,11 @@ var XyyDataSeries = /** @class */ (function (_super) {
      */
     function XyyDataSeries(webAssemblyContext, options) {
         var _this = _super.call(this, webAssemblyContext, options) || this;
-        /**
-         * @inheritDoc
-         */
+        /** @inheritDoc */
         _this.type = IDataSeries_1.EDataSeriesType.Xyy;
         _this.y1Values = new webAssemblyContext.DoubleVector();
-        _this.y1AnimationValues = new webAssemblyContext.DoubleVector();
+        _this.y1InitialAnimationValues = new webAssemblyContext.DoubleVector();
+        _this.y1FinalAnimationValues = new webAssemblyContext.DoubleVector();
         if (options === null || options === void 0 ? void 0 : options.xValues) {
             Guard_1.Guard.notNull(options.yValues, "options.yValues");
             Guard_1.Guard.notNull(options.y1Values, "options.y1Values");
@@ -274,16 +274,16 @@ var XyyDataSeries = /** @class */ (function (_super) {
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Clear, null, null);
         }
     };
-    /**
-     * @inheritDoc
-     */
-    XyyDataSeries.prototype.getWindowedYRange = function (xRange, getPositiveRange, isXCategoryAxis) {
+    /** @inheritDoc */
+    XyyDataSeries.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.getYY1Values(dataSeriesValueType), yValues = _a.yValues, y1Values = _a.y1Values;
         // TODO: getPositiveRange
         // if one point
         if (this.count() === 1) {
-            var min = Math.min(this.yValues.get(0), this.y1Values.get(0)) - 1;
-            var max = Math.max(this.yValues.get(0), this.y1Values.get(0)) + 1;
+            var min = Math.min(yValues.get(0), y1Values.get(0)) - 1;
+            var max = Math.max(yValues.get(0), y1Values.get(0)) + 1;
             return new NumberRange_1.NumberRange(min, max);
         }
         var indicesRange = isXCategoryAxis ? xRange : this.getIndicesRange(xRange);
@@ -295,14 +295,14 @@ var XyyDataSeries = /** @class */ (function (_super) {
             return undefined;
         }
         for (var i = iMin; i <= iMax; i++) {
-            var yVal = this.yValues.get(i);
+            var yVal = yValues.get(i);
             if (yVal < yMin) {
                 yMin = yVal;
             }
             if (yVal > yMax) {
                 yMax = yVal;
             }
-            var y1Val = this.y1Values.get(i);
+            var y1Val = y1Values.get(i);
             if (y1Val < yMin) {
                 yMin = y1Val;
             }
@@ -312,14 +312,50 @@ var XyyDataSeries = /** @class */ (function (_super) {
         }
         return new NumberRange_1.NumberRange(yMin, yMax);
     };
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     XyyDataSeries.prototype.delete = function () {
         this.y1Values = Deleter_1.deleteSafe(this.y1Values);
-        this.y1AnimationValues = Deleter_1.deleteSafe(this.y1AnimationValues);
+        this.y1InitialAnimationValues = Deleter_1.deleteSafe(this.y1InitialAnimationValues);
+        this.y1FinalAnimationValues = Deleter_1.deleteSafe(this.y1FinalAnimationValues);
         _super.prototype.delete.call(this);
     };
+    /** @inheritDoc */
+    XyyDataSeries.prototype.setInitialAnimationVectors = function (dataSeries) {
+        _super.prototype.setInitialAnimationVectors.call(this, dataSeries);
+        if (!dataSeries) {
+            this.y1InitialAnimationValues.resize(0, 0);
+            return;
+        }
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeY1Values(), this.y1InitialAnimationValues);
+    };
+    /** @inheritDoc */
+    XyyDataSeries.prototype.setFinalAnimationVectors = function (dataSeries) {
+        _super.prototype.setFinalAnimationVectors.call(this, dataSeries);
+        if (!dataSeries) {
+            this.y1FinalAnimationValues.resize(0, 0);
+            return;
+        }
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeY1Values(), this.y1FinalAnimationValues);
+    };
+    /** @inheritDoc */
+    XyyDataSeries.prototype.validateAnimationVectors = function () {
+        _super.prototype.validateAnimationVectors.call(this);
+        var size = this.xInitialAnimationValues.size();
+        if (size !== this.y1InitialAnimationValues.size() || size !== this.y1FinalAnimationValues.size()) {
+            throw Error("initialAnimationValues and finalAnimationValues must have the same length");
+        }
+    };
+    /** @inheritDoc */
+    XyyDataSeries.prototype.updateAnimationProperties = function (progress, animation) {
+        _super.prototype.updateAnimationProperties.call(this, progress, animation);
+        if (animation.isOnStartAnimation) {
+            animation.calculateAnimationValues(this.webAssemblyContext, this.y1FinalAnimationValues, this.getNativeY1Values(), progress);
+        }
+        else if (animation.isDataSeriesAnimation) {
+            animation.calculateDataSeriesAnimationValues(this.webAssemblyContext, this.y1InitialAnimationValues, this.y1FinalAnimationValues, this.getNativeY1Values(), progress);
+        }
+    };
+    /** @inheritDoc */
     XyyDataSeries.prototype.toJSON = function (excludeData) {
         if (excludeData === void 0) { excludeData = false; }
         var json = _super.prototype.toJSON.call(this);
@@ -341,6 +377,24 @@ var XyyDataSeries = /** @class */ (function (_super) {
         }
         return json;
     };
+    XyyDataSeries.prototype.getYY1Values = function (dataSeriesValueType) {
+        var yValues;
+        var y1Values;
+        switch (dataSeriesValueType) {
+            case IDataSeries_1.EDataSeriesValueType.FinalAnimationValues:
+                yValues = this.yFinalAnimationValues;
+                y1Values = this.y1FinalAnimationValues;
+                break;
+            case IDataSeries_1.EDataSeriesValueType.InitialAnimationValues:
+                yValues = this.yInitialAnimationValues;
+                y1Values = this.y1InitialAnimationValues;
+                break;
+            default:
+                yValues = this.yValues;
+                y1Values = this.y1Values;
+        }
+        return { yValues: yValues, y1Values: y1Values };
+    };
     return XyyDataSeries;
 }(BaseDataSeries_1.BaseDataSeries));
 exports.XyyDataSeries = XyyDataSeries;

package/Charting/Model/XyzDataSeries.d.ts

@@ -1,4 +1,5 @@
 import { DoubleVector, TSciChart } from "../../types/TSciChart";
+import { BaseAnimation } from "../Visuals/RenderableSeries/Animations/BaseAnimation";
 import { BaseDataSeries, IBaseDataSeriesOptions } from "./BaseDataSeries";
 import { EDataSeriesType } from "./IDataSeries";
 import { IPointMetadata } from "./IPointMetadata";
@@ -33,10 +34,16 @@ export interface IXyzDataSeriesOptions extends IBaseDataSeriesOptions {
  * See derived types of {@link IRenderableSeries} to find out what 2D JavaScript Chart types are available.
  */
 export declare class XyzDataSeries extends BaseDataSeries {
+    /** @inheritDoc */
+    readonly type = EDataSeriesType.Xyz;
     /**
-     * @inheritDoc
+     * Z vector with initial animation values
      */
-    readonly type = EDataSeriesType.Xyz;
+    zInitialAnimationValues: DoubleVector;
+    /**
+     * Z vector with final animation values
+     */
+    zFinalAnimationValues: DoubleVector;
     protected zValues: DoubleVector;
     /**
      * Creates an instance of {@link XyzDataSeries}
@@ -138,9 +145,17 @@ export declare class XyzDataSeries extends BaseDataSeries {
      * Any changes of the DataSeries will trigger a redraw on the parent {@link SciChartSurface}
      */
     clear(): void;
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     delete(): void;
+    /** @inheritDoc */
+    setInitialAnimationVectors(dataSeries?: XyzDataSeries): void;
+    /** @inheritDoc */
+    setFinalAnimationVectors(dataSeries?: XyzDataSeries): void;
+    /** @inheritDoc */
+    validateAnimationVectors(): void;
+    /** @inheritDoc */
+    updateAnimationProperties(progress: number, animation: BaseAnimation): void;
+    /** @inheritDoc */
     toJSON(excludeData?: boolean): import("../../Builder/buildDataSeries").TSeriesDataDefinition;
+    private getYZValues;
 }

package/Charting/Model/XyzDataSeries.js

@@ -17,6 +17,7 @@ exports.XyzDataSeries = void 0;
 var Deleter_1 = require("../../Core/Deleter");
 var Guard_1 = require("../../Core/Guard");
 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");
 /**
@@ -42,11 +43,11 @@ var XyzDataSeries = /** @class */ (function (_super) {
      */
     function XyzDataSeries(webAssemblyContext, options) {
         var _this = _super.call(this, webAssemblyContext) || this;
-        /**
-         * @inheritDoc
-         */
+        /** @inheritDoc */
         _this.type = IDataSeries_1.EDataSeriesType.Xyz;
         _this.zValues = new webAssemblyContext.DoubleVector();
+        _this.zInitialAnimationValues = new webAssemblyContext.DoubleVector();
+        _this.zFinalAnimationValues = new webAssemblyContext.DoubleVector();
         if (options === null || options === void 0 ? void 0 : options.xValues) {
             Guard_1.Guard.notNull(options.yValues, "options.yValues");
             Guard_1.Guard.notNull(options.zValues, "options.zValues");
@@ -265,17 +266,54 @@ var XyzDataSeries = /** @class */ (function (_super) {
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Clear, null, null);
         }
     };
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     XyzDataSeries.prototype.delete = function () {
         this.zValues = Deleter_1.deleteSafe(this.zValues);
+        this.zInitialAnimationValues = Deleter_1.deleteSafe(this.zInitialAnimationValues);
+        this.zFinalAnimationValues = Deleter_1.deleteSafe(this.zFinalAnimationValues);
         _super.prototype.delete.call(this);
     };
+    /** @inheritDoc */
+    XyzDataSeries.prototype.setInitialAnimationVectors = function (dataSeries) {
+        _super.prototype.setInitialAnimationVectors.call(this, dataSeries);
+        if (!dataSeries) {
+            this.zInitialAnimationValues.resize(0, 0);
+            return;
+        }
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeZValues(), this.zInitialAnimationValues);
+    };
+    /** @inheritDoc */
+    XyzDataSeries.prototype.setFinalAnimationVectors = function (dataSeries) {
+        _super.prototype.setFinalAnimationVectors.call(this, dataSeries);
+        if (!dataSeries) {
+            this.zFinalAnimationValues.resize(0, 0);
+            return;
+        }
+        animationHelpers_1.animationHelpers.copyVector(dataSeries.getNativeZValues(), this.zFinalAnimationValues);
+    };
+    /** @inheritDoc */
+    XyzDataSeries.prototype.validateAnimationVectors = function () {
+        _super.prototype.validateAnimationVectors.call(this);
+        var size = this.xInitialAnimationValues.size();
+        if (size !== this.zInitialAnimationValues.size() || size !== this.zFinalAnimationValues.size()) {
+            throw Error("initialAnimationValues and finalAnimationValues must have the same length");
+        }
+    };
+    /** @inheritDoc */
+    XyzDataSeries.prototype.updateAnimationProperties = function (progress, animation) {
+        _super.prototype.updateAnimationProperties.call(this, progress, animation);
+        if (animation.isOnStartAnimation) {
+            animation.calculateAnimationValues(this.webAssemblyContext, this.zFinalAnimationValues, this.getNativeZValues(), progress, true);
+        }
+        else if (animation.isDataSeriesAnimation) {
+            animation.calculateDataSeriesAnimationValues(this.webAssemblyContext, this.zInitialAnimationValues, this.zFinalAnimationValues, this.getNativeZValues(), progress);
+        }
+    };
+    /** @inheritDoc */
     XyzDataSeries.prototype.toJSON = function (excludeData) {
         if (excludeData === void 0) { excludeData = false; }
         var json = _super.prototype.toJSON.call(this);
-        if (excludeData) {
+        if (!excludeData) {
             var xValues = [];
             var yValues = [];
             var zValues = [];
@@ -293,6 +331,24 @@ var XyzDataSeries = /** @class */ (function (_super) {
         }
         return json;
     };
+    XyzDataSeries.prototype.getYZValues = function (dataSeriesValueType) {
+        var yValues;
+        var zValues;
+        switch (dataSeriesValueType) {
+            case IDataSeries_1.EDataSeriesValueType.FinalAnimationValues:
+                yValues = this.yFinalAnimationValues;
+                zValues = this.zFinalAnimationValues;
+                break;
+            case IDataSeries_1.EDataSeriesValueType.InitialAnimationValues:
+                yValues = this.yInitialAnimationValues;
+                zValues = this.zInitialAnimationValues;
+                break;
+            default:
+                yValues = this.yValues;
+                zValues = this.zValues;
+        }
+        return { yValues: yValues, zValues: zValues };
+    };
     return XyzDataSeries;
 }(BaseDataSeries_1.BaseDataSeries));
 exports.XyzDataSeries = XyzDataSeries;

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

@@ -29,9 +29,33 @@ export declare class LogarithmicTickProvider extends TickProvider {
     private majorTickModeProperty;
     private minorTickModeProperty;
     constructor(wasmContext: TSciChart | TSciChart3D);
+    /**
+     * Gets or sets the mode for Major ticks using {@link ELogarithmicMajorTickMode}
+     * Equally spaced (best for large ranges) or
+     * Round numbers (better for small ranges)
+     */
     get majorTickMode(): ELogarithmicMajorTickMode;
+    /**
+     * Gets or sets the mode for Major ticks using {@link ELogarithmicMajorTickMode}
+     * Equally spaced (best for large ranges) or
+     * Round numbers (better for small ranges)
+     */
     set majorTickMode(mode: ELogarithmicMajorTickMode);
+    /**
+     * Gets or sets the mode for minor ticks using {@link ELogarithmicMinorTickMode},
+     * Linear (default, best for smaller ranges),
+     * Logarithmic (better for very large ranges) or
+     * Auto (switches from linear to Logarithmic when the visible range is such that
+     *  the first linear minor tick would be more than 70% of the major tick)
+     */
     get minorTickMode(): ELogarithmicMinorTickMode;
+    /**
+     * Gets or sets the mode for minor ticks using {@link ELogarithmicMinorTickMode},
+     * Linear (default, best for smaller ranges),
+     * Logarithmic (better for very large ranges) or
+     * Auto (switches from linear to Logarithmic when the visible range is such that
+     *  the first linear minor tick would be more than 70% of the major tick)
+     */
     set minorTickMode(mode: ELogarithmicMinorTickMode);
     getMajorTicks(minorDelta: number, majorDelta: number, visibleRange: NumberRange): number[];
     getRoundNumberMajorTicks(minorDelta: number, majorDelta: number, visibleRange: NumberRange): number[];

package/Charting/Numerics/TickProviders/LogarithmicTickProvider.js

@@ -52,9 +52,19 @@ var LogarithmicTickProvider = /** @class */ (function (_super) {
         return _this;
     }
     Object.defineProperty(LogarithmicTickProvider.prototype, "majorTickMode", {
+        /**
+         * Gets or sets the mode for Major ticks using {@link ELogarithmicMajorTickMode}
+         * Equally spaced (best for large ranges) or
+         * Round numbers (better for small ranges)
+         */
         get: function () {
             return this.majorTickModeProperty;
         },
+        /**
+         * Gets or sets the mode for Major ticks using {@link ELogarithmicMajorTickMode}
+         * Equally spaced (best for large ranges) or
+         * Round numbers (better for small ranges)
+         */
         set: function (mode) {
             var _a;
             this.majorTickModeProperty = mode;
@@ -66,9 +76,23 @@ var LogarithmicTickProvider = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(LogarithmicTickProvider.prototype, "minorTickMode", {
+        /**
+         * Gets or sets the mode for minor ticks using {@link ELogarithmicMinorTickMode},
+         * Linear (default, best for smaller ranges),
+         * Logarithmic (better for very large ranges) or
+         * Auto (switches from linear to Logarithmic when the visible range is such that
+         *  the first linear minor tick would be more than 70% of the major tick)
+         */
         get: function () {
             return this.minorTickModeProperty;
         },
+        /**
+         * Gets or sets the mode for minor ticks using {@link ELogarithmicMinorTickMode},
+         * Linear (default, best for smaller ranges),
+         * Logarithmic (better for very large ranges) or
+         * Auto (switches from linear to Logarithmic when the visible range is such that
+         *  the first linear minor tick would be more than 70% of the major tick)
+         */
         set: function (mode) {
             var _a;
             this.minorTickModeProperty = mode;
@@ -135,11 +159,9 @@ var LogarithmicTickProvider = /** @class */ (function (_super) {
         var minDiff = this.roundNum(min * (diff - 1));
         current = this.roundNum(current, minDiff);
         results.push(current);
-        //console.log(visibleRange, majorDelta, diff, minDiff, current);
         while (current <= max) {
             var nextDiff = current * (diff - 1);
             var next = this.roundNum(current * diff, nextDiff);
-            //console.log(current, nextDiff, next);
             var working = next;
             while (next === current) {
                 working = working * diff;
@@ -158,7 +180,7 @@ var LogarithmicTickProvider = /** @class */ (function (_super) {
             exponent = Math.min(exponent, Math.round(Math.log10(difference)));
         }
         // Fractional part of range
-        var figures = this.wasmContext.NumberUtil.RoundToDigits((value / Math.pow(10, exponent)), 1);
+        var figures = this.wasmContext.NumberUtil.RoundToDigits(value / Math.pow(10, exponent), 1);
         var base = Math.floor(figures);
         var fraction = figures - base;
         var niceFraction = NaN;
@@ -191,7 +213,7 @@ var LogarithmicTickProvider = /** @class */ (function (_super) {
         var logDiff = Math.pow(this.logarithmicBase, majorDelta);
         if (count > 0) {
             for (var index = 0; index <= count; index++) {
-                var upper = index < count ? majorTicks[index] : (majorTicks[index - 1] * logDiff);
+                var upper = index < count ? majorTicks[index] : majorTicks[index - 1] * logDiff;
                 var prev = Math.max(upper / logDiff, visibleRange.min);
                 var increment = prev * minorDelta;
                 if (minorLogMode) {