[Pkg-javascript-commits] [dojo] 15/27: Make sure that domReady(), when used as a function rather than a plugin, executes registered callbacks sequentially. This is how ready() is supposed to work, so it makes sense for domReady() to follow suit.
David Prévot
taffit at moszumanska.debian.org
Sun Sep 14 16:23:06 UTC 2014
This is an automated email from the git hooks/post-receive script.
taffit pushed a commit to annotated tag 1.7.6
in repository dojo.
commit 71e6969152c58773419d153ec24ef8a2ccea84e9
Author: Bill Keese <bill at dojotoolkit.org>
Date: Tue Nov 27 07:44:03 2012 +0000
Make sure that domReady(), when used as a function rather than a plugin, executes registered callbacks sequentially. This is how ready() is supposed to work, so it makes sense for domReady() to follow suit.
Fixes #16389, refs #16386 on 1.7 branch.
(cherry picked from commit 33e4435e30d59f339af3bcce6d84fbc0aa3bd6c6)
---
domReady.js | 63 ++++++++++++++++++++++++++++++++++-------------
ready.js | 81 ++++++++++++++++++++++++++++++++-----------------------------
2 files changed, 88 insertions(+), 56 deletions(-)
diff --git a/domReady.js b/domReady.js
index 64ea1c0..207359a 100644
--- a/domReady.js
+++ b/domReady.js
@@ -3,24 +3,64 @@ define(['./has'], function(has){
doc = document,
readyStates = { 'loaded': 1, 'complete': 1 },
fixReadyState = typeof doc.readyState != "string",
- ready = !!readyStates[doc.readyState];
+ ready = !!readyStates[doc.readyState],
+ readyQ = [],
+ recursiveGuard;
+
+ function domReady(callback){
+ // summary:
+ // Plugin to delay require()/define() callback from firing until the DOM has finished loading.
+ readyQ.push(callback);
+ if(ready){ processQ(); }
+ }
+ domReady.load = function(id, req, load){
+ domReady(load);
+ };
+
+ // Export queue so that ready() can check if it's empty or not.
+ domReady._Q = readyQ;
+ domReady._onQEmpty = function(){
+ // summary:
+ // Private method overridden by dojo/ready, to notify when everything in the
+ // domReady queue has been processed. Do not use directly.
+ // Will be removed in 2.0, along with domReady._Q.
+ };
// For FF <= 3.5
if(fixReadyState){ doc.readyState = "loading"; }
+ function processQ(){
+ // Calls all functions in the queue in order, unless processQ() is already running, in which case just return
+
+ if(recursiveGuard){ return; }
+ recursiveGuard = true;
+
+ while(readyQ.length){
+ try{
+ (readyQ.shift())(doc);
+ }catch(err){
+ console.log("Error on domReady callback: " + err);
+ }
+ }
+
+ recursiveGuard = false;
+
+ // Notification for dojo/ready. Remove for 2.0.
+ // Note that this could add more tasks to the ready queue.
+ domReady._onQEmpty();
+ }
+
if(!ready){
- var readyQ = [], tests = [],
+ var tests = [],
detectReady = function(evt){
evt = evt || global.event;
if(ready || (evt.type == "readystatechange" && !readyStates[doc.readyState])){ return; }
- ready = 1;
// For FF <= 3.5
if(fixReadyState){ doc.readyState = "complete"; }
- while(readyQ.length){
- (readyQ.shift())();
- }
+ ready = 1;
+ processQ();
},
on = function(node, event){
node.addEventListener(event, detectReady, false);
@@ -80,16 +120,5 @@ define(['./has'], function(has){
}
}
- function domReady(callback){
- if(ready){
- callback(1);
- }else{
- readyQ.push(callback);
- }
- }
- domReady.load = function(id, req, load){
- domReady(load);
- };
-
return domReady;
});
diff --git a/ready.js b/ready.js
index 3e1bd38..901aac3 100644
--- a/ready.js
+++ b/ready.js
@@ -10,9 +10,6 @@ define(["./_base/kernel", "./has", "require", "./has!host-browser?./domReady", "
// truthy if DOMContentLoaded or better (e.g., window.onload fired) has been achieved
isDomReady = 0,
- // a function to call to cause onLoad to be called when all requested modules have been loaded
- requestCompleteSignal,
-
// The queue of functions waiting to execute as soon as dojo.ready conditions satisfied
loadQ = [],
@@ -22,50 +19,56 @@ define(["./_base/kernel", "./has", "require", "./has!host-browser?./domReady", "
handleDomReady = function(){
isDomReady = 1;
dojo._postLoad = dojo.config.afterOnLoad = true;
- if(loadQ.length){
- requestCompleteSignal(onLoad);
- }
+ onEvent();
},
- // run the next function queued with dojo.ready
- onLoad = function(){
- if(isDomReady && !onLoadRecursiveGuard && loadQ.length){
- //guard against recursions into this function
- onLoadRecursiveGuard = 1;
+ onEvent = function(){
+ // Called when some state changes:
+ // - dom ready
+ // - dojo/domReady has finished processing everything in its queue
+ // - task added to loadQ
+ // - require() has finished loading all currently requested modules
+ //
+ // Run the functions queued with dojo.ready if appropriate.
+
+
+ //guard against recursions into this function
+ if(onLoadRecursiveGuard){
+ return;
+ }
+ onLoadRecursiveGuard = 1;
+
+ // Run tasks in queue if require() is finished loading modules, the dom is ready, and there are no
+ // pending tasks registered via domReady().
+ // The last step is necessary so that a user defined dojo.ready() callback is delayed until after the
+ // domReady() calls inside of dojo. Failure can be seen on dijit/tests/robot/Dialog_ally.html on IE8
+ // because the dijit/focus.js domReady() callback doesn't execute until after the test starts running.
+ while(isDomReady && (!domReady || domReady._Q.length == 0) && require.idle() && loadQ.length){
var f = loadQ.shift();
- try{
- f();
- }
- // FIXME: signal the error via require.on
- finally{
- onLoadRecursiveGuard = 0;
- }
- onLoadRecursiveGuard = 0;
- if(loadQ.length){
- requestCompleteSignal(onLoad);
+ try{
+ f();
+ }catch(e){
+ // FIXME: signal the error via require.on
}
}
- };
- // define requireCompleteSignal; impl depends on loader
- if(has("dojo-loader")){
- require.on("idle", onLoad);
- requestCompleteSignal = function(){
- if(require.idle()){
- onLoad();
- } // else do nothing, onLoad will be called with the next idle signal
- };
- }else{
- // RequireJS or similar
- requestCompleteSignal = function(){
- // the next function call will fail if you don't have a loader with require.ready
- // in that case, either fix your loader, use dojo's loader, or don't call dojo.ready;
- require.ready(onLoad);
+ onLoadRecursiveGuard = 0;
};
+
+ // Check if we should run the next queue operation whenever require() finishes loading modules or domReady
+ // finishes processing it's queue.
+ require.on("idle", onEvent);
+ if(domReady){
+ domReady._onQEmpty = onEvent;
}
var ready = dojo.ready = dojo.addOnLoad = function(priority, context, callback){
- // summary: Add a function to execute on DOM content loaded and all requested modules have arrived and been evaluated.
+ // summary:
+ // Add a function to execute on DOM content loaded and all requested modules have arrived and been evaluated.
+ // In most cases, the `domReady` plug-in should suffice and this method should not be needed.
+ //
+ // When called in a non-browser environment, just checks that all requested modules have arrived and been
+ // evaluated.
// priority: Integer?
// The order in which to exec this callback relative to other callbacks, defaults to 1000
// context: Object?|Function
@@ -108,7 +111,7 @@ define(["./_base/kernel", "./has", "require", "./has!host-browser?./domReady", "
callback.priority = priority;
for(var i = 0; i < loadQ.length && priority >= loadQ[i].priority; i++){}
loadQ.splice(i, 0, callback);
- requestCompleteSignal();
+ onEvent();
};
has.add("dojo-config-addOnLoad", 1);
@@ -128,7 +131,7 @@ define(["./_base/kernel", "./has", "require", "./has!host-browser?./domReady", "
});
}
- if(has("host-browser")){
+ if(domReady){
domReady(handleDomReady);
}else{
handleDomReady();
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-javascript/dojo.git
More information about the Pkg-javascript-commits
mailing list