* docs(readme): fix lite

* code(linting): some linting
* Interpolation(values): now works not only numbers, also object and arrays (except `Bezier` interpolation)

API.md

@@ -33,6 +33,7 @@ Lightweight, effecient and modular ES6 version of tween.js
  * [.Interpolation](#TWEEN.Interpolation) : <code>object</code>
  * [.add(tween)](#TWEEN.add)
  * [.onTick(fn)](#TWEEN.onTick)
+ * [.FrameThrottle([frameCount])](#TWEEN.FrameThrottle)
  * [.autoPlay(state)](#TWEEN.autoPlay)
  * [.removeAll()](#TWEEN.removeAll)
  * [.get(tween)](#TWEEN.get) ⇒ [<code>Tween</code>](#Tween)
@@ -112,6 +113,21 @@ Adds ticker like event
 ```js
 TWEEN.onTick(time => console.log(time))
 ```
+<a name="TWEEN.FrameThrottle"></a>
+
+### TWEEN.FrameThrottle([frameCount])
+Sets after how much frames empty updating should stop
+
+**Kind**: static method of [<code>TWEEN</code>](#TWEEN) 
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [frameCount] | <code>number</code> | <code>120</code> | count of frames that should stop after all tweens removed |
+
+**Example** 
+```js
+TWEEN.FrameThrottle(60)
+```
 <a name="TWEEN.autoPlay"></a>
 
 ### TWEEN.autoPlay(state)

README.md

@@ -82,9 +82,6 @@ PR are welcome...
 ```javascript
 // Full
 import { Easing, Tween, autoPlay } from 'es6-tween'
-
-// Lite
-import { Easing, Interpolation, Tween, autoPlay } from 'es6-tween/src/index.lite'
 ```
 
 #### Using [getlibs](https://github.com/activewidgets/getlibs)

package.json

@@ -1,6 +1,6 @@
 {
  "name": "es6-tween",
- "version": "4.0.2",
+ "version": "4.1.0",
  "description": "ES6 implementation of amazing tween.js",
  "browser": "full/Tween.min.js",
  "cdn": "full/Tween.min.js",

ts/Easing.ts

@@ -8,242 +8,242 @@
  */
 const Easing = {
  Linear: {
- None (k) {
- return k
- }
+ None(k) {
+ return k;
+ },
  },
 
  Quadratic: {
- In (k) {
- return k * k
+ In(k) {
+ return k * k;
  },
 
- Out (k) {
- return k * (2 - k)
+ Out(k) {
+ return k * (2 - k);
  },
 
- InOut (k) {
+ InOut(k) {
  if ((k *= 2) < 1) {
- return 0.5 * k * k
+ return 0.5 * k * k;
  }
 
- return -0.5 * (--k * (k - 2) - 1)
- }
+ return -0.5 * (--k * (k - 2) - 1);
+ },
  },
 
  Cubic: {
- In (k) {
- return k * k * k
+ In(k) {
+ return k * k * k;
  },
 
- Out (k) {
- return --k * k * k + 1
+ Out(k) {
+ return --k * k * k + 1;
  },
 
- InOut (k) {
+ InOut(k) {
  if ((k *= 2) < 1) {
- return 0.5 * k * k * k
+ return 0.5 * k * k * k;
  }
 
- return 0.5 * ((k -= 2) * k * k + 2)
- }
+ return 0.5 * ((k -= 2) * k * k + 2);
+ },
  },
 
  Quartic: {
- In (k) {
- return k * k * k * k
+ In(k) {
+ return k * k * k * k;
  },
 
- Out (k) {
- return 1 - --k * k * k * k
+ Out(k) {
+ return 1 - --k * k * k * k;
  },
 
- InOut (k) {
+ InOut(k) {
  if ((k *= 2) < 1) {
- return 0.5 * k * k * k * k
+ return 0.5 * k * k * k * k;
  }
 
- return -0.5 * ((k -= 2) * k * k * k - 2)
- }
+ return -0.5 * ((k -= 2) * k * k * k - 2);
+ },
  },
 
  Quintic: {
- In (k) {
- return k * k * k * k * k
+ In(k) {
+ return k * k * k * k * k;
  },
 
- Out (k) {
- return --k * k * k * k * k + 1
+ Out(k) {
+ return --k * k * k * k * k + 1;
  },
 
- InOut (k) {
+ InOut(k) {
  if ((k *= 2) < 1) {
- return 0.5 * k * k * k * k * k
+ return 0.5 * k * k * k * k * k;
  }
 
- return 0.5 * ((k -= 2) * k * k * k * k + 2)
- }
+ return 0.5 * ((k -= 2) * k * k * k * k + 2);
+ },
  },
 
  Sinusoidal: {
- In (k) {
- return 1 - Math.cos(k * Math.PI / 2)
+ In(k) {
+ return 1 - Math.cos(k * Math.PI / 2);
  },
 
- Out (k) {
- return Math.sin(k * Math.PI / 2)
+ Out(k) {
+ return Math.sin(k * Math.PI / 2);
  },
 
- InOut (k) {
- return 0.5 * (1 - Math.cos(Math.PI * k))
- }
+ InOut(k) {
+ return 0.5 * (1 - Math.cos(Math.PI * k));
+ },
  },
 
  Exponential: {
- In (k) {
- return k === 0 ? 0 : Math.pow(1024, k - 1)
+ In(k) {
+ return k === 0 ? 0 : Math.pow(1024, k - 1);
  },
 
- Out (k) {
- return k === 1 ? 1 : 1 - Math.pow(2, -10 * k)
+ Out(k) {
+ return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);
  },
 
- InOut (k) {
+ InOut(k) {
  if (k === 0) {
- return 0
+ return 0;
  }
 
  if (k === 1) {
- return 1
+ return 1;
  }
 
  if ((k *= 2) < 1) {
- return 0.5 * Math.pow(1024, k - 1)
+ return 0.5 * Math.pow(1024, k - 1);
  }
 
- return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2)
- }
+ return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);
+ },
  },
 
  Circular: {
- In (k) {
- return 1 - Math.sqrt(1 - k * k)
+ In(k) {
+ return 1 - Math.sqrt(1 - k * k);
  },
 
- Out (k) {
- return Math.sqrt(1 - --k * k)
+ Out(k) {
+ return Math.sqrt(1 - --k * k);
  },
 
- InOut (k) {
+ InOut(k) {
  if ((k *= 2) < 1) {
- return -0.5 * (Math.sqrt(1 - k * k) - 1)
+ return -0.5 * (Math.sqrt(1 - k * k) - 1);
  }
 
- return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1)
- }
+ return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
+ },
  },
 
  Elastic: {
- In (k) {
+ In(k) {
  if (k === 0) {
- return 0
+ return 0;
  }
 
  if (k === 1) {
- return 1
+ return 1;
  }
 
- return -Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI)
+ return -Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI);
  },
 
- Out (k) {
+ Out(k) {
  if (k === 0) {
- return 0
+ return 0;
  }
 
  if (k === 1) {
- return 1
+ return 1;
  }
 
- return Math.pow(2, -10 * k) * Math.sin((k - 0.1) * 5 * Math.PI) + 1
+ return Math.pow(2, -10 * k) * Math.sin((k - 0.1) * 5 * Math.PI) + 1;
  },
 
- InOut (k) {
+ InOut(k) {
  if (k === 0) {
- return 0
+ return 0;
  }
 
  if (k === 1) {
- return 1
+ return 1;
  }
 
- k *= 2
+ k *= 2;
 
  if (k < 1) {
  return (
  -0.5 * Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI)
- )
+ );
  }
 
  return (
  0.5 * Math.pow(2, -10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI) + 1
- )
- }
+ );
+ },
  },
 
  Back: {
- In (k) {
- const s = 1.70158
+ In(k) {
+ const s = 1.70158;
 
- return k * k * ((s + 1) * k - s)
+ return k * k * ((s + 1) * k - s);
  },
 
- Out (k) {
- const s = 1.70158
+ Out(k) {
+ const s = 1.70158;
 
- return --k * k * ((s + 1) * k + s) + 1
+ return --k * k * ((s + 1) * k + s) + 1;
  },
 
- InOut (k) {
- const s = 1.70158 * 1.525
+ InOut(k) {
+ const s = 1.70158 * 1.525;
 
  if ((k *= 2) < 1) {
- return 0.5 * (k * k * ((s + 1) * k - s))
+ return 0.5 * (k * k * ((s + 1) * k - s));
  }
 
- return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2)
- }
+ return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);
+ },
  },
 
  Bounce: {
- In (k) {
- return 1 - Easing.Bounce.Out(1 - k)
+ In(k) {
+ return 1 - Easing.Bounce.Out(1 - k);
  },
 
- Out (k) {
+ Out(k) {
  if (k < 1 / 2.75) {
- return 7.5625 * k * k
+ return 7.5625 * k * k;
  } else if (k < 2 / 2.75) {
- return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75
+ return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75;
  } else if (k < 2.5 / 2.75) {
- return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375
+ return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375;
  } else {
- return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375
+ return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375;
  }
  },
 
- InOut (k) {
+ InOut(k) {
  if (k < 0.5) {
- return Easing.Bounce.In(k * 2) * 0.5
+ return Easing.Bounce.In(k * 2) * 0.5;
  }
 
- return Easing.Bounce.Out(k * 2 - 1) * 0.5 + 0.5
- }
+ return Easing.Bounce.Out(k * 2 - 1) * 0.5 + 0.5;
+ },
  },
 
  Stepped: {
- steps: steps => k => ((k * steps) | 0) / steps
- }
-}
+ steps: steps => k => ((k * steps) | 0) / steps,
+ },
+};
 
-export default Easing
+export default Easing;