@tweenjs/tween.js 18.6.4 → 20.0.0

package/dist/tween.d.ts

@@ -1,67 +1,33 @@
-declare type EasingFunction = (amount: number) => number;
+type EasingFunction = (amount: number) => number;
+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;
+}>;
 
 /**
  *
  */
-declare type InterpolationFunction = (v: number[], k: number) => number;
+type InterpolationFunction = (v: number[], k: number) => number;
 /**
  *
  */
@@ -77,6 +43,31 @@ declare const Interpolation: {
     };
 };
 
+/**
+ * Controlling groups of tweens
+ *
+ * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
+ * In these cases, you may want to create your own smaller groups of tween
+ */
+declare class Group {
+    private _tweens;
+    private _tweensAddedDuringUpdate;
+    getAll(): Array<Tween<UnknownProps>>;
+    removeAll(): void;
+    add(tween: Tween<UnknownProps>): void;
+    remove(tween: Tween<UnknownProps>): void;
+    update(time?: number, preserve?: boolean): boolean;
+}
+
+/**
+ * Tween.js - Licensed under the MIT license
+ * https://github.com/tweenjs/tween.js
+ * ----------------------------------------------
+ *
+ * See https://github.com/tweenjs/tween.js/graphs/contributors for the full list of contributors.
+ * Thank you all, you're awesome!
+ */
+
 declare class Tween<T extends UnknownProps> {
     private _object;
     private _group;
@@ -86,6 +77,7 @@ declare class Tween<T extends UnknownProps> {
     private _valuesEnd;
     private _valuesStartRepeat;
     private _duration;
+    private _isDynamic;
     private _initialRepeat;
     private _repeat;
     private _repeatDelayTime?;
@@ -99,38 +91,44 @@ declare class Tween<T extends UnknownProps> {
     private _chainedTweens;
     private _onStartCallback?;
     private _onStartCallbackFired;
+    private _onEveryStartCallback?;
+    private _onEveryStartCallbackFired;
     private _onUpdateCallback?;
     private _onRepeatCallback?;
     private _onCompleteCallback?;
     private _onStopCallback?;
     private _id;
     private _isChainStopped;
+    private _propertiesAreSetUp;
     constructor(_object: T, _group?: Group | false);
     getId(): number;
     isPlaying(): boolean;
     isPaused(): boolean;
-    to(properties: UnknownProps, duration?: number): this;
-    duration(d: number): this;
-    start(time?: number): this;
+    to(target: UnknownProps, duration?: number): this;
+    duration(duration?: number): this;
+    dynamic(dynamic?: boolean): 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,25 +140,9 @@ declare class Tween<T extends UnknownProps> {
     private _handleRelativeValue;
     private _swapEndStartRepeatValues;
 }
-declare type UnknownProps = Record<string, any>;
+type UnknownProps = Record<string, any>;
 
-/**
- * Controlling groups of tweens
- *
- * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
- * In these cases, you may want to create your own smaller groups of tween
- */
-declare class Group {
-    private _tweens;
-    private _tweensAddedDuringUpdate;
-    getAll(): Array<Tween<UnknownProps>>;
-    removeAll(): void;
-    add(tween: Tween<UnknownProps>): void;
-    remove(tween: Tween<UnknownProps>): void;
-    update(time?: number, preserve?: boolean): boolean;
-}
-
-declare let now: () => number;
+declare const now: () => number;
 
 /**
  * Utils
@@ -170,70 +152,32 @@ declare class Sequence {
     static nextId(): number;
 }
 
-declare const VERSION = "18.6.4";
+declare const VERSION = "20.0.0";
 
 declare const nextId: typeof Sequence.nextId;
-declare const getAll: () => Tween<Record<string, any>>[];
+declare const getAll: () => Tween<UnknownProps>[];
 declare const removeAll: () => void;
-declare const add: (tween: Tween<Record<string, any>>) => void;
-declare const remove: (tween: Tween<Record<string, any>>) => void;
+declare const add: (tween: Tween<UnknownProps>) => void;
+declare const remove: (tween: Tween<UnknownProps>) => 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,12 +195,11 @@ declare const exports: {
     nextId: typeof Sequence.nextId;
     Tween: typeof Tween;
     VERSION: string;
-    getAll: () => Tween<Record<string, any>>[];
+    getAll: () => Tween<UnknownProps>[];
     removeAll: () => void;
-    add: (tween: Tween<Record<string, any>>) => void;
-    remove: (tween: Tween<Record<string, any>>) => void;
+    add: (tween: Tween<UnknownProps>) => void;
+    remove: (tween: Tween<UnknownProps>) => void;
     update: (time?: number, preserve?: boolean) => boolean;
 };
 
-export default exports;
-export { Easing, Group, Interpolation, Sequence, Tween, VERSION, add, getAll, nextId, now, remove, removeAll, update };
+export { Easing, Group, Interpolation, Sequence, Tween, VERSION, add, exports as default, getAll, nextId, now, remove, removeAll, update };