Wrong execution order using LABjs

Question

The problem here is a misunderstanding of how LABjs works, or rather, of how nested dynamic script loading works.

If I load script A.js using a script loader, the browser will download and then execute the contents of that script, and inside the script A, I use the script loader to load script B.js, the fact that script A.js asked for B.js to load does not mean that A.js's "load" event is magically blocked until the dependencies (that is, in this case, B.js) finish loading and executing.

Once a script has loaded, it's executed immediately by the browser, and once its main execution finishes, the browser will fire the "load" event on that script signaling it's done. If that script fired off some other asynchronous behavior, such as loading more scripts, that asynchronous behavior will have no effect on the main execution thread or the firing of that script's "load" event.

If you need to load nested dependencies, you will need a more sophisticated system of "deferring" each file's execution, similar to how AMD loaders like Require.js wrap all code in functions. The reason that technique works is that the execution order of the outer function being declared is irrelevant, because then after all code is defined, you can come back and execute those function payloads in their various correct orders and get the sequence you expect.

The other (simpler?) option, which is what I do personally, if you don't want to go the AMD/Require route, is to use a simple build tool script that reads through your JS files at build time, discovers what all the nested dependencies are, and "hoists" all of them, in the correct order, into a single "global" $LAB chain call. So inside your files, instead of declaring nested dependencies with actual $LAB calls, just have a notation of the depdendencies, like in a JS comment, and have your script look for those.

Example (similar to how I do things myself):

A.js:

// needs "B.js"
// needs "C.js"

A.something = function( /*..*/ ) { /*..*/ };    
B.something();
C.something();

B.js:

// needs "D.js"

B.something = function( /*..*/ ) { /*..*/ };
D.something();

C.js:

// needs "D.js"
// needs "E.js"

C.something = function( /*..*/ ) { /*..*/ };
D.something();
E.something();

D.js:

D.something = function( /*..*/ ) { /*..*/ };

E.js:

E.something = function( /*..*/ ) { /*..*/ };

Then, I have a simple script which looks through my files, and discovers the necessary execution order so that all dependencies are met.

It then produces a single $LAB chain for use in my main page, that looks like this:

$LAB
.script("D.js")
.script("E.js").wait() // D and E can execute in either order
.script("B.js")
.script("C.js").wait() // B and C can execute in either order
.script("A.js")
.wait(function(){
   alert("Everything is loaded!");
});

The only caveat to an approach like I'm suggesting is that you can't do circular dependencies (like C depends on B and B depends on C). If you need circular dependencies, go AMD/Require.js.