forked from yui/yui3
-
Notifications
You must be signed in to change notification settings - Fork 1
/
yui-base.js
2187 lines (1885 loc) · 57.8 KB
/
yui-base.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/**
* The YUI module contains the components required for building the YUI seed file.
* This includes the script loading mechanism, a simple queue, and the core utilities for the library.
* @module yui
* @submodule yui-base
*/
(function() {
var _instances = {},
_startTime = new Date().getTime(),
p,
i,
add = function () {
if (window.addEventListener) {
return function(el, type, fn, capture) {
el.addEventListener(type, fn, (!!capture));
};
} else if (window.attachEvent) {
return function(el, type, fn) {
el.attachEvent("on" + type, fn);
};
} else {
return function(){};
}
}(),
remove = function() {
if (window.removeEventListener) {
return function (el, type, fn, capture) {
el.removeEventListener(type, fn, !!capture);
};
} else if (window.detachEvent) {
return function (el, type, fn) {
el.detachEvent("on" + type, fn);
};
} else {
return function(){};
}
}(),
globalListener = function() {
YUI.Env.windowLoaded = true;
YUI.Env.DOMReady = true;
remove(window, 'load', globalListener);
},
// @TODO: this needs to be created at build time from module metadata
_APPLY_TO_WHITE_LIST = {
'io.xdrReady': 1,
'io.xdrResponse':1
},
SLICE = Array.prototype.slice;
// reduce to one or the other
if (typeof YUI === 'undefined' || !YUI) {
/**
* The YUI global namespace object. If YUI is already defined, the
* existing YUI object will not be overwritten so that defined
* namespaces are preserved.
*
* @class YUI
* @constructor
* @global
* @uses EventTarget
* @param o* Up to five optional configuration objects. This object is stored
* in YUI.config. See config for the list of supported properties.
*/
/*global YUI*/
/*global YUI_config*/
// @TODO Advice was to make a function, disallow direct instantiation.
YUI = function(o1, o2, o3, o4, o5) {
var Y = this, a = arguments, i, l = a.length,
globalConfig = (typeof YUI_config !== 'undefined') && YUI_config;
// Allow instantiation without the new operator
if (!(Y instanceof YUI)) {
return new YUI(o1, o2, o3, o4, o5);
} else {
// set up the core environment
Y._init();
if (globalConfig) {
Y._config(globalConfig);
}
for (i=0; i<l; i++) {
Y._config(a[i]);
}
// bind the specified additional modules for this instance
Y._setup();
return Y;
}
};
}
// The prototype contains the functions that are required to allow the external
// modules to be registered and for the instance to be initialized.
YUI.prototype = {
_config: function(o) {
o = o || {};
var c = this.config, i, j, m, mods;
mods = c.modules;
for (i in o) {
if (mods && i == 'modules') {
m = o[i];
for (j in m) {
if (m.hasOwnProperty(j)) {
mods[j] = m[j];
}
}
} else if (i == 'win') {
c[i] = o[i].contentWindow || o[i];
c.doc = c[i].document;
} else {
c[i] = o[i];
}
}
},
/**
* Initialize this YUI instance
* @private
*/
_init: function() {
// find targeted window/frame
// @TODO create facades
var v = '@VERSION@', Y = this, filter;
if (v.indexOf('@') > -1) {
v = 'test';
}
Y.version = v;
Y.Env = {
// @todo expand the new module metadata
mods: {},
cdn: 'http://yui.yahooapis.com/' + v + '/build/',
bootstrapped: false,
_idx: 0,
_used: {},
_attached: {},
_yidx: 0,
_uidx: 0,
_loaded: {}
};
Y.Env._loaded[v] = {};
if (YUI.Env) {
Y.Env._yidx = (++YUI.Env._yidx);
Y.Env._guidp = ('yui_' + v + '-' + Y.Env._yidx + '-' + _startTime).replace(/\./g, '_');
Y.id = Y.stamp(Y);
_instances[Y.id] = Y;
}
Y.constructor = YUI;
// configuration defaults
Y.config = {
win: window || {},
doc: document,
debug: true,
useBrowserConsole: true,
throwFail: true,
bootstrap: true,
fetchCSS: true,
base: (Y === YUI) ? Y.Env.cdn : function() {
var b, nodes, i, src, match;
// get from querystring
nodes = document.getElementsByTagName('script');
for (i=0; i<nodes.length; i=i+1) {
src = nodes[i].src;
if (src) {
// DEBUG
//src = "http://yui.yahooapis.com/combo?2.8.0r4/build/yuiloader-dom-event/yuiloader-dom-event.js&3.0.0/build/yui/yui-min.js";
//console.log('src) ' + src);
// DEBUG
match = src.match(/^(.*)yui\/yui([\.\-].*)js(\?.*)?$/);
b = match && match[1];
// First stage base extraction
// console.log('1) ' + b);
if (b) {
filter = match[2];
console.log('filter: ' + filter);
// extract correct path for mixed combo urls
// http://yuilibrary.com/projects/yui3/ticket/2528423
// http://yui.yahooapis.com/combo?2.8.0r4/build/yuiloader-dom-event/yuiloader-dom-event.js&3.0.0/build/yui/yui-min.js
match = src.match(/^(.*\?)(.*\&)(.*)yui\/yui[\.\-].*js(\?.*)?$/);
if (match && match[3]) {
b = match[1] + match[3];
}
break;
}
}
}
// console.log('2) ' + b);
// use CDN default
return b || Y.Env.cdn;
}(),
loaderPath: 'loader/loader' + (filter || '-min.') + 'js'
};
},
/**
* Finishes the instance setup. Attaches whatever modules were defined
* when the yui modules was registered.
* @method _setup
* @private
*/
_setup: function(o) {
this.use("yui-base");
},
/**
* Executes a method on a YUI instance with
* the specified id if the specified method is whitelisted.
* @method applyTo
* @param id {string} the YUI instance id
* @param method {string} the name of the method to exectute.
* Ex: 'Object.keys'
* @param args {Array} the arguments to apply to the method
* @return {object} the return value from the applied method or null
*/
applyTo: function(id, method, args) {
if (!(method in _APPLY_TO_WHITE_LIST)) {
this.log(method + ': applyTo not allowed', 'warn', 'yui');
return null;
}
var instance = _instances[id], nest, m, i;
if (instance) {
nest = method.split('.');
m = instance;
for (i=0; i<nest.length; i=i+1) {
m = m[nest[i]];
if (!m) {
this.log('applyTo not found: ' + method, 'warn', 'yui');
}
}
return m.apply(instance, args);
}
return null;
},
/**
* Register a module
* @method add
* @param name {string} module name
* @param fn {Function} entry point into the module that
* is used to bind module to the YUI instance
* @param version {string} version string
* @param details optional config data:
* requires - features that should be present before loading
* optional - optional features that should be present if load optional defined
* use - features that should be attached automatically
* skinnable -
* rollup
* omit - features that should not be loaded if this module is present
* @return {YUI} the YUI instance
*
*/
add: function(name, fn, version, details) {
// this.log('Adding a new component ' + name);
// @todo expand this to include version mapping
// @todo may want to restore the build property
// @todo fire moduleAvailable event
YUI.Env.mods[name] = {
name: name,
fn: fn,
version: version,
details: details || {}
};
return this; // chain support
},
_attach: function(r, fromLoader) {
var mods = YUI.Env.mods,
attached = this.Env._attached,
i, l = r.length, name, m, d, req, use;
for (i=0; i<l; i=i+1) {
name = r[i];
m = mods[name];
// console.log(name + '::' + m);
if (!m) {
}
if (!attached[name] && m) {
attached[name] = true;
d = m.details;
req = d.requires;
use = d.use;
// console.log(req);
// console.log(use);
if (req) {
this._attach(this.Array(req));
}
// this.log('attaching ' + name, 'info', 'yui');
if (m.fn) {
m.fn(this);
}
if (use) {
this._attach(this.Array(use));
}
}
}
},
/**
* Bind a module to a YUI instance
* @param modules* {string} 1-n modules to bind (uses arguments array)
* @param *callback {function} callback function executed when
* the instance has the required functionality. If included, it
* must be the last parameter.
*
* @TODO
* Implement versioning? loader can load different versions?
* Should sub-modules/plugins be normal modules, or do
* we add syntax for specifying these?
*
* YUI().use('dragdrop')
* YUI().use('dragdrop:2.4.0'); // specific version
* YUI().use('dragdrop:2.4.0-'); // at least this version
* YUI().use('dragdrop:2.4.0-2.9999.9999'); // version range
* YUI().use('*'); // use all available modules
* YUI().use('lang+dump+substitute'); // use lang and some plugins
* YUI().use('lang+*'); // use lang and all known plugins
*
*
* @return {YUI} the YUI instance
*/
use: function() {
if (this._loading) {
this._useQueue = this._useQueue || new this.Queue();
this._useQueue.add(SLICE.call(arguments, 0));
return this;
}
var Y = this,
a=SLICE.call(arguments, 0),
mods = YUI.Env.mods,
used = Y.Env._used,
loader,
firstArg = a[0],
dynamic = false,
callback = a[a.length-1],
boot = Y.config.bootstrap,
k, i, l, missing = [],
r = [],
css = Y.config.fetchCSS,
f = function(name) {
// only attach a module once
if (used[name]) {
return;
}
var m = mods[name], j, req, use;
if (m) {
used[name] = true;
req = m.details.requires;
use = m.details.use;
} else {
// CSS files don't register themselves, see if it has been loaded
if (!YUI.Env._loaded[Y.version][name]) {
missing.push(name);
} else {
// probably css
used[name] = true;
}
}
// make sure requirements are attached
if (req) {
if (Y.Lang.isString(req)) {
f(req);
} else {
for (j = 0; j < req.length; j = j + 1) {
f(req[j]);
}
}
}
// add this module to full list of things to attach
r.push(name);
},
onComplete;
// The last argument supplied to use can be a load complete callback
if (typeof callback === 'function') {
a.pop();
} else {
callback = null;
}
onComplete = function(fromLoader) {
fromLoader = fromLoader || {
success: true,
msg: 'not dynamic'
};
if (callback) {
callback(Y, fromLoader);
}
if (Y.fire) {
Y.fire('yui:load', Y, fromLoader);
}
// process queued use requests as long until done
// or dynamic load happens again.
Y._loading = false;
if (Y._useQueue && Y._useQueue.size() && !Y._loading) {
Y.use.apply(Y, Y._useQueue.next());
}
};
// YUI().use('*'); // bind everything available
if (firstArg === "*") {
a = [];
for (k in mods) {
if (mods.hasOwnProperty(k)) {
a.push(k);
}
}
if (callback) {
a.push(callback);
}
return Y.use.apply(Y, a);
}
// use loader to expand dependencies and sort the
// requirements if it is available.
if (Y.Loader) {
dynamic = true;
loader = new Y.Loader(Y.config);
loader.require(a);
loader.ignoreRegistered = true;
loader.allowRollup = false;
// loader.calculate(null, (css && css == 'force') ? null : 'js');
// loader.calculate();
loader.calculate(null, (css) ? null : 'js');
a = loader.sorted;
}
l = a.length;
// process each requirement and any additional requirements
// the module metadata specifies
for (i=0; i<l; i=i+1) {
f(a[i]);
}
l = missing.length;
if (l) {
missing = Y.Object.keys(Y.Array.hash(missing));
}
// dynamic load
if (boot && l && Y.Loader) {
Y._loading = true;
loader = new Y.Loader(Y.config);
loader.onSuccess = onComplete;
loader.onFailure = onComplete;
loader.onTimeout = onComplete;
loader.context = Y;
loader.attaching = a;
// loader.require(missing);
loader.require((css) ? missing : a);
loader.insert(null, (css) ? null : 'js');
} else if (boot && l && Y.Get && !Y.Env.bootstrapped) {
Y._loading = true;
a = Y.Array(arguments, 0, true);
// a.unshift('loader');
Y.Get.script(Y.config.base + Y.config.loaderPath, {
onEnd: function() {
Y._loading = false;
Y.Env.bootstrapped = true;
Y._attach(['loader']);
Y.use.apply(Y, a);
}
});
return Y;
} else {
if (l) {
Y.message('Unable or not configured to fetch missing modules: ' + missing, 'info', 'yui');
}
Y._attach(r);
onComplete();
}
return Y; // chain support var yui = YUI().use('dragdrop');
},
/**
* Returns the namespace specified and creates it if it doesn't exist
* <pre>
* YUI.namespace("property.package");
* YUI.namespace("YAHOO.property.package");
* </pre>
* Either of the above would create YUI.property, then
* YUI.property.package (YAHOO is scrubbed out, this is
* to remain compatible with YUI2)
*
* Be careful when naming packages. Reserved words may work in some browsers
* and not others. For instance, the following will fail in Safari:
* <pre>
* YUI.namespace("really.long.nested.namespace");
* </pre>
* This fails because "long" is a future reserved word in ECMAScript
*
* @method namespace
* @param {string*} arguments 1-n namespaces to create
* @return {object} A reference to the last namespace object created
*/
namespace: function() {
var a=arguments, o=null, i, j, d;
for (i=0; i<a.length; i=i+1) {
d = ("" + a[i]).split(".");
o = this;
for (j=(d[0] == "YAHOO") ? 1 : 0; j<d.length; j=j+1) {
o[d[j]] = o[d[j]] || {};
o = o[d[j]];
}
}
return o;
},
// this is replaced if the log module is included
log: function() {
},
/**
* Report an error. The reporting mechanism is controled by
* the 'throwFail' configuration attribute. If throwFail is
* not specified, the message is written to the Logger, otherwise
* a JS error is thrown
* @method error
* @param msg {string} the error message
* @param e {Error} Optional JS error that was caught. If supplied
* and throwFail is specified, this error will be re-thrown.
* @return {YUI} this YUI instance
*/
error: function(msg, e) {
if (this.config.throwFail) {
throw (e || new Error(msg));
} else {
this.message(msg, "error"); // don't scrub this one
}
return this;
},
/**
* Generate an id that is unique among all YUI instances
* @method guid
* @param pre {string} optional guid prefix
* @return {string} the guid
*/
guid: function(pre) {
var id = this.Env._guidp + (++this.Env._uidx);
return (pre) ? (pre + id) : id;
},
/**
* Returns a guid associated with an object. If the object
* does not have one, a new one is created unless readOnly
* is specified.
* @method stamp
* @param o The object to stamp
* @param readOnly {boolean} if true, a valid guid will only
* be returned if the object has one assigned to it.
* @return {string} The object's guid or null
*/
stamp: function(o, readOnly) {
if (!o) {
return o;
}
var uid = (typeof o === 'string') ? o : o._yuid;
if (!uid) {
uid = this.guid();
if (!readOnly) {
try {
o._yuid = uid;
} catch(e) {
uid = null;
}
}
}
return uid;
}
};
// Give the YUI global the same properties as an instance.
// This makes it so that the YUI global can be used like the YAHOO
// global was used prior to 3.x. More importantly, the YUI global
// provides global metadata, so env needs to be configured.
// @TODO review
p = YUI.prototype;
// inheritance utilities are not available yet
for (i in p) {
// if (1) { // intenionally ignoring hasOwnProperty check
YUI[i] = p[i];
// }
}
// set up the environment
YUI._init();
// add a window load event at load time so we can capture
// the case where it fires before dynamic loading is
// complete.
add(window, 'load', globalListener);
YUI.Env.add = add;
YUI.Env.remove = remove;
})();
/**
* The config object contains all of the configuration options for
* the YUI instance. This object is supplied by the implementer
* when instantiating a YUI instance. Some properties have default
* values if they are not supplied by the implementer.
*
* @class config
* @static
*/
/**
* Allows the YUI seed file to fetch the loader component and library
* metadata to dynamically load additional dependencies.
*
* @property bootstrap
* @type boolean
* @default true
*/
/**
* Log to the browser console if debug is on and the browser has a
* supported console.
*
* @property useBrowserConsole
* @type boolean
* @default true
*/
/**
* A hash of log sources that should be logged. If specified, only log messages from these sources will be logged.
*
* @property logInclude
* @type object
*/
/**
* A hash of log sources that should be not be logged. If specified, all sources are logged if not on this list.
*
* @property logExclude
* @type object
*/
/**
* Set to true if the yui seed file was dynamically loaded in
* order to bootstrap components relying on the window load event
* and the 'domready' custom event.
*
* @property injected
* @type object
*/
/**
* If throwFail is set, Y.fail will generate or re-throw a JS Error. Otherwise the failure is logged.
*
* @property throwFail
* @type boolean
* @default true
*/
/**
* The window/frame that this instance should operate in.
*
* @property win
* @type Window
* @default the window hosting YUI
*/
/**
* The document associated with the 'win' configuration.
*
* @property doc
* @type Document
* @default the document hosting YUI
*/
/**
* A list of modules that defines the YUI core (overrides the default).
*
* @property core
* @type string[]
*/
/**
* The default date format
*
* @property dateFormat
* @type string
*/
/**
* The default locale
*
* @property locale
* @type string
*/
/**
* The default interval when polling in milliseconds.
*
* @property pollInterval
* @type int
* @default 20
*/
/**
* The number of dynamic nodes to insert by default before
* automatically removing them. This applies to script nodes
* because remove the node will not make the evaluated script
* unavailable. Dynamic CSS is not auto purged, because removing
* a linked style sheet will also remove the style definitions.
*
* @property purgethreshold
* @type int
* @default 20
*/
/**
* The default interval when polling in milliseconds.
*
* @property windowResizeDelay
* @type int
* @default 40
*/
/**
* Base directory for dynamic loading
*
* @property base
* @type string
*/
/**
* The secure base dir (not implemented)
*
* For dynamic loading.
*
* @property secureBase
* @type string
*/
/**
* The YUI combo service base dir. Ex: http://yui.yahooapis.com/combo?
*
* For dynamic loading.
*
* @property comboBase
* @type string
*/
/**
* The root path to prepend to module names for the combo service. Ex: 3.0.0b1/build/
*
* For dynamic loading.
*
* @property root
* @type string
*/
/**
* A filter to apply to result urls. This filter will modify the default
* path for all modules. The default path for the YUI library is the
* minified version of the files (e.g., event-min.js). The filter property
* can be a predefined filter or a custom filter. The valid predefined
* filters are:
* <dl>
* <dt>DEBUG</dt>
* <dd>Selects the debug versions of the library (e.g., event-debug.js).
* This option will automatically include the Logger widget</dd>
* <dt>RAW</dt>
* <dd>Selects the non-minified version of the library (e.g., event.js).</dd>
* </dl>
* You can also define a custom filter, which must be an object literal
* containing a search expression and a replace string:
* <pre>
* myFilter: {
* 'searchExp': "-min\\.js",
* 'replaceStr': "-debug.js"
* }
* </pre>
*
* For dynamic loading.
*
* @property filter
* @type string|object
*/
/**
* Hash of per-component filter specification. If specified for a given component,
* this overrides the filter config
*
* For dynamic loading.
*
* @property filters
* @type object
*/
/**
* Use the YUI combo service to reduce the number of http connections
* required to load your dependencies.
*
* For dynamic loading.
*
* @property combine
* @type boolean
* @default true if 'base' is not supplied, false if it is.
*/
/**
* A list of modules that should never be dynamically loaded
*
* @property ignore
* @type string[]
*/
/**
* A list of modules that should always be loaded when required, even if already
* present on the page.
*
* @property force
* @type string[]
*/
/**
* Node or id for a node that should be used as the insertion point for new nodes
* For dynamic loading.
*
* @property insertBefore
* @type string
*/
/**
* charset for dynamic nodes
*
* @property charset
* @type string
* @deprecated use jsAttributes cssAttributes
*/
/**
* Object literal containing attributes to add to dynamically loaded script nodes.
*
* @property jsAttributes
* @type string
*/
/**
* Object literal containing attributes to add to dynamically loaded link nodes.
*
* @property cssAttributes
* @type string
*/
/**
* Number of milliseconds before a timeout occurs when dynamically
* loading nodes. If not set, there is no timeout.
*
* @property timeout
* @type int
*/
/**
* Callback for the 'CSSComplete' event. When dynamically loading YUI
* components with CSS, this property fires when the CSS is finished
* loading but script loading is still ongoing. This provides an
* opportunity to enhance the presentation of a loading page a little
* bit before the entire loading process is done.
*
* @property onCSS
* @type function
*/
/**
* A list of module definitions to add to the list of YUI components.
* These components can then be dynamically loaded side by side with
* YUI via the use() method.See Loader.addModule for the supported
* module metadata.
*
* @property modules
* @type function
*/
/**
* The loader 'path' attribute to the loader itself. This is combined
* with the 'base' attribute to dynamically load the loader component
* when boostrapping with the get utility alone.
*
* @property loaderPath
* @default loader/loader-min.js
*/
/*
*
* Specifies whether or not YUI().use(...) will attempt to load CSS
* resources at all. Any truthy value will cause CSS dependencies
* to load when fetching script. The special value 'force' will
* cause CSS dependencies to be loaded even if no script is needed.
*