@tweenjs/tween.js 18.6.3 → 19.0.0

package/dist/tween.cjs.js

@@ -5,13 +5,22 @@ Object.defineProperty(exports, '__esModule', { value: true });
 /**
  * The Ease class provides a collection of easing functions for use with tween.js.
  */
-var Easing = {
-    Linear: {
+var Easing = Object.freeze({
+    Linear: Object.freeze({
         None: function (amount) {
             return amount;
         },
-    },
-    Quadratic: {
+        In: function (amount) {
+            return this.None(amount);
+        },
+        Out: function (amount) {
+            return this.None(amount);
+        },
+        InOut: function (amount) {
+            return this.None(amount);
+        },
+    }),
+    Quadratic: Object.freeze({
         In: function (amount) {
             return amount * amount;
         },
@@ -24,8 +33,8 @@ var Easing = {
             }
             return -0.5 * (--amount * (amount - 2) - 1);
         },
-    },
-    Cubic: {
+    }),
+    Cubic: Object.freeze({
         In: function (amount) {
             return amount * amount * amount;
         },
@@ -38,8 +47,8 @@ var Easing = {
             }
             return 0.5 * ((amount -= 2) * amount * amount + 2);
         },
-    },
-    Quartic: {
+    }),
+    Quartic: Object.freeze({
         In: function (amount) {
             return amount * amount * amount * amount;
         },
@@ -52,8 +61,8 @@ var Easing = {
             }
             return -0.5 * ((amount -= 2) * amount * amount * amount - 2);
         },
-    },
-    Quintic: {
+    }),
+    Quintic: Object.freeze({
         In: function (amount) {
             return amount * amount * amount * amount * amount;
         },
@@ -66,19 +75,19 @@ var Easing = {
             }
             return 0.5 * ((amount -= 2) * amount * amount * amount * amount + 2);
         },
-    },
-    Sinusoidal: {
+    }),
+    Sinusoidal: Object.freeze({
         In: function (amount) {
-            return 1 - Math.cos((amount * Math.PI) / 2);
+            return 1 - Math.sin(((1.0 - amount) * Math.PI) / 2);
         },
         Out: function (amount) {
             return Math.sin((amount * Math.PI) / 2);
         },
         InOut: function (amount) {
-            return 0.5 * (1 - Math.cos(Math.PI * amount));
+            return 0.5 * (1 - Math.sin(Math.PI * (0.5 - amount)));
         },
-    },
-    Exponential: {
+    }),
+    Exponential: Object.freeze({
         In: function (amount) {
             return amount === 0 ? 0 : Math.pow(1024, amount - 1);
         },
@@ -97,8 +106,8 @@ var Easing = {
             }
             return 0.5 * (-Math.pow(2, -10 * (amount - 1)) + 2);
         },
-    },
-    Circular: {
+    }),
+    Circular: Object.freeze({
         In: function (amount) {
             return 1 - Math.sqrt(1 - amount * amount);
         },
@@ -111,8 +120,8 @@ var Easing = {
             }
             return 0.5 * (Math.sqrt(1 - (amount -= 2) * amount) + 1);
         },
-    },
-    Elastic: {
+    }),
+    Elastic: Object.freeze({
         In: function (amount) {
             if (amount === 0) {
                 return 0;
@@ -144,15 +153,15 @@ var Easing = {
             }
             return 0.5 * Math.pow(2, -10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI) + 1;
         },
-    },
-    Back: {
+    }),
+    Back: Object.freeze({
         In: function (amount) {
             var s = 1.70158;
-            return amount * amount * ((s + 1) * amount - s);
+            return amount === 1 ? 1 : amount * amount * ((s + 1) * amount - s);
         },
         Out: function (amount) {
             var s = 1.70158;
-            return --amount * amount * ((s + 1) * amount + s) + 1;
+            return amount === 0 ? 0 : --amount * amount * ((s + 1) * amount + s) + 1;
         },
         InOut: function (amount) {
             var s = 1.70158 * 1.525;
@@ -161,8 +170,8 @@ var Easing = {
             }
             return 0.5 * ((amount -= 2) * amount * ((s + 1) * amount + s) + 2);
         },
-    },
-    Bounce: {
+    }),
+    Bounce: Object.freeze({
         In: function (amount) {
             return 1 - Easing.Bounce.Out(1 - amount);
         },
@@ -186,8 +195,27 @@ var Easing = {
             }
             return Easing.Bounce.Out(amount * 2 - 1) * 0.5 + 0.5;
         },
+    }),
+    generatePow: function (power) {
+        if (power === void 0) { power = 4; }
+        power = power < Number.EPSILON ? Number.EPSILON : power;
+        power = power > 10000 ? 10000 : power;
+        return {
+            In: function (amount) {
+                return Math.pow(amount, power);
+            },
+            Out: function (amount) {
+                return 1 - Math.pow((1 - amount), power);
+            },
+            InOut: function (amount) {
+                if (amount < 0.5) {
+                    return Math.pow((amount * 2), power) / 2;
+                }
+                return (1 - Math.pow((2 - amount * 2), power)) / 2 + 0.5;
+            },
+        };
     },
-};
+});
 
 var now;
 // Include a performance.now polyfill.
@@ -400,8 +428,10 @@ var Tween = /** @class */ (function () {
         this._startTime = 0;
         this._easingFunction = Easing.Linear.None;
         this._interpolationFunction = Interpolation.Linear;
+        // eslint-disable-next-line
         this._chainedTweens = [];
         this._onStartCallbackFired = false;
+        this._onEveryStartCallbackFired = false;
         this._id = Sequence.nextId();
         this._isChainStopped = false;
         this._goToEnd = false;
@@ -427,10 +457,13 @@ var Tween = /** @class */ (function () {
         return this;
     };
     Tween.prototype.duration = function (d) {
+        if (d === void 0) { d = 1000; }
         this._duration = d;
         return this;
     };
-    Tween.prototype.start = function (time) {
+    Tween.prototype.start = function (time, overrideStartingValues) {
+        if (time === void 0) { time = now$1(); }
+        if (overrideStartingValues === void 0) { overrideStartingValues = false; }
         if (this._isPlaying) {
             return this;
         }
@@ -449,13 +482,17 @@ var Tween = /** @class */ (function () {
         this._isPlaying = true;
         this._isPaused = false;
         this._onStartCallbackFired = false;
+        this._onEveryStartCallbackFired = false;
         this._isChainStopped = false;
-        this._startTime = time !== undefined ? (typeof time === 'string' ? now$1() + parseFloat(time) : time) : now$1();
+        this._startTime = time;
         this._startTime += this._delayTime;
-        this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat);
+        this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat, overrideStartingValues);
         return this;
     };
-    Tween.prototype._setupProperties = function (_object, _valuesStart, _valuesEnd, _valuesStartRepeat) {
+    Tween.prototype.startFromCurrentValues = function (time) {
+        return this.start(time, true);
+    };
+    Tween.prototype._setupProperties = function (_object, _valuesStart, _valuesEnd, _valuesStartRepeat, overrideStartingValues) {
         for (var property in _valuesEnd) {
             var startValue = _object[property];
             var startValueIsArray = Array.isArray(startValue);
@@ -475,7 +512,9 @@ var Tween = /** @class */ (function () {
                 // handle an array of relative values
                 endValues = endValues.map(this._handleRelativeValue.bind(this, startValue));
                 // Create a local copy of the Array with the start value at the front
-                _valuesEnd[property] = [startValue].concat(endValues);
+                if (_valuesStart[property] === undefined) {
+                    _valuesEnd[property] = [startValue].concat(endValues);
+                }
             }
             // handle the deepness of the values
             if ((propType === 'object' || startValueIsArray) && startValue && !isInterpolationList) {
@@ -489,11 +528,11 @@ var Tween = /** @class */ (function () {
                 _valuesStartRepeat[property] = startValueIsArray ? [] : {}; // TODO? repeat nested values? And yoyo? And array values?
                 // eslint-disable-next-line
                 // @ts-ignore FIXME?
-                this._setupProperties(startValue, _valuesStart[property], _valuesEnd[property], _valuesStartRepeat[property]);
+                this._setupProperties(startValue, _valuesStart[property], _valuesEnd[property], _valuesStartRepeat[property], overrideStartingValues);
             }
             else {
-                // Save the starting value, but only once.
-                if (typeof _valuesStart[property] === 'undefined') {
+                // Save the starting value, but only once unless override is requested.
+                if (typeof _valuesStart[property] === 'undefined' || overrideStartingValues) {
                     _valuesStart[property] = startValue;
                 }
                 if (!startValueIsArray) {
@@ -564,14 +603,17 @@ var Tween = /** @class */ (function () {
         return this;
     };
     Tween.prototype.group = function (group) {
+        if (group === void 0) { group = mainGroup; }
         this._group = group;
         return this;
     };
     Tween.prototype.delay = function (amount) {
+        if (amount === void 0) { amount = 0; }
         this._delayTime = amount;
         return this;
     };
     Tween.prototype.repeat = function (times) {
+        if (times === void 0) { times = 0; }
         this._initialRepeat = times;
         this._repeat = times;
         return this;
@@ -581,17 +623,21 @@ var Tween = /** @class */ (function () {
         return this;
     };
     Tween.prototype.yoyo = function (yoyo) {
+        if (yoyo === void 0) { yoyo = false; }
         this._yoyo = yoyo;
         return this;
     };
     Tween.prototype.easing = function (easingFunction) {
+        if (easingFunction === void 0) { easingFunction = Easing.Linear.None; }
         this._easingFunction = easingFunction;
         return this;
     };
     Tween.prototype.interpolation = function (interpolationFunction) {
+        if (interpolationFunction === void 0) { interpolationFunction = Interpolation.Linear; }
         this._interpolationFunction = interpolationFunction;
         return this;
     };
+    // eslint-disable-next-line
     Tween.prototype.chain = function () {
         var tweens = [];
         for (var _i = 0; _i < arguments.length; _i++) {
@@ -604,6 +650,10 @@ var Tween = /** @class */ (function () {
         this._onStartCallback = callback;
         return this;
     };
+    Tween.prototype.onEveryStart = function (callback) {
+        this._onEveryStartCallback = callback;
+        return this;
+    };
     Tween.prototype.onUpdate = function (callback) {
         this._onUpdateCallback = callback;
         return this;
@@ -637,7 +687,7 @@ var Tween = /** @class */ (function () {
             if (time > endTime)
                 return false;
             if (autoStart)
-                this.start(time);
+                this.start(time, true);
         }
         this._goToEnd = false;
         if (time < this._startTime) {
@@ -649,6 +699,12 @@ var Tween = /** @class */ (function () {
             }
             this._onStartCallbackFired = true;
         }
+        if (this._onEveryStartCallbackFired === false) {
+            if (this._onEveryStartCallback) {
+                this._onEveryStartCallback(this._object);
+            }
+            this._onEveryStartCallbackFired = true;
+        }
         elapsed = (time - this._startTime) / this._duration;
         elapsed = this._duration === 0 || elapsed > 1 ? 1 : elapsed;
         var value = this._easingFunction(elapsed);
@@ -687,6 +743,7 @@ var Tween = /** @class */ (function () {
                 if (this._onRepeatCallback) {
                     this._onRepeatCallback(this._object);
                 }
+                this._onEveryStartCallbackFired = false;
                 return true;
             }
             else {
@@ -696,7 +753,7 @@ var Tween = /** @class */ (function () {
                 for (var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++) {
                     // Make the chained tweens start exactly at the time they should,
                     // even if the `update()` method was called way past the duration of the tween
-                    this._chainedTweens[i].start(this._startTime + this._duration);
+                    this._chainedTweens[i].start(this._startTime + this._duration, false);
                 }
                 this._isPlaying = false;
                 return false;
@@ -748,10 +805,9 @@ var Tween = /** @class */ (function () {
     };
     Tween.prototype._swapEndStartRepeatValues = function (property) {
         var tmp = this._valuesStartRepeat[property];
-        if (typeof this._valuesEnd[property] === 'string') {
-            // eslint-disable-next-line
-            // @ts-ignore FIXME?
-            this._valuesStartRepeat[property] = this._valuesStartRepeat[property] + parseFloat(this._valuesEnd[property]);
+        var endValue = this._valuesEnd[property];
+        if (typeof endValue === 'string') {
+            this._valuesStartRepeat[property] = this._valuesStartRepeat[property] + parseFloat(endValue);
         }
         else {
             this._valuesStartRepeat[property] = this._valuesEnd[property];
@@ -761,7 +817,7 @@ var Tween = /** @class */ (function () {
     return Tween;
 }());
 
-var VERSION = '18.6.3';
+var VERSION = '19.0.0';
 
 /**
  * Tween.js - Licensed under the MIT license

package/dist/tween.d.ts

@@ -1,62 +1,28 @@
 declare type EasingFunction = (amount: number) => number;
+declare type EasingFunctionGroup = {
+    In: EasingFunction;
+    Out: EasingFunction;
+    InOut: EasingFunction;
+};
 /**
  * The Ease class provides a collection of easing functions for use with tween.js.
  */
-declare const Easing: {
-    Linear: {
-        None: (amount: number) => number;
-    };
-    Quadratic: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-    Cubic: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-    Quartic: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-    Quintic: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-    Sinusoidal: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-    Exponential: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-    Circular: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-    Elastic: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-    Back: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-    Bounce: {
-        In: (amount: number) => number;
-        Out: (amount: number) => number;
-        InOut: (amount: number) => number;
-    };
-};
+declare const Easing: Readonly<{
+    Linear: Readonly<EasingFunctionGroup & {
+        None: EasingFunction;
+    }>;
+    Quadratic: Readonly<EasingFunctionGroup>;
+    Cubic: Readonly<EasingFunctionGroup>;
+    Quartic: Readonly<EasingFunctionGroup>;
+    Quintic: Readonly<EasingFunctionGroup>;
+    Sinusoidal: Readonly<EasingFunctionGroup>;
+    Exponential: Readonly<EasingFunctionGroup>;
+    Circular: Readonly<EasingFunctionGroup>;
+    Elastic: Readonly<EasingFunctionGroup>;
+    Back: Readonly<EasingFunctionGroup>;
+    Bounce: Readonly<EasingFunctionGroup>;
+    generatePow(power?: number): EasingFunctionGroup;
+}>;
 
 /**
  *
@@ -99,6 +65,8 @@ declare class Tween<T extends UnknownProps> {
     private _chainedTweens;
     private _onStartCallback?;
     private _onStartCallbackFired;
+    private _onEveryStartCallback?;
+    private _onEveryStartCallbackFired;
     private _onUpdateCallback?;
     private _onRepeatCallback?;
     private _onCompleteCallback?;
@@ -110,27 +78,29 @@ declare class Tween<T extends UnknownProps> {
     isPlaying(): boolean;
     isPaused(): boolean;
     to(properties: UnknownProps, duration?: number): this;
-    duration(d: number): this;
-    start(time?: number): this;
+    duration(d?: number): this;
+    start(time?: number, overrideStartingValues?: boolean): this;
+    startFromCurrentValues(time?: number): this;
     private _setupProperties;
     stop(): this;
     end(): this;
     pause(time?: number): this;
     resume(time?: number): this;
     stopChainedTweens(): this;
-    group(group: Group): this;
-    delay(amount: number): this;
-    repeat(times: number): this;
-    repeatDelay(amount: number): this;
-    yoyo(yoyo: boolean): this;
-    easing(easingFunction: EasingFunction): this;
-    interpolation(interpolationFunction: InterpolationFunction): this;
-    chain(...tweens: Array<Tween<UnknownProps>>): this;
-    onStart(callback: (object: T) => void): this;
-    onUpdate(callback: (object: T, elapsed: number) => void): this;
-    onRepeat(callback: (object: T) => void): this;
-    onComplete(callback: (object: T) => void): this;
-    onStop(callback: (object: T) => void): this;
+    group(group?: Group): this;
+    delay(amount?: number): this;
+    repeat(times?: number): this;
+    repeatDelay(amount?: number): this;
+    yoyo(yoyo?: boolean): this;
+    easing(easingFunction?: EasingFunction): this;
+    interpolation(interpolationFunction?: InterpolationFunction): this;
+    chain(...tweens: Array<Tween<any>>): this;
+    onStart(callback?: (object: T) => void): this;
+    onEveryStart(callback?: (object: T) => void): this;
+    onUpdate(callback?: (object: T, elapsed: number) => void): this;
+    onRepeat(callback?: (object: T) => void): this;
+    onComplete(callback?: (object: T) => void): this;
+    onStop(callback?: (object: T) => void): this;
     private _goToEnd;
     /**
      * @returns true if the tween is still playing after the update, false
@@ -142,7 +112,7 @@ declare class Tween<T extends UnknownProps> {
     private _handleRelativeValue;
     private _swapEndStartRepeatValues;
 }
-declare type UnknownProps = Record<string, unknown>;
+declare type UnknownProps = Record<string, any>;
 
 /**
  * Controlling groups of tweens
@@ -170,70 +140,31 @@ declare class Sequence {
     static nextId(): number;
 }
 
-declare const VERSION = "18.6.3";
+declare const VERSION = "19.0.0";
 
 declare const nextId: typeof Sequence.nextId;
-declare const getAll: () => Tween<Record<string, unknown>>[];
+declare const getAll: () => Tween<Record<string, any>>[];
 declare const removeAll: () => void;
-declare const add: (tween: Tween<Record<string, unknown>>) => void;
-declare const remove: (tween: Tween<Record<string, unknown>>) => void;
+declare const add: (tween: Tween<Record<string, any>>) => void;
+declare const remove: (tween: Tween<Record<string, any>>) => void;
 declare const update: (time?: number, preserve?: boolean) => boolean;
 declare const exports: {
-    Easing: {
-        Linear: {
-            None: (amount: number) => number;
-        };
-        Quadratic: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-        Cubic: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-        Quartic: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-        Quintic: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-        Sinusoidal: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-        Exponential: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-        Circular: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-        Elastic: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-        Back: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-        Bounce: {
-            In: (amount: number) => number;
-            Out: (amount: number) => number;
-            InOut: (amount: number) => number;
-        };
-    };
+    Easing: Readonly<{
+        Linear: Readonly<EasingFunctionGroup & {
+            None: EasingFunction;
+        }>;
+        Quadratic: Readonly<EasingFunctionGroup>;
+        Cubic: Readonly<EasingFunctionGroup>;
+        Quartic: Readonly<EasingFunctionGroup>;
+        Quintic: Readonly<EasingFunctionGroup>;
+        Sinusoidal: Readonly<EasingFunctionGroup>;
+        Exponential: Readonly<EasingFunctionGroup>;
+        Circular: Readonly<EasingFunctionGroup>;
+        Elastic: Readonly<EasingFunctionGroup>;
+        Back: Readonly<EasingFunctionGroup>;
+        Bounce: Readonly<EasingFunctionGroup>;
+        generatePow(power?: number): EasingFunctionGroup;
+    }>;
     Group: typeof Group;
     Interpolation: {
         Linear: (v: number[], k: number) => number;
@@ -251,10 +182,10 @@ declare const exports: {
     nextId: typeof Sequence.nextId;
     Tween: typeof Tween;
     VERSION: string;
-    getAll: () => Tween<Record<string, unknown>>[];
+    getAll: () => Tween<Record<string, any>>[];
     removeAll: () => void;
-    add: (tween: Tween<Record<string, unknown>>) => void;
-    remove: (tween: Tween<Record<string, unknown>>) => void;
+    add: (tween: Tween<Record<string, any>>) => void;
+    remove: (tween: Tween<Record<string, any>>) => void;
     update: (time?: number, preserve?: boolean) => boolean;
 };