@tweenjs/tween.js 18.3.2 → 18.6.0

package/README.md

@@ -15,28 +15,29 @@ Do you use tween.js? If you have some time, please fill out [this short survey](
 ---
 
 ```javascript
-const box = document.createElement('div');
-box.style.setProperty('background-color', '#008800');
-box.style.setProperty('width', '100px');
-box.style.setProperty('height', '100px');
-document.body.appendChild(box);
+const box = document.createElement('div')
+box.style.setProperty('background-color', '#008800')
+box.style.setProperty('width', '100px')
+box.style.setProperty('height', '100px')
+document.body.appendChild(box)
 
 // Setup the animation loop.
 function animate(time) {
-    requestAnimationFrame(animate);
-    TWEEN.update(time);
+	requestAnimationFrame(animate)
+	TWEEN.update(time)
 }
-requestAnimationFrame(animate);
+requestAnimationFrame(animate)
 
-const coords = { x: 0, y: 0 }; // Start at (0, 0)
+const coords = {x: 0, y: 0} // Start at (0, 0)
 const tween = new TWEEN.Tween(coords) // Create a new tween that modifies 'coords'.
-        .to({ x: 300, y: 200 }, 1000) // Move to (300, 200) in 1 second.
-        .easing(TWEEN.Easing.Quadratic.Out) // Use an easing function to make the animation smooth.
-        .onUpdate(() => { // Called after tween.js updates 'coords'.
-            // Move 'box' to the position described by 'coords' with a CSS translation.
-            box.style.setProperty('transform', `translate(${coords.x}px, ${coords.y}px)`);
-        })
-        .start(); // Start the tween immediately.
+	.to({x: 300, y: 200}, 1000) // Move to (300, 200) in 1 second.
+	.easing(TWEEN.Easing.Quadratic.Out) // Use an easing function to make the animation smooth.
+	.onUpdate(() => {
+		// Called after tween.js updates 'coords'.
+		// Move 'box' to the position described by 'coords' with a CSS translation.
+		box.style.setProperty('transform', `translate(${coords.x}px, ${coords.y}px)`)
+	})
+	.start() // Start the tween immediately.
 ```
 
 [Test it with CodePen](https://codepen.io/mikebolt/pen/zzzvZg)
@@ -54,10 +55,10 @@ npm run build
 
 This will create some builds in the `dist` directory. There are currently four different builds of the library:
 
- - UMD : tween.umd.js
- - AMD : tween.amd.js
- - CommonJS : tween.cjs.js
- - ES6 Module : tween.es.js
+- UMD : tween.umd.js
+- AMD : tween.amd.js
+- CommonJS : tween.cjs.js
+- ES6 Module : tween.es.js
 
 You are now able to copy tween.umd.js into your project, then include it with
 a script tag. This will add TWEEN to the global scope.
@@ -77,25 +78,25 @@ npm i @tweenjs/tween.js@^18
 If you are using Node, Webpack, or Browserify, then you can now use the following to include tween.js:
 
 ```javascript
-const TWEEN = require('@tweenjs/tween.js');
+const TWEEN = require('@tweenjs/tween.js')
 ```
 
 ## Features
 
-* Does one thing and one thing only: tween properties
-* Doesn't take care of CSS units (e.g. appending `px`)
-* Doesn't interpolate colours
-* Easing functions are reusable outside of Tween
-* Can also use custom easing functions
+- Does one thing and one thing only: tween properties
+- Doesn't take care of CSS units (e.g. appending `px`)
+- Doesn't interpolate colours
+- Easing functions are reusable outside of Tween
+- Can also use custom easing functions
 
 ## Documentation
 
-* [User guide](./docs/user_guide.md)
-* [Contributor guide](./docs/contributor_guide.md)
-* [Tutorial](http://learningthreejs.com/blog/2011/08/17/tweenjs-for-smooth-animation/)  using tween.js with three.js
-* Also: [libtween](https://github.com/jsm174/libtween), a port of tween.js to C by [jsm174](https://github.com/jsm174)
-* Also: [es6-tween](https://github.com/tweenjs/es6-tween), a port of tween.js to ES6/Harmony by [dalisoft](https://github.com/dalisoft)
-* [Understanding tween.js](https://mikebolt.me/article/understanding-tweenjs.html)
+- [User guide](./docs/user_guide.md)
+- [Contributor guide](./docs/contributor_guide.md)
+- [Tutorial](http://learningthreejs.com/blog/2011/08/17/tweenjs-for-smooth-animation/) using tween.js with three.js
+- Also: [libtween](https://github.com/jsm174/libtween), a port of tween.js to C by [jsm174](https://github.com/jsm174)
+- Also: [es6-tween](https://github.com/tweenjs/es6-tween), a port of tween.js to ES6/Harmony by [dalisoft](https://github.com/dalisoft)
+- [Understanding tween.js](https://mikebolt.me/article/understanding-tweenjs.html)
 
 ## Examples
 
@@ -249,7 +250,7 @@ npm test
 
 every time you want to run the tests.
 
-If you want to add any feature or change existing features, you *must* run the tests to make sure you didn't break anything else. If you send a pull request (PR) to add something new and it doesn't have tests, or the tests don't pass, the PR won't be accepted. See [contributing](CONTRIBUTING.md) for more information.
+If you want to add any feature or change existing features, you _must_ run the tests to make sure you didn't break anything else. If you send a pull request (PR) to add something new and it doesn't have tests, or the tests don't pass, the PR won't be accepted. See [contributing](CONTRIBUTING.md) for more information.
 
 ## People
 
@@ -280,4 +281,3 @@ Maintainers: [mikebolt](https://github.com/mikebolt), [sole](https://github.com/
 [flattr-url]: https://flattr.com/thing/45014/tween-js
 [cdnjs-image]: https://img.shields.io/cdnjs/v/tween.js.svg
 [cdnjs-url]: https://cdnjs.com/libraries/tween.js
-

package/dist/index.d.ts

@@ -0,0 +1,273 @@
+declare module "TWEEN" {
+
+    type EasingFunction = (amount: number) => number;
+
+    /**
+     * The Ease class provides a collection of easing functions for use with tween.js.
+     */
+    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;
+        };
+    };
+
+    let NOW: () => number;
+
+    /**
+     *
+     */
+    type InterpolationFunction = (v: number[], k: number) => number;
+
+    /**
+     *
+     */
+    const Interpolation: {
+        Linear: (v: number[], k: number) => number;
+        Bezier: (v: number[], k: number) => number;
+        CatmullRom: (v: number[], k: number) => number;
+        Utils: {
+            Linear: (p0: number, p1: number, t: number) => number;
+            Bernstein: (n: number, i: number) => number;
+            Factorial: (n: number) => number;
+            CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
+        };
+    };
+
+    /**
+     * Utils
+     */
+    class Sequence {
+        private static _nextId;
+        static nextId(): number;
+    }
+
+    const VERSION = "18.6.0";
+
+    /**
+     * 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
+     */
+    class Main extends Group {
+        version: string;
+        now: () => number;
+        Group: typeof Group;
+        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;
+            };
+        };
+        Interpolation: {
+            Linear: (v: number[], k: number) => number;
+            Bezier: (v: number[], k: number) => number;
+            CatmullRom: (v: number[], k: number) => number;
+            Utils: {
+                Linear: (p0: number, p1: number, t: number) => number;
+                Bernstein: (n: number, i: number) => number;
+                Factorial: (n: number) => number;
+                CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
+            };
+        };
+        nextId: typeof Sequence.nextId;
+        Tween: typeof Tween;
+    }
+
+    const TWEEN: Main;
+
+    /**
+     * 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!
+     */
+    
+    
+    
+    class Tween<T extends UnknownProps> {
+        private _object;
+        private _group;
+        private _isPaused;
+        private _pauseStart;
+        private _valuesStart;
+        private _valuesEnd;
+        private _valuesStartRepeat;
+        private _duration;
+        private _initialRepeat;
+        private _repeat;
+        private _repeatDelayTime?;
+        private _yoyo;
+        private _isPlaying;
+        private _reversed;
+        private _delayTime;
+        private _startTime;
+        private _easingFunction;
+        private _interpolationFunction;
+        private _chainedTweens;
+        private _onStartCallback?;
+        private _onStartCallbackFired;
+        private _onUpdateCallback?;
+        private _onRepeatCallback?;
+        private _onCompleteCallback?;
+        private _onStopCallback?;
+        private _id;
+        private _isChainStopped;
+        constructor(_object: T, _group?: Group);
+        getId(): number;
+        isPlaying(): boolean;
+        isPaused(): boolean;
+        to(properties: UnknownProps, duration?: number): this;
+        duration(d: number): this;
+        start(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;
+        update(time: number): boolean;
+        private _updateProperties;
+        private _handleRelativeValue;
+        private _swapEndStartRepeatValues;
+    }
+
+    type UnknownProps = Record<string, unknown>;
+
+    /**
+     * 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
+     */
+    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;
+    }
+
+    export default TWEEN;
+}
+
+declare module "@tweenjs/tween.js" {
+    import TWEEN from "TWEEN";
+    export = TWEEN;
+}