scichart 2.0.2139 → 2.0.2185

package/Core/Animations/AnimationFiniteStateMachine.js

@@ -1,6 +1,21 @@
 "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.AnimationFiniteStateMachine = exports.EAnimationStateTransition = exports.EAnimationState = void 0;
+exports.SeriesAnimationFiniteStateMachine = exports.AnimationFiniteStateMachine = exports.EAnimationStateTransition = exports.EAnimationState = void 0;
 var NumberUtil_1 = require("../NumberUtil");
 var EAnimationState;
 (function (EAnimationState) {
@@ -19,12 +34,9 @@ var EAnimationStateTransition;
     EAnimationStateTransition["Running_Completed"] = "Running_Completed";
 })(EAnimationStateTransition = exports.EAnimationStateTransition || (exports.EAnimationStateTransition = {}));
 var AnimationFiniteStateMachine = /** @class */ (function () {
-    function AnimationFiniteStateMachine(animation, renderableSeries) {
+    function AnimationFiniteStateMachine(animation) {
         this.stateProperty = EAnimationState.InitialState;
         this.animationProperty = animation;
-        if (renderableSeries) {
-            this.initialStylesProperty = animation.getSeriesStyle(renderableSeries);
-        }
     }
     Object.defineProperty(AnimationFiniteStateMachine.prototype, "state", {
         /**
@@ -46,16 +58,6 @@ var AnimationFiniteStateMachine = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AnimationFiniteStateMachine.prototype, "initialStyles", {
-        /**
-         * Gets the initial styles for the animation
-         */
-        get: function () {
-            return this.initialStylesProperty;
-        },
-        enumerable: false,
-        configurable: true
-    });
     /**
      * Checks the current state
      * @param states
@@ -115,7 +117,7 @@ var AnimationFiniteStateMachine = /** @class */ (function () {
     };
     AnimationFiniteStateMachine.prototype.validate = function (from, to) {
         if (!from.includes(this.stateProperty)) {
-            throw Error("Transition from state " + this.stateProperty + " to " + to + " if forbidden");
+            throw Error("Transition from state ".concat(this.stateProperty, " to ").concat(to, " if forbidden"));
         }
     };
     AnimationFiniteStateMachine.prototype.toDelayed = function () {
@@ -147,3 +149,36 @@ var AnimationFiniteStateMachine = /** @class */ (function () {
     return AnimationFiniteStateMachine;
 }());
 exports.AnimationFiniteStateMachine = AnimationFiniteStateMachine;
+// tslint:disable-next-line: max-classes-per-file
+var SeriesAnimationFiniteStateMachine = /** @class */ (function (_super) {
+    __extends(SeriesAnimationFiniteStateMachine, _super);
+    function SeriesAnimationFiniteStateMachine(animation, renderableSeries) {
+        var _this = _super.call(this, animation) || this;
+        if (renderableSeries) {
+            _this.initialStylesProperty = animation.getSeriesStyle(renderableSeries);
+        }
+        return _this;
+    }
+    Object.defineProperty(SeriesAnimationFiniteStateMachine.prototype, "animation", {
+        /**
+         * Gets the animation property
+         */
+        get: function () {
+            return this.animationProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SeriesAnimationFiniteStateMachine.prototype, "initialStyles", {
+        /**
+         * Gets the initial styles for the animation
+         */
+        get: function () {
+            return this.initialStylesProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SeriesAnimationFiniteStateMachine;
+}(AnimationFiniteStateMachine));
+exports.SeriesAnimationFiniteStateMachine = SeriesAnimationFiniteStateMachine;

package/Core/Animations/Animator.d.ts

@@ -1,14 +1,6 @@
 import { AnimationToken } from "../AnimationToken";
 import { TEasingFn } from "./EasingFunctions";
 /**
- * @description A generic function for animating any value
- * @remarks See functions {@link DoubleAnimator.animate} and {@link NumberRangeAnimator.animate} for examples on how to use this
- * @param durationMs The duration of the animation in milliseconds
- * @param from The start value
- * @param to The end value
- * @param onAnimate A function which is called on animation step, with the current intermediate value passed in
- * @param interpolate An interpolation function
- * @param onCompleted A function which is called when animation is completed
- * @param easingFn An easing function. See {@link IEasingMap} for a list of values
+ * @deprecated Instead create an {@link GenericAnimation} and pass it to sciChartSurface.addAnimation
  */
 export declare function animateAny<T>(durationMs: number, from: T, to: T, onAnimate: (intermediateValue: T) => void, interpolate: (start: T, end: T, interpolationFactor: number) => T, onCompleted: () => void, easingFn: TEasingFn): AnimationToken;

package/Core/Animations/Animator.js

@@ -5,15 +5,7 @@ var AnimationToken_1 = require("../AnimationToken");
 var Guard_1 = require("../Guard");
 var NumberUtil_1 = require("../NumberUtil");
 /**
- * @description A generic function for animating any value
- * @remarks See functions {@link DoubleAnimator.animate} and {@link NumberRangeAnimator.animate} for examples on how to use this
- * @param durationMs The duration of the animation in milliseconds
- * @param from The start value
- * @param to The end value
- * @param onAnimate A function which is called on animation step, with the current intermediate value passed in
- * @param interpolate An interpolation function
- * @param onCompleted A function which is called when animation is completed
- * @param easingFn An easing function. See {@link IEasingMap} for a list of values
+ * @deprecated Instead create an {@link GenericAnimation} and pass it to sciChartSurface.addAnimation
  */
 function animateAny(durationMs, from, to, onAnimate, interpolate, onCompleted, easingFn) {
     Guard_1.Guard.notNull(onAnimate, "onAnimate");

package/Core/Animations/DoubleAnimator.d.ts

@@ -5,14 +5,8 @@ import { TEasingFn } from "./EasingFunctions";
  */
 export declare class DoubleAnimator {
     /**
-     * Animates a number with a start, to value over a specified duration and with an optional completed and easing function
-     * @param from The start value to animate
-     * @param to The end value to animate
-     * @param durationMs The duration of the animation in milliseconds
-     * @param onAnimate A callback function which is called with intermediate values
-     * @param onCompleted A callback function which is called when the animation completes
-     * @param easingFunction An optional easing function. See {@link IEasingMap} for a list of values
+     * @deprecated Instead create an {@link GenericAnimation} and pass it to sciChartSurface.addAnimation
      */
     static animate(from: number, to: number, durationMs: number, onAnimate: (value: number) => void, onCompleted: () => void, easingFunction?: TEasingFn): AnimationToken;
-    private static interpolate;
+    static interpolate(from: number, to: number, interpolationFactor: number): number;
 }

package/Core/Animations/DoubleAnimator.js

@@ -10,17 +10,11 @@ var DoubleAnimator = /** @class */ (function () {
     function DoubleAnimator() {
     }
     /**
-     * Animates a number with a start, to value over a specified duration and with an optional completed and easing function
-     * @param from The start value to animate
-     * @param to The end value to animate
-     * @param durationMs The duration of the animation in milliseconds
-     * @param onAnimate A callback function which is called with intermediate values
-     * @param onCompleted A callback function which is called when the animation completes
-     * @param easingFunction An optional easing function. See {@link IEasingMap} for a list of values
+     * @deprecated Instead create an {@link GenericAnimation} and pass it to sciChartSurface.addAnimation
      */
     DoubleAnimator.animate = function (from, to, durationMs, onAnimate, onCompleted, easingFunction) {
         if (easingFunction === void 0) { easingFunction = EasingFunctions_1.easing.outExpo; }
-        return Animator_1.animateAny(durationMs, from, to, onAnimate, DoubleAnimator.interpolate, onCompleted, easingFunction);
+        return (0, Animator_1.animateAny)(durationMs, from, to, onAnimate, DoubleAnimator.interpolate, onCompleted, easingFunction);
     };
     DoubleAnimator.interpolate = function (from, to, interpolationFactor) {
         var result = (to - from) * interpolationFactor + from;

package/Core/Animations/GenericAnimation.d.ts

@@ -0,0 +1,74 @@
+import { IAnimation } from "./AnimationFiniteStateMachine";
+import { TEasingFn } from "./EasingFunctions";
+/**
+ * Options passed to a {@link GenericAnimation} at construction time
+ */
+export interface IGenericAnimationOptions<T> {
+    /** An identifier for the animation.  Will be set to a Guid if not specified */
+    id?: string;
+    /** Time in ms before the animation is started.  Animations are advanced on each frame, so this time is a minimum, not exact. */
+    delay?: number;
+    /** Time in ms that the animation will run for. Animations are advanced on each frame, so this time is a minimum, not exact  */
+    duration?: number;
+    /** An easing function used to calculate progress */
+    ease?: TEasingFn | string;
+    /** The initial state of the animation parameter */
+    from: T;
+    /** The final state of the animation parameter */
+    to: T;
+    /**
+     * A function that is called each frame.  Update the target of the animation here. progress is between 0 and 1.
+     */
+    onAnimate: (from: T, to: T, progress: number) => void;
+    /**
+     * A function that is called after the animation has finished.
+     */
+    onCompleted?: () => void;
+}
+export interface IGenericAnimation extends IAnimation {
+    readonly id: string;
+    isComplete: boolean;
+    reset(): void;
+    update(timeElapsed: number): void;
+    cancel(): void;
+}
+/**
+ * @summary Defines Animations that can be applied directly to a {@link SciChartSurface} in SciChart's High Performance Real-time
+ * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
+ * @remarks
+ * When creating the animation, use the options to specify what to update
+ */
+export declare class GenericAnimation<T> implements IGenericAnimation {
+    /** The initial state of the animation parameter */
+    from: T;
+    /** The final state of the animation parameter */
+    to: T;
+    get isComplete(): boolean;
+    readonly id: string;
+    /**
+     * The animation delay
+     */
+    delay: number;
+    /**
+     * The animation duration
+     */
+    duration: number;
+    /**
+     * Sets the animation easing function
+     */
+    ease: TEasingFn;
+    /** The function that is called each frame.  Update the target of the animation here. progress is between 0 and 1. */
+    onAnimate: (from: T, to: T, progress: number) => void;
+    /** The function that is called after the animation has finished. */
+    onCompleted: () => void;
+    private animationFSM;
+    constructor(options: IGenericAnimationOptions<T>);
+    /** Reset the animation to its initial state.
+     * If reset while running or onCompleted, the animation will remain in the list and run again.
+     */
+    reset(): void;
+    /** Advance the animation according to the time elapsed since the last frame */
+    update(timeElapsed: number): void;
+    /** Cancel the animation.  onCompleted will not be called */
+    cancel(): void;
+}

package/Core/Animations/GenericAnimation.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericAnimation = void 0;
+var guid_1 = require("../../utils/guid");
+var AnimationFiniteStateMachine_1 = require("./AnimationFiniteStateMachine");
+var EasingFunctions_1 = require("./EasingFunctions");
+/**
+ * @summary Defines Animations that can be applied directly to a {@link SciChartSurface} in SciChart's High Performance Real-time
+ * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
+ * @remarks
+ * When creating the animation, use the options to specify what to update
+ */
+var GenericAnimation = /** @class */ (function () {
+    function GenericAnimation(options) {
+        var _a, _b, _c, _d;
+        /**
+         * The animation delay
+         */
+        this.delay = 0;
+        /**
+         * The animation duration
+         */
+        this.duration = 1000;
+        /**
+         * Sets the animation easing function
+         */
+        this.ease = EasingFunctions_1.easing.linear;
+        this.id = (_a = options === null || options === void 0 ? void 0 : options.id) !== null && _a !== void 0 ? _a : (0, guid_1.generateGuid)();
+        this.delay = (_b = options === null || options === void 0 ? void 0 : options.delay) !== null && _b !== void 0 ? _b : this.delay;
+        this.duration = (_c = options === null || options === void 0 ? void 0 : options.duration) !== null && _c !== void 0 ? _c : this.duration;
+        if ((options === null || options === void 0 ? void 0 : options.ease) && typeof options.ease === "string") {
+            options.ease = EasingFunctions_1.easing[options.ease];
+        }
+        this.ease = (_d = options === null || options === void 0 ? void 0 : options.ease) !== null && _d !== void 0 ? _d : this.ease;
+        this.from = options.from;
+        this.to = options.to;
+        this.onAnimate = options.onAnimate;
+        this.onCompleted = options === null || options === void 0 ? void 0 : options.onCompleted;
+        this.animationFSM = new AnimationFiniteStateMachine_1.AnimationFiniteStateMachine(this);
+    }
+    Object.defineProperty(GenericAnimation.prototype, "isComplete", {
+        get: function () {
+            return this.animationFSM.is([AnimationFiniteStateMachine_1.EAnimationState.Completed]);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** Reset the animation to its initial state.
+     * If reset while running or onCompleted, the animation will remain in the list and run again.
+     */
+    GenericAnimation.prototype.reset = function () {
+        this.animationFSM = new AnimationFiniteStateMachine_1.AnimationFiniteStateMachine(this);
+    };
+    /** Advance the animation according to the time elapsed since the last frame */
+    GenericAnimation.prototype.update = function (timeElapsed) {
+        var transition = this.animationFSM.update(timeElapsed);
+        if ([AnimationFiniteStateMachine_1.EAnimationStateTransition.InitialState_Running, AnimationFiniteStateMachine_1.EAnimationStateTransition.Delayed_Running].includes(transition)) {
+            this.onAnimate(this.from, this.to, 0);
+        }
+        if (this.animationFSM.is([AnimationFiniteStateMachine_1.EAnimationState.Running, AnimationFiniteStateMachine_1.EAnimationState.Completed])) {
+            this.onAnimate(this.from, this.to, this.animationFSM.animationProgress);
+        }
+        if ([AnimationFiniteStateMachine_1.EAnimationStateTransition.Running_Completed, AnimationFiniteStateMachine_1.EAnimationStateTransition.InitialState_Completed].includes(transition)) {
+            if (this.onCompleted)
+                this.onCompleted();
+        }
+    };
+    /** Cancel the animation.  onCompleted will not be called */
+    GenericAnimation.prototype.cancel = function () {
+        this.animationFSM.toCompleted();
+    };
+    return GenericAnimation;
+}());
+exports.GenericAnimation = GenericAnimation;

package/Core/Animations/NumberRangeAnimator.d.ts

@@ -1,6 +1,6 @@
-import { AnimationToken } from "../AnimationToken";
 import { NumberRange } from "../NumberRange";
 import { TEasingFn } from "./EasingFunctions";
+import { GenericAnimation } from "./GenericAnimation";
 /**
  * A class for animating a value of type {@link NumberRange}. Used throughout SciChart to animate
  * {@link AxisCore.visibleRange} when zooming or panning.
@@ -15,6 +15,7 @@ export declare class NumberRangeAnimator {
      * @param onCompleted A callback function which is called when the animation completes
      * @param easingFunction An optional easing function. See {@link IEasingMap} for a list of values
      */
-    static animate(from: NumberRange, to: NumberRange, durationMs: number, onAnimate: (value: NumberRange) => void, onCompleted: () => void, easingFunction?: TEasingFn): AnimationToken;
-    private static interpolate;
+    static animate(from: NumberRange, to: NumberRange, durationMs: number, onAnimate: (value: NumberRange) => void, onCompleted: () => void, easingFunction?: TEasingFn, isLog?: boolean): GenericAnimation<NumberRange>;
+    static interpolate(from: NumberRange, to: NumberRange, interpolationFactor: number): NumberRange;
+    static interpolateLog(from: NumberRange, to: NumberRange, interpolationFactor: number): NumberRange;
 }

package/Core/Animations/NumberRangeAnimator.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NumberRangeAnimator = void 0;
 var NumberRange_1 = require("../NumberRange");
-var Animator_1 = require("./Animator");
 var EasingFunctions_1 = require("./EasingFunctions");
+var GenericAnimation_1 = require("./GenericAnimation");
 /**
  * A class for animating a value of type {@link NumberRange}. Used throughout SciChart to animate
  * {@link AxisCore.visibleRange} when zooming or panning.
@@ -20,9 +20,23 @@ var NumberRangeAnimator = /** @class */ (function () {
      * @param onCompleted A callback function which is called when the animation completes
      * @param easingFunction An optional easing function. See {@link IEasingMap} for a list of values
      */
-    NumberRangeAnimator.animate = function (from, to, durationMs, onAnimate, onCompleted, easingFunction) {
+    NumberRangeAnimator.animate = function (from, to, durationMs, onAnimate, onCompleted, easingFunction, isLog) {
         if (easingFunction === void 0) { easingFunction = EasingFunctions_1.easing.outExpo; }
-        return Animator_1.animateAny(durationMs, from, to, onAnimate, NumberRangeAnimator.interpolate, onCompleted, easingFunction);
+        if (isLog === void 0) { isLog = false; }
+        var animation = new GenericAnimation_1.GenericAnimation({
+            from: from,
+            to: to,
+            duration: durationMs,
+            onAnimate: function (from, to, progress) {
+                var interpolate = isLog ? NumberRangeAnimator.interpolateLog : NumberRangeAnimator.interpolate;
+                var intermediate = interpolate(from, to, progress);
+                onAnimate(intermediate);
+            },
+            delay: 0,
+            ease: easingFunction,
+            onCompleted: onCompleted
+        });
+        return animation;
     };
     NumberRangeAnimator.interpolate = function (from, to, interpolationFactor) {
         var newMin = (to.min - from.min) * interpolationFactor + from.min;
@@ -30,6 +44,12 @@ var NumberRangeAnimator = /** @class */ (function () {
         var result = new NumberRange_1.NumberRange(newMin, newMax);
         return result;
     };
+    NumberRangeAnimator.interpolateLog = function (from, to, interpolationFactor) {
+        var newMin = Math.pow(to.min / from.min, interpolationFactor) * from.min;
+        var newMax = Math.pow(to.max / from.max, interpolationFactor) * from.max;
+        var result = new NumberRange_1.NumberRange(newMin, newMax);
+        return result;
+    };
     return NumberRangeAnimator;
 }());
 exports.NumberRangeAnimator = NumberRangeAnimator;

package/Core/Guard.js

@@ -42,7 +42,7 @@ var Guard = /** @class */ (function () {
         this.notNull(arg, name1);
         this.notNull(arg2, name2);
         if (arg.length !== arg2.length) {
-            throw new Error("Arrays " + name1 + " and " + name2 + " must have the same length");
+            throw new Error("Arrays ".concat(name1, " and ").concat(name2, " must have the same length"));
         }
     };
     /**
@@ -61,7 +61,7 @@ var Guard = /** @class */ (function () {
             var firstArgName_1 = args[0].name;
             args.forEach(function (el) {
                 if (el.arg.length !== firstArgLength_1) {
-                    throw new Error("Arrays " + firstArgName_1 + " and " + el.name + " must have the same length");
+                    throw new Error("Arrays ".concat(firstArgName_1, " and ").concat(el.name, " must have the same length"));
                 }
             });
         }
@@ -72,8 +72,8 @@ var Guard = /** @class */ (function () {
      * @param name
      */
     Guard.argumentIsRealNumber = function (d, name) {
-        if (!isRealNumber_1.isRealNumber(d)) {
-            throw new Error("Argument " + name + " must be a real number (not infinite, not NAN)");
+        if (!(0, isRealNumber_1.isRealNumber)(d)) {
+            throw new Error("Argument ".concat(name, " must be a real number (not infinite, not NAN)"));
         }
     };
     return Guard;

package/Core/Mouse/MouseManager.js

@@ -387,7 +387,7 @@ var MouseManager = /** @class */ (function () {
     Object.defineProperty(MouseManager.prototype, "chartModifierGroups", {
         get: function () {
             var arr = this.chartModifiers.filter(function (cm) { return cm.modifierGroup !== undefined; }).map(function (el) { return el.modifierGroup; });
-            return array_1.getUniqueValues(arr);
+            return (0, array_1.getUniqueValues)(arr);
         },
         enumerable: false,
         configurable: true

package/Core/NumberRange.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NumberRange = void 0;
-var app_1 = require("../constants/app");
 var isRealNumber_1 = require("../utils/isRealNumber");
 var math_1 = require("../utils/math");
 /**
@@ -57,17 +56,17 @@ var NumberRange = /** @class */ (function () {
             max = temp;
         }
         // If still zero, then expand around the zero line
-        if (Math.abs(max - min) <= app_1.EPSILON && Math.abs(min) <= app_1.EPSILON) {
-            min = -1.0;
-            max = 1.0;
-        }
+        // if (Math.abs(max - min) <= EPSILON && Math.abs(min) <= EPSILON) {
+        //     min = -1.0;
+        //     max = 1.0;
+        // }
         return new NumberRange(min, max);
     };
     NumberRange.prototype.growByLog = function (range, logBase) {
         // If NegativeLogarithmicAxis, negate ranges
         var mult = this.min < 0 ? -1 : 1;
-        var minExp = this.min !== 0 ? math_1.logToBase(Math.abs(this.min), logBase) : 0;
-        var maxExp = this.max !== 0 ? math_1.logToBase(Math.abs(this.max), logBase) : 0;
+        var minExp = this.min !== 0 ? (0, math_1.logToBase)(Math.abs(this.min), logBase) : 0;
+        var maxExp = this.max !== 0 ? (0, math_1.logToBase)(Math.abs(this.max), logBase) : 0;
         var expDiff = maxExp - minExp;
         var minExpDelta = expDiff * range.min;
         var maxExpDelta = expDiff * range.max;
@@ -84,7 +83,7 @@ var NumberRange = /** @class */ (function () {
      * Returns true if the range is defined (is a real number, not NaN, not infinite, and not undefined)
      */
     NumberRange.prototype.isDefined = function () {
-        return isRealNumber_1.isRealNumber(this.max) && isRealNumber_1.isRealNumber(this.min);
+        return (0, isRealNumber_1.isRealNumber)(this.max) && (0, isRealNumber_1.isRealNumber)(this.min);
     };
     /**
      * Returns true if the range equals another by value
@@ -100,7 +99,7 @@ var NumberRange = /** @class */ (function () {
      * Returns a string representation of a {@link NumberRange} for easy debugging
      */
     NumberRange.prototype.toString = function () {
-        return "NumberRange (" + this.min + ", " + this.max + ")";
+        return "NumberRange (".concat(this.min, ", ").concat(this.max, ")");
     };
     Object.defineProperty(NumberRange.prototype, "diff", {
         /**

package/Core/Point.js

@@ -10,7 +10,7 @@ var Point = /** @class */ (function () {
         this.y = y;
     }
     Point.prototype.toString = function () {
-        return "Point (" + this.x + ", " + this.y + ")";
+        return "Point (".concat(this.x, ", ").concat(this.y, ")");
     };
     return Point;
 }());