pax_global_header00006660000000000000000000000064127653767600014535gustar00rootroot0000000000000052 comment=f1ccbfdf09cb93aadf77c4aa749ea554503b9234 setImmediate-1.0.5/000077500000000000000000000000001276537676000141525ustar00rootroot00000000000000setImmediate-1.0.5/.gitignore000066400000000000000000000000361276537676000161410ustar00rootroot00000000000000/node_modules/ /npm-debug.log setImmediate-1.0.5/.jshintrc000066400000000000000000000006301276537676000157760ustar00rootroot00000000000000{ "camelcase": true, "curly": true, "eqeqeq": true, "evil": true, "globalstrict": true, "immed": true, "indent": 4, "latedef": true, "newcap": true, "noarg": true, "node": true, "quotmark": "double", "trailing": true, "undef": true, "unused": true, "white": true, "globals": { "MessageChannel": false, "self": false } } setImmediate-1.0.5/LICENSE.txt000066400000000000000000000021171276537676000157760ustar00rootroot00000000000000Copyright (c) 2012 Barnesandnoble.com, llc, Donavon West, and Domenic Denicola Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. setImmediate-1.0.5/README.md000066400000000000000000000125531276537676000154370ustar00rootroot00000000000000# setImmediate.js **A YuzuJS production** ## Introduction **setImmediate.js** is a highly cross-browser implementation of the `setImmediate` and `clearImmediate` APIs, [proposed][spec] by Microsoft to the Web Performance Working Group. `setImmediate` allows scripts to yield to the browser, executing a given operation asynchronously, in a manner that is typically more efficient and consumes less power than the usual `setTimeout(..., 0)` pattern. setImmediate.js runs at “full speed” in the following browsers and environments, using various clever tricks: * Internet Explorer 6+ * Firefox 3+ * WebKit * Opera 9.5+ * Node.js * Web workers in browsers that support `MessageChannel`, which I can't find solid info on. In all other browsers we fall back to using `setTimeout`, so it's always safe to use. ## Macrotasks and Microtasks The `setImmediate` API, as specified, gives you access to the environment's [task queue][], sometimes known as its "macrotask" queue. This is crucially different from the [microtask queue][] used by web features such as `MutationObserver`, language features such as promises and `Object.observe`, and Node.js features such as `process.nextTick`. Each go-around of the macrotask queue yields back to the event loop once all queued tasks have been processed, even if the macrotask itself queued more macrotasks. Whereas, the microtask queue will continue executing any queued microtasks until it is exhausted. In practice, what this means is that if you call `setImmediate` inside of another task queued with `setImmediate`, you will yield back to the event loop and any I/O or rendering tasks that need to take place between those calls, instead of executing the queued task as soon as possible. If you are looking specifically to yield as part of a render loop, consider using [`requestAnimationFrame`][raf]; if you are looking solely for the control-flow ordering effects, use a microtask solution such as [asap][]. ## The Tricks ### `process.nextTick` In Node.js versions below 0.9, `setImmediate` is not available, but [`process.nextTick`][nextTick] is—and in those versions, `process.nextTick` uses macrotask semantics. So, we use it to shim support for a global `setImmediate`. In Node.js 0.9 and above, `process.nextTick` moved to microtask semantics, but `setImmediate` was introduced with macrotask semantics, so there's no need to polyfill anything. Note that we check for *actual* Node.js environments, not emulated ones like those produced by browserify or similar. Such emulated environments often already include a `process.nextTick` shim that's not as browser-compatible as setImmediate.js. ### `postMessage` In Firefox 3+, Internet Explorer 9+, all modern WebKit browsers, and Opera 9.5+, [`postMessage`][postMessage] is available and provides a good way to queue tasks on the event loop. It's quite the abuse, using a cross-document messaging protocol within the same document simply to get access to the event loop task queue, but until there are native implementations, this is the best option. Note that Internet Explorer 8 includes a synchronous version of `postMessage`. We detect this, or any other such synchronous implementation, and fall back to another trick. ### `MessageChannel` Unfortunately, `postMessage` has completely different semantics inside web workers, and so cannot be used there. So we turn to [`MessageChannel`][MessageChannel], which has worse browser support, but does work inside a web worker. ### ` setImmediate-1.0.5/test/browserOnly/selfClose.htm000066400000000000000000000005311276537676000221060ustar00rootroot00000000000000 Modal Dialog for Testing

This'll be gone in one second; we're just testing the interaction of setImmediate and window.showModalDialog.

setImmediate-1.0.5/test/browserOnly/tests.js000066400000000000000000000024351276537676000211620ustar00rootroot00000000000000"use strict"; /*global setImmediate: false, specify: false, window: false */ function assert(condition) { if (!condition) { throw new Error("Assertion failed"); } } assert.strictEqual = function (x, y) { if (x !== y) { throw new Error(x + " !== " + y); } }; specify("Modal dialogs block handlers", function (done) { // Try to launch the less-annoying self-closing-window modal dialog; if that's not an option, fall back to alert. var showTheDialog = window.showModalDialog ? function () { window.showModalDialog("selfClose.htm"); } : function () { window.alert("Please press OK to continue the test; we needed a modal dialog."); }; var dialogClosed = false; setImmediate(function () { showTheDialog(); dialogClosed = true; }); setImmediate(function () { assert(dialogClosed); done(); }); }); if (typeof window.Worker === "function") { specify("When inside a web worker context, setImmediate calls the passed handler", function (done) { var worker = new window.Worker("worker.js"); worker.addEventListener("message", function (event) { assert.strictEqual(event.data, "TEST"); done(); }, false); }); } setImmediate-1.0.5/test/browserOnly/worker.js000066400000000000000000000001431276537676000213230ustar00rootroot00000000000000importScripts("../../setImmediate.js"); setImmediate(function () { self.postMessage("TEST"); }); setImmediate-1.0.5/test/mocha.opts000066400000000000000000000000201276537676000171170ustar00rootroot00000000000000--slow Infinity setImmediate-1.0.5/test/tests.js000066400000000000000000000057171276537676000166430ustar00rootroot00000000000000"use strict"; /*global setImmediate: false, clearImmediate: false, specify: false, window: false */ // The Node version of setImmediate does not support string handlers. var global = Function("return this")(); var originalGlobalSetImmediate = global.setImmediate; if (originalGlobalSetImmediate) { global.setImmediate = function(handler) { var args = arguments; if (typeof handler !== "function") { handler = args[0] = eval.bind(null, "" + handler); } return originalGlobalSetImmediate.apply(this, args); }; } var assert = require("assert"); require("../setImmediate"); specify("Handlers do execute", function (done) { setImmediate(function () { done(); }); }); specify("Handlers do not execute in the same event loop turn as the call to `setImmediate`", function (done) { var handlerCalled = false; function handler() { handlerCalled = true; done(); } setImmediate(handler); assert(!handlerCalled); }); specify("Handlers can be strings", function(done) { var property = "handler$" + Math.random().toString(36).slice(2); done.called = false; setImmediate[property] = function () { delete setImmediate[property]; done(); }; setImmediate("setImmediate." + property + ".called = true; setImmediate." + property + "()"); assert.strictEqual(done.called, false); }); specify("`setImmediate` passes through an argument to the handler", function (done) { var expectedArg = { expected: true }; function handler(actualArg) { assert.strictEqual(actualArg, expectedArg); done(); } setImmediate(handler, expectedArg); }); specify("`setImmediate` passes through two arguments to the handler", function (done) { var expectedArg1 = { arg1: true }; var expectedArg2 = { arg2: true }; function handler(actualArg1, actualArg2) { assert.strictEqual(actualArg1, expectedArg1); assert.strictEqual(actualArg2, expectedArg2); done(); } setImmediate(handler, expectedArg1, expectedArg2); }); specify("`clearImmediate` within the same event loop turn prevents the handler from executing", function (done) { var handlerCalled = false; function handler() { handlerCalled = true; } var handle = setImmediate(handler); clearImmediate(handle); setTimeout(function () { assert(!handlerCalled); done(); }, 100); }); specify("`clearImmediate` does not interfere with handlers other than the one with ID passed to it", function (done) { var expectedArgs = ["A", "D"]; var recordedArgs = []; function handler(arg) { recordedArgs.push(arg); } setImmediate(handler, "A"); clearImmediate(setImmediate(handler, "B")); var handle = setImmediate(handler, "C"); setImmediate(handler, "D"); clearImmediate(handle); setTimeout(function () { assert.deepEqual(recordedArgs, expectedArgs); done(); }, 100); });