diff -r d334a616c023 -r e16a97fb364a src/cm/media/js/lib/yui/yui3-3.15.0/build/timers/timers-debug.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cm/media/js/lib/yui/yui3-3.15.0/build/timers/timers-debug.js Mon Mar 10 15:19:48 2014 +0100 @@ -0,0 +1,309 @@ +YUI.add('timers', function (Y, NAME) { + +/** +Provides utilities for timed asynchronous callback execution. +Y.soon is a setImmediate/process.nextTick/setTimeout wrapper. + +This module includes [asap.js](https://github.com/kriskowal/asap) for scheduling +asynchronous tasks. + +@module timers +@author Steven Olmsted +**/ + +// Hack. asap.js is written as a Node module and expects require, module and +// global to be available in the module's scope. +var module = {}, + global = Y.config.global; + +// `asap` only requires a `queue` module that is bundled into this same file. +function require(mod) { + return Queue; +} +"use strict"; + +module.exports = Queue; +function Queue(capacity) { + this.capacity = this.snap(capacity); + this.length = 0; + this.front = 0; + this.initialize(); +} + +Queue.prototype.push = function (value) { + var length = this.length; + if (this.capacity <= length) { + this.grow(this.snap(this.capacity * this.growFactor)); + } + var index = (this.front + length) & (this.capacity - 1); + this[index] = value; + this.length = length + 1; +}; + +Queue.prototype.shift = function () { + var front = this.front; + var result = this[front]; + + this[front] = void 0; + this.front = (front + 1) & (this.capacity - 1); + this.length--; + return result; +}; + +Queue.prototype.grow = function (capacity) { + var oldFront = this.front; + var oldCapacity = this.capacity; + var oldQueue = new Array(oldCapacity); + var length = this.length; + + copy(this, 0, oldQueue, 0, oldCapacity); + this.capacity = capacity; + this.initialize(); + this.front = 0; + if (oldFront + length <= oldCapacity) { + // Can perform direct linear copy + copy(oldQueue, oldFront, this, 0, length); + } else { + // Cannot perform copy directly, perform as much as possible at the + // end, and then copy the rest to the beginning of the buffer + var lengthBeforeWrapping = + length - ((oldFront + length) & (oldCapacity - 1)); + copy( + oldQueue, + oldFront, + this, + 0, + lengthBeforeWrapping + ); + copy( + oldQueue, + 0, + this, + lengthBeforeWrapping, + length - lengthBeforeWrapping + ); + } +}; + +Queue.prototype.initialize = function () { + var length = this.capacity; + for (var i = 0; i < length; ++i) { + this[i] = void 0; + } +}; + +Queue.prototype.snap = function (capacity) { + if (typeof capacity !== "number") { + return this.minCapacity; + } + return pow2AtLeast( + Math.min(this.maxCapacity, Math.max(this.minCapacity, capacity)) + ); +}; + +Queue.prototype.maxCapacity = (1 << 30) | 0; +Queue.prototype.minCapacity = 16; +Queue.prototype.growFactor = 8; + +function copy(source, sourceIndex, target, targetIndex, length) { + for (var index = 0; index < length; ++index) { + target[index + targetIndex] = source[index + sourceIndex]; + } +} + +function pow2AtLeast(n) { + n = n >>> 0; + n = n - 1; + n = n | (n >> 1); + n = n | (n >> 2); + n = n | (n >> 4); + n = n | (n >> 8); + n = n | (n >> 16); + return n + 1; +} +"use strict"; + +// Use the fastest possible means to execute a task in a future turn +// of the event loop. + +// Queue is a circular buffer with good locality of reference and doesn't +// allocate new memory unless there are more than `InitialCapacity` parallel +// tasks in which case it will resize itself generously to x8 more capacity. +// The use case of asap should require no or few amount of resizes during +// runtime. +// Calling a task frees a slot immediately so if the calling +// has a side effect of queuing itself again, it can be sustained +// without additional memory +// Queue specifically uses +// http://en.wikipedia.org/wiki/Circular_buffer#Use_a_Fill_Count +// Because: +// 1. We need fast .length operation, since queue +// could have changed after every iteration +// 2. Modulus can be negated by using power-of-two +// capacities and replacing it with bitwise AND +// 3. It will not be used in a multi-threaded situation. + +var Queue = require("./queue"); + +//1024 = InitialCapacity +var queue = new Queue(1024); +var flushing = false; +var requestFlush = void 0; +var hasSetImmediate = typeof setImmediate === "function"; +var domain; + +// Avoid shims from browserify. +// The existence of `global` in browsers is guaranteed by browserify. +var process = global.process; + +// Note that some fake-Node environments, +// like the Mocha test runner, introduce a `process` global. +var isNodeJS = !!process && ({}).toString.call(process) === "[object process]"; + +function flush() { + /* jshint loopfunc: true */ + + while (queue.length > 0) { + var task = queue.shift(); + + try { + task.call(); + + } catch (e) { + if (isNodeJS) { + // In node, uncaught exceptions are considered fatal errors. + // Re-throw them to interrupt flushing! + + // Ensure continuation if an uncaught exception is suppressed + // listening process.on("uncaughtException") or domain("error"). + requestFlush(); + + throw e; + + } else { + // In browsers, uncaught exceptions are not fatal. + // Re-throw them asynchronously to avoid slow-downs. + setTimeout(function () { + throw e; + }, 0); + } + } + } + + flushing = false; +} + +if (isNodeJS) { + // Node.js + requestFlush = function () { + // Ensure flushing is not bound to any domain. + var currentDomain = process.domain; + if (currentDomain) { + domain = domain || (1,require)("domain"); + domain.active = process.domain = null; + } + + // Avoid tick recursion - use setImmediate if it exists. + if (flushing && hasSetImmediate) { + setImmediate(flush); + } else { + process.nextTick(flush); + } + + if (currentDomain) { + domain.active = process.domain = currentDomain; + } + }; + +} else if (hasSetImmediate) { + // In IE10, or https://github.com/NobleJS/setImmediate + requestFlush = function () { + setImmediate(flush); + }; + +} else if (typeof MessageChannel !== "undefined") { + // modern browsers + // http://www.nonblocking.io/2011/06/windownexttick.html + var channel = new MessageChannel(); + // At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create + // working message ports the first time a page loads. + channel.port1.onmessage = function () { + requestFlush = requestPortFlush; + channel.port1.onmessage = flush; + flush(); + }; + var requestPortFlush = function () { + // Opera requires us to provide a message payload, regardless of + // whether we use it. + channel.port2.postMessage(0); + }; + requestFlush = function () { + setTimeout(flush, 0); + requestPortFlush(); + }; + +} else { + // old browsers + requestFlush = function () { + setTimeout(flush, 0); + }; +} + +function asap(task) { + if (isNodeJS && process.domain) { + task = process.domain.bind(task); + } + + queue.push(task); + + if (!flushing) { + requestFlush(); + flushing = true; + } +}; + +module.exports = asap; +/** +Y.soon accepts a callback function. The callback function will be called +once in a future turn of the JavaScript event loop. If the function +requires a specific execution context or arguments, wrap it with Y.bind. +Y.soon returns an object with a cancel method. If the cancel method is +called before the callback function, the callback function won't be +called. + +@method soon +@for YUI +@param {Function} callbackFunction +@return {Object} An object with a cancel method. If the cancel method is + called before the callback function, the callback function won't be + called. +**/ +function soon(callbackFunction) { + var canceled; + + soon._asynchronizer(function () { + // Some asynchronizers may provide their own cancellation + // methods such as clearImmediate or clearTimeout but some + // asynchronizers do not. For simplicity, cancellation is + // entirely handled here rather than wrapping the other methods. + // All asynchronizers are expected to always call this anonymous + // function. + if (!canceled) { + callbackFunction(); + } + }); + + return { + cancel: function () { + canceled = 1; + } + }; +} + +soon._asynchronizer = asap; +soon._impl = 'asap'; + +Y.soon = soon; + + +}, '@VERSION@', {"requires": ["yui-base"]});