nanotween
Advanced tools
Comparing version 0.4.4 to 0.4.5
@@ -1,525 +0,1 @@ | ||
| var NanoTween = (function () { | ||
| var global$1 = typeof global !== "undefined" ? global : | ||
| typeof self !== "undefined" ? self : | ||
| typeof window !== "undefined" ? window : {} | ||
| // shim for using process in browser | ||
| // based off https://github.com/defunctzombie/node-process/blob/master/browser.js | ||
| function defaultSetTimout() { | ||
| throw new Error('setTimeout has not been defined'); | ||
| } | ||
| function defaultClearTimeout () { | ||
| throw new Error('clearTimeout has not been defined'); | ||
| } | ||
| var cachedSetTimeout = defaultSetTimout; | ||
| var cachedClearTimeout = defaultClearTimeout; | ||
| if (typeof global$1.setTimeout === 'function') { | ||
| cachedSetTimeout = setTimeout; | ||
| } | ||
| if (typeof global$1.clearTimeout === 'function') { | ||
| cachedClearTimeout = clearTimeout; | ||
| } | ||
| function runTimeout(fun) { | ||
| if (cachedSetTimeout === setTimeout) { | ||
| //normal enviroments in sane situations | ||
| return setTimeout(fun, 0); | ||
| } | ||
| // if setTimeout wasn't available but was latter defined | ||
| if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { | ||
| cachedSetTimeout = setTimeout; | ||
| return setTimeout(fun, 0); | ||
| } | ||
| try { | ||
| // when when somebody has screwed with setTimeout but no I.E. maddness | ||
| return cachedSetTimeout(fun, 0); | ||
| } catch(e){ | ||
| try { | ||
| // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally | ||
| return cachedSetTimeout.call(null, fun, 0); | ||
| } catch(e){ | ||
| // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error | ||
| return cachedSetTimeout.call(this, fun, 0); | ||
| } | ||
| } | ||
| } | ||
| function runClearTimeout(marker) { | ||
| if (cachedClearTimeout === clearTimeout) { | ||
| //normal enviroments in sane situations | ||
| return clearTimeout(marker); | ||
| } | ||
| // if clearTimeout wasn't available but was latter defined | ||
| if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { | ||
| cachedClearTimeout = clearTimeout; | ||
| return clearTimeout(marker); | ||
| } | ||
| try { | ||
| // when when somebody has screwed with setTimeout but no I.E. maddness | ||
| return cachedClearTimeout(marker); | ||
| } catch (e){ | ||
| try { | ||
| // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally | ||
| return cachedClearTimeout.call(null, marker); | ||
| } catch (e){ | ||
| // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. | ||
| // Some versions of I.E. have different rules for clearTimeout vs setTimeout | ||
| return cachedClearTimeout.call(this, marker); | ||
| } | ||
| } | ||
| } | ||
| var queue = []; | ||
| var draining = false; | ||
| var currentQueue; | ||
| var queueIndex = -1; | ||
| function cleanUpNextTick() { | ||
| if (!draining || !currentQueue) { | ||
| return; | ||
| } | ||
| draining = false; | ||
| if (currentQueue.length) { | ||
| queue = currentQueue.concat(queue); | ||
| } else { | ||
| queueIndex = -1; | ||
| } | ||
| if (queue.length) { | ||
| drainQueue(); | ||
| } | ||
| } | ||
| function drainQueue() { | ||
| if (draining) { | ||
| return; | ||
| } | ||
| var timeout = runTimeout(cleanUpNextTick); | ||
| draining = true; | ||
| var len = queue.length; | ||
| while(len) { | ||
| currentQueue = queue; | ||
| queue = []; | ||
| while (++queueIndex < len) { | ||
| if (currentQueue) { | ||
| currentQueue[queueIndex].run(); | ||
| } | ||
| } | ||
| queueIndex = -1; | ||
| len = queue.length; | ||
| } | ||
| currentQueue = null; | ||
| draining = false; | ||
| runClearTimeout(timeout); | ||
| } | ||
| function nextTick(fun) { | ||
| var args = new Array(arguments.length - 1); | ||
| if (arguments.length > 1) { | ||
| for (var i = 1; i < arguments.length; i++) { | ||
| args[i - 1] = arguments[i]; | ||
| } | ||
| } | ||
| queue.push(new Item(fun, args)); | ||
| if (queue.length === 1 && !draining) { | ||
| runTimeout(drainQueue); | ||
| } | ||
| } | ||
| // v8 likes predictible objects | ||
| function Item(fun, array) { | ||
| this.fun = fun; | ||
| this.array = array; | ||
| } | ||
| Item.prototype.run = function () { | ||
| this.fun.apply(null, this.array); | ||
| }; | ||
| var title = 'browser'; | ||
| var platform = 'browser'; | ||
| var browser = true; | ||
| var env = {}; | ||
| var argv = []; | ||
| var version = ''; // empty string to avoid regexp issues | ||
| var versions = {}; | ||
| var release = {}; | ||
| var config = {}; | ||
| function noop() {} | ||
| var on = noop; | ||
| var addListener = noop; | ||
| var once = noop; | ||
| var off = noop; | ||
| var removeListener = noop; | ||
| var removeAllListeners = noop; | ||
| var emit = noop; | ||
| function binding(name) { | ||
| throw new Error('process.binding is not supported'); | ||
| } | ||
| function cwd () { return '/' } | ||
| function chdir (dir) { | ||
| throw new Error('process.chdir is not supported'); | ||
| } | ||
| function umask() { return 0; } | ||
| // from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js | ||
| var performance = global$1.performance || {}; | ||
| var performanceNow = | ||
| performance.now || | ||
| performance.mozNow || | ||
| performance.msNow || | ||
| performance.oNow || | ||
| performance.webkitNow || | ||
| function(){ return (new Date()).getTime() }; | ||
| // generate timestamp or delta | ||
| // see http://nodejs.org/api/process.html#process_process_hrtime | ||
| function hrtime(previousTimestamp){ | ||
| var clocktime = performanceNow.call(performance)*1e-3; | ||
| var seconds = Math.floor(clocktime); | ||
| var nanoseconds = Math.floor((clocktime%1)*1e9); | ||
| if (previousTimestamp) { | ||
| seconds = seconds - previousTimestamp[0]; | ||
| nanoseconds = nanoseconds - previousTimestamp[1]; | ||
| if (nanoseconds<0) { | ||
| seconds--; | ||
| nanoseconds += 1e9; | ||
| } | ||
| } | ||
| return [seconds,nanoseconds] | ||
| } | ||
| var startTime = new Date(); | ||
| function uptime$1() { | ||
| var currentTime = new Date(); | ||
| var dif = currentTime - startTime; | ||
| return dif / 1000; | ||
| } | ||
| var process = { | ||
| nextTick: nextTick, | ||
| title: title, | ||
| browser: browser, | ||
| env: env, | ||
| argv: argv, | ||
| version: version, | ||
| versions: versions, | ||
| on: on, | ||
| addListener: addListener, | ||
| once: once, | ||
| off: off, | ||
| removeListener: removeListener, | ||
| removeAllListeners: removeAllListeners, | ||
| emit: emit, | ||
| binding: binding, | ||
| cwd: cwd, | ||
| chdir: chdir, | ||
| umask: umask, | ||
| hrtime: hrtime, | ||
| platform: platform, | ||
| release: release, | ||
| config: config, | ||
| uptime: uptime$1 | ||
| }; | ||
| function createCommonjsModule(fn, module) { | ||
| return module = { exports: {} }, fn(module, module.exports), module.exports; | ||
| } | ||
| var nanouptime = createCommonjsModule(function (module) { | ||
| if (typeof window === 'undefined' && typeof process !== 'undefined') { | ||
| function now() { | ||
| var time = process.hrtime(); | ||
| return time[0] * 1e9 + time[1] | ||
| } | ||
| var upTime = process.uptime() * 1e9; | ||
| var loadTime = now(); | ||
| var start = loadTime - upTime; | ||
| module.exports = function() { | ||
| return (now() - start) / 1e6 | ||
| }; | ||
| } else if ( | ||
| typeof window !== 'undefined' && | ||
| window.performance !== undefined && | ||
| window.performance.now !== undefined | ||
| ) { | ||
| module.exports = window.performance.now.bind(window.performance); | ||
| } else { | ||
| var start = Date.now(); | ||
| module.exports = function() { | ||
| return Date.now() - start | ||
| }; | ||
| } | ||
| }); | ||
| var nanoevents = createCommonjsModule(function (module) { | ||
| ( | ||
| /** | ||
| * Interface for event subscription. | ||
| * | ||
| * @example | ||
| * var NanoEvents = require('nanoevents') | ||
| * | ||
| * class Ticker { | ||
| * constructor() { | ||
| * this.emitter = new NanoEvents() | ||
| * } | ||
| * on() { | ||
| * return this.emitter.on.apply(this.events, arguments) | ||
| * } | ||
| * tick() { | ||
| * this.emitter.emit('tick') | ||
| * } | ||
| * } | ||
| * | ||
| * @alias NanoEvents | ||
| * @class | ||
| */ | ||
| module.exports = function NanoEvents () { | ||
| /** | ||
| * Event names in keys and arrays with listeners in values. | ||
| * @type {object} | ||
| * | ||
| * @example | ||
| * Object.keys(ee.events) | ||
| * | ||
| * @alias NanoEvents#events | ||
| */ | ||
| this.events = { }; | ||
| } | ||
| ).prototype = { | ||
| /** | ||
| * Add a listener for a given event. | ||
| * @param {string} event The event name. | ||
| * @param {function} cb The listener function. | ||
| * | ||
| * @return {function} Unbind listener from event. | ||
| * | ||
| * @example | ||
| * const unbind = ee.on('tick', (tickType, tickDuration) => { | ||
| * count += 1 | ||
| * }) | ||
| * | ||
| * disable () { | ||
| * unbind() | ||
| * } | ||
| * | ||
| * @alias NanoEvents#on | ||
| * @method | ||
| */ | ||
| on: function on$$1 (event, cb) { | ||
| if (production !== 'production' && typeof cb !== 'function') { | ||
| throw new Error('Listener must be a function') | ||
| } | ||
| // event variable is reused and repurposed, now it's an array of handlers | ||
| event = this.events[event] = this.events[event] || []; | ||
| event.push(cb); | ||
| return function () { | ||
| // a.splice(i >>> 0, 1) === if (i !== -1) a.splice(i, 1) | ||
| // -1 >>> 0 === 0xFFFFFFFF, max possible array length | ||
| event.splice(event.indexOf(cb) >>> 0, 1); | ||
| } | ||
| }, | ||
| /** | ||
| * Calls each of the listeners registered for a given event. | ||
| * | ||
| * @param {string} event The event name. | ||
| * @param {...*} arguments The arguments for listeners. | ||
| * | ||
| * @returns {undefined} | ||
| * | ||
| * @example | ||
| * ee.emit('tick', tickType, tickDuration) | ||
| * | ||
| * @alias NanoEvents#emit | ||
| * @method | ||
| */ | ||
| emit: function emit$$1 (event) { | ||
| var list = this.events[event]; | ||
| if (!list || !list[0]) return // list[0] === Array.isArray(list) | ||
| var args = list.slice.call(arguments, 1); | ||
| list.slice().map(function (i) { | ||
| i.apply(this, args); // this === global or window | ||
| }); | ||
| } | ||
| }; | ||
| }); | ||
| var lastTime = 0; | ||
| var tweens = []; | ||
| function Tween() { | ||
| var self = this; | ||
| var _options = { | ||
| id: tweens.length, | ||
| delay: 0, | ||
| repeats: 1, | ||
| duration: 0, | ||
| easing: function(x) { | ||
| return x | ||
| }, | ||
| reversed: false, | ||
| converters: [] | ||
| }; | ||
| function remaining() { | ||
| return { | ||
| progress: self.state.progress, | ||
| value: self.state.value, | ||
| remaining: self.state.repeats + 1, | ||
| completed: _options.repeats - self.state.repeats - 1 | ||
| } | ||
| } | ||
| function _rescale(progress) { | ||
| self.state.progress = progress; | ||
| var easing = _options.easing; | ||
| easing.reverse = easing.reverse || easing; | ||
| var value = _options.reversed | ||
| ? 1 - easing.reverse(self.state.progress) | ||
| : easing(self.state.progress); | ||
| self.state.value = _options.converters.reduce(function(res, cb) { | ||
| return cb(res) | ||
| }, value); | ||
| self.bus.emit('update', self.state.value); | ||
| } | ||
| self.state = { | ||
| isRunning: false, | ||
| current: void 0, | ||
| progress: 0, | ||
| repeats: 0 | ||
| }; | ||
| self.bus = new nanoevents(); | ||
| tweens.push(self); | ||
| self.use = function(enhancer) { | ||
| enhancer(self); | ||
| return self | ||
| }; | ||
| self.easing = function(easing) { | ||
| _options.easing = easing; | ||
| return self | ||
| }; | ||
| self.duration = function(duration) { | ||
| _options.duration = duration; | ||
| return self | ||
| }; | ||
| self.delay = function(delay) { | ||
| _options.delay = delay; | ||
| return self | ||
| }; | ||
| self.repeat = function(repeat) { | ||
| _options.repeats = repeat; | ||
| return self | ||
| }; | ||
| self.reverse = function(val) { | ||
| _options.reversed = val !== void 0 ? val : !_options.reversed; | ||
| self.state.progress = 1 - self.state.progress; | ||
| return self | ||
| }; | ||
| self.on = function(evt, cb) { | ||
| self.bus.on(evt, cb); | ||
| return self | ||
| }; | ||
| self.convert = function(cb) { | ||
| _options.converters.push(cb); | ||
| return self | ||
| }; | ||
| self.set = function(progress) { | ||
| if (progress > 1) { | ||
| var times = Math.floor(progress); | ||
| self.complete(times); | ||
| if (!self.state.isRunning) return | ||
| _rescale(progress - times); | ||
| } else { | ||
| _rescale(progress); | ||
| } | ||
| return self | ||
| }; | ||
| self.tick = function(time) { | ||
| self.set(self.state.progress + time / _options.duration); | ||
| }; | ||
| self.start = function() { | ||
| self._i = setTimeout(function() { | ||
| self.set(0); | ||
| self.state.repeats = _options.repeats - 1; | ||
| self.state.isRunning = true; | ||
| self.bus.emit('start'); | ||
| }, _options.delay); | ||
| return self | ||
| }; | ||
| self.stop = function() { | ||
| self.set(1); | ||
| self.state.repeats = 0; | ||
| self.state.isRunning = false; | ||
| self.bus.emit('stop'); | ||
| return self | ||
| }; | ||
| self.complete = function(times) { | ||
| _rescale(1); | ||
| var isStop = self.state.repeats < times; | ||
| var ticks = isStop ? self.state.repeats : times; | ||
| while (ticks > 0) { | ||
| self.state.repeats--; | ||
| self.bus.emit('step', ticks); | ||
| ticks--; | ||
| } | ||
| if (isStop) { | ||
| self.state.isRunning = false; | ||
| self.bus.emit('complete'); | ||
| } | ||
| return self | ||
| }; | ||
| self.play = function() { | ||
| self.state.isRunning = true; | ||
| self.bus.emit('play', remaining()); | ||
| return self | ||
| }; | ||
| self.pause = function() { | ||
| self.state.isRunning = false; | ||
| self.bus.emit('pause', remaining()); | ||
| return self | ||
| }; | ||
| } | ||
| Tween.update = function() { | ||
| if (document.hidden) return | ||
| var now = nanouptime(); | ||
| tweens.forEach(function(tween) { | ||
| if (tween.state.isRunning) { | ||
| tween.tick(now - lastTime); | ||
| } | ||
| }); | ||
| lastTime = now; | ||
| }; | ||
| return Tween; | ||
| }()); | ||
| var NanoTween=function(){function e(e,t){return e(t={exports:{}},t.exports),t.exports}var t=e(function(e){if("undefined"==typeof window&&"undefined"!=typeof process){function t(){var e=process.hrtime();return 1e9*e[0]+e[1]}var n=1e9*process.uptime(),r=t()-n;e.exports=function(){return(t()-r)/1e6}}else if("undefined"!=typeof window&&void 0!==window.performance&&void 0!==window.performance.now)e.exports=window.performance.now.bind(window.performance);else{r=Date.now();e.exports=function(){return Date.now()-r}}}),n=e(function(e){(e.exports=function(){this.events={}}).prototype={on:function(e,t){return(e=this.events[e]=this.events[e]||[]).push(t),function(){e.splice(e.indexOf(t)>>>0,1)}},emit:function(e){var t=this.events[e];if(t&&t[0]){var n=t.slice.call(arguments,1);t.slice().map(function(e){e.apply(this,n)})}}}}),r=0,s=[];function i(){var e=this,t={id:s.length,delay:0,repeats:1,duration:0,easing:function(e){return e},reversed:!1,converters:[]};function r(){return{progress:e.state.progress,value:e.state.value,remaining:e.state.repeats+1,completed:t.repeats-e.state.repeats-1}}function i(n){e.state.progress=n;var r=t.easing;r.reverse=r.reverse||r;var s=t.reversed?1-r.reverse(e.state.progress):r(e.state.progress);e.state.value=t.converters.reduce(function(e,t){return t(e)},s),e.bus.emit("update",e.state.value)}e.state={isRunning:!1,current:void 0,progress:0,repeats:0},e.bus=new n,s.push(e),e.use=function(t){return t(e),e},e.easing=function(n){return t.easing=n,e},e.duration=function(n){return t.duration=n,e},e.delay=function(n){return t.delay=n,e},e.repeat=function(n){return t.repeats=n,e},e.reverse=function(n){return t.reversed=void 0!==n?n:!t.reversed,e.state.progress=1-e.state.progress,e},e.on=function(t,n){return e.bus.on(t,n),e},e.convert=function(n){return t.converters.push(n),e},e.set=function(t){if(t>1){var n=Math.floor(t);if(e.complete(n),!e.state.isRunning)return;i(t-n)}else i(t);return e},e.tick=function(n){e.set(e.state.progress+n/t.duration)},e.start=function(){return e._i=setTimeout(function(){e.set(0),e.state.repeats=t.repeats-1,e.state.isRunning=!0,e.bus.emit("start")},t.delay),e},e.stop=function(){return e.set(1),e.state.repeats=0,e.state.isRunning=!1,e.bus.emit("stop"),e},e.complete=function(t){i(1);for(var n=e.state.repeats<t,r=n?e.state.repeats:t;r>0;)e.state.repeats--,e.bus.emit("step",r),r--;return n&&(e.state.isRunning=!1,e.bus.emit("complete")),e},e.play=function(){return e.state.isRunning=!0,e.bus.emit("play",r()),e},e.pause=function(){return e.state.isRunning=!1,e.bus.emit("pause",r()),e}}return i.update=function(){if(!document.hidden){var e=t();s.forEach(function(t){t.state.isRunning&&t.tick(e-r)}),r=e}},i}(); |
| { | ||
| "name": "nanotween", | ||
| "version": "0.4.4", | ||
| "version": "0.4.5", | ||
| "description": "Tiny library for tweening", | ||
@@ -57,5 +57,5 @@ "main": "index.js", | ||
| "rollup-plugin-commonjs": "^8.2.6", | ||
| "rollup-plugin-node-globals": "^1.1.0", | ||
| "rollup-plugin-node-resolve": "^3.0.1", | ||
| "rollup-plugin-replace": "^2.0.0", | ||
| "rollup-plugin-uglify": "^2.0.1", | ||
| "size-limit": "^0.13.2" | ||
@@ -62,0 +62,0 @@ }, |
No alert changes
Worsened metrics
- Total package byte prevSize
- decreased by-27.28%
27267
- Lines of code
- decreased by-36.04%
818
No dependency changes