scichart 2.0.2139 → 2.0.2144

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,13 +10,7 @@ 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; }

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 : 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/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,10 +56,10 @@ 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) {