3
Copyright 2012 Yahoo! Inc. All rights reserved.
4
Licensed under the BSD License.
5
http://yuilibrary.com/license/
8
* The YUI module contains the components required for building the YUI seed
9
* file. This includes the script loading mechanism, a simple queue, and
10
* the core utilities for the library.
15
if (typeof YUI != 'undefined') {
20
The YUI global namespace object. If YUI is already defined, the
21
existing YUI object will not be overwritten so that defined
22
namespaces are preserved. It is the constructor for the object
23
the end user interacts with. As indicated below, each instance
24
has full custom event support, but only if the event system
25
is available. This is a self-instantiable factory function. You
26
can invoke it directly like this:
28
YUI().use('*', function(Y) {
32
But it also works like this:
36
Configuring the YUI object:
41
}).use('node', function(Y) {
42
//Node is ready to use
45
See the API docs for the <a href="config.html">Config</a> class
46
for the complete list of supported configuration properties accepted
47
by the YUI constuctor.
53
@param [o]* {Object} 0..n optional configuration objects. these values
54
are store in Y.config. See <a href="config.html">Config</a> for the list of supported
59
var YUI = function() {
64
instanceOf = function(o, type) {
65
return (o && o.hasOwnProperty && (o instanceof type));
67
gconf = (typeof YUI_config !== 'undefined') && YUI_config;
69
if (!(instanceOf(Y, YUI))) {
72
// set up the core environment
76
YUI.GlobalConfig is a master configuration that might span
77
multiple contexts in a non-browser environment. It is applied
78
first to all instances in all contexts.
79
@property GlobalConfig
90
YUI().use('node', function(Y) {
91
//debug files used here
96
}).use('node', function(Y) {
101
if (YUI.GlobalConfig) {
102
Y.applyConfig(YUI.GlobalConfig);
106
YUI_config is a page-level config. It is applied to all
107
instances created on the page. This is applied after
108
YUI.GlobalConfig, and before the instance level configuration
116
//Single global var to include before YUI seed file
121
YUI().use('node', function(Y) {
122
//debug files used here
127
}).use('node', function(Y) {
128
//min files used here
132
Y.applyConfig(gconf);
135
// bind the specified additional modules for this instance
142
// Each instance can accept one or more configuration objects.
143
// These are applied after YUI.GlobalConfig and YUI_Config,
144
// overriding values set in those config files if there is a '
145
// matching property.
147
Y.applyConfig(args[i]);
153
Y.instanceOf = instanceOf;
163
BASE = 'http://yui.yahooapis.com/',
164
DOC_LABEL = 'yui3-js-enabled',
165
CSS_STAMP_EL = 'yui3-css-stamp',
166
NOOP = function() {},
167
SLICE = Array.prototype.slice,
168
APPLY_TO_AUTH = { 'io.xdrReady': 1, // the functions applyTo
169
'io.xdrResponse': 1, // can call. this should
170
'SWF.eventHandler': 1 }, // be done at build time
171
hasWin = (typeof window != 'undefined'),
172
win = (hasWin) ? window : null,
173
doc = (hasWin) ? win.document : null,
174
docEl = doc && doc.documentElement,
175
docClass = docEl && docEl.className,
177
time = new Date().getTime(),
178
add = function(el, type, fn, capture) {
179
if (el && el.addEventListener) {
180
el.addEventListener(type, fn, capture);
181
} else if (el && el.attachEvent) {
182
el.attachEvent('on' + type, fn);
185
remove = function(el, type, fn, capture) {
186
if (el && el.removeEventListener) {
187
// this can throw an uncaught exception in FF
189
el.removeEventListener(type, fn, capture);
191
} else if (el && el.detachEvent) {
192
el.detachEvent('on' + type, fn);
195
handleLoad = function() {
196
YUI.Env.windowLoaded = true;
197
YUI.Env.DOMReady = true;
199
remove(window, 'load', handleLoad);
202
getLoader = function(Y, o) {
203
var loader = Y.Env._loader;
205
//loader._config(Y.config);
206
loader.ignoreRegistered = false;
209
loader.required = [];
210
loader.loadType = null;
212
loader = new Y.Loader(Y.config);
213
Y.Env._loader = loader;
215
YUI.Env.core = Y.Array.dedupe([].concat(YUI.Env.core, [ 'loader-base', 'loader-rollup', 'loader-yui3' ]));
220
clobber = function(r, s) {
222
if (s.hasOwnProperty(i)) {
228
ALREADY_DONE = { success: true };
230
// Stamp the documentElement (HTML) with a class of "yui-loaded" to
231
// enable styles that need to key off of JS being enabled.
232
if (docEl && docClass.indexOf(DOC_LABEL) == -1) {
236
docClass += DOC_LABEL;
237
docEl.className = docClass;
240
if (VERSION.indexOf('@') > -1) {
241
VERSION = '3.3.0'; // dev time hack for cdn test
246
* Applies a new configuration object to the YUI instance config.
247
* This will merge new group/module definitions, and will also
248
* update the loader cache if necessary. Updating Y.config directly
249
* will not update the cache.
250
* @method applyConfig
251
* @param {Object} o the configuration object.
254
applyConfig: function(o) {
261
config = this.config,
262
mods = config.modules,
263
groups = config.groups,
264
aliases = config.aliases,
265
loader = this.Env._loader;
268
if (o.hasOwnProperty(name)) {
270
if (mods && name == 'modules') {
272
} else if (aliases && name == 'aliases') {
273
clobber(aliases, attr);
274
} else if (groups && name == 'groups') {
275
clobber(groups, attr);
276
} else if (name == 'win') {
277
config[name] = (attr && attr.contentWindow) || attr;
278
config.doc = config[name] ? config[name].document : null;
279
} else if (name == '_yuid') {
293
* Old way to apply a config to the instance (calls `applyConfig` under the hood)
296
* @param {Object} o The config to apply
298
_config: function(o) {
303
* Initialize this YUI instance
315
* The version number of the YUI instance.
323
core: ['get','features','intl-base','yui-log', 'yui-log-nodejs', 'yui-later','loader-base', 'loader-rollup', 'loader-yui3'],
324
mods: {}, // flat module map
325
versions: {}, // version module map
327
cdn: BASE + VERSION + '/build/',
328
// bootstrapped: false,
339
// I'll start at the \b(simpleyui).
340
// 1. Look in the test string for "simpleyui" or "yui" or
341
// "yui-base" or "yui-davglass" or "yui-foobar" that comes after a word break. That is, it
342
// can't match "foyui" or "i_heart_simpleyui". This can be anywhere in the string.
343
// 2. After #1 must come a forward slash followed by the string matched in #1, so
344
// "yui-base/yui-base" or "simpleyui/simpleyui" or "yui-pants/yui-pants".
345
// 3. The second occurence of the #1 token can optionally be followed by "-debug" or "-min",
346
// so "yui/yui-min", "yui/yui-debug", "yui-base/yui-base-debug". NOT "yui/yui-tshirt".
347
// 4. This is followed by ".js", so "yui/yui.js", "simpleyui/simpleyui-min.js"
348
// 0. Going back to the beginning, now. If all that stuff in 1-4 comes after a "?" in the string,
349
// then capture the junk between the LAST "&" and the string in 1-4. So
350
// "blah?foo/yui/yui.js" will capture "foo/" and "blah?some/thing.js&3.3.0/build/yui-davglass/yui-davglass.js"
351
// will capture "3.3.0/build/"
355
// (?:[^&]*&) followed by 0..n characters followed by an &
356
// * in fact, find as many sets of characters followed by a & as you can
357
// ([^&]*) capture the stuff after the last & in \1
358
// )? but it's ok if all this ?junk&more_junk stuff isn't even there
359
// \b(simpleyui| after a word break find either the string "simpleyui" or
360
// yui(?:-\w+)? the string "yui" optionally followed by a -, then more characters
361
// ) and store the simpleyui or yui-* string in \2
362
// \/\2 then comes a / followed by the simpleyui or yui-* string in \2
363
// (?:-(min|debug))? optionally followed by "-min" or "-debug"
364
// .js and ending in ".js"
365
_BASE_RE: /(?:\?(?:[^&]*&)*([^&]*))?\b(simpleyui|yui(?:-\w+)?)\/\2(?:-(min|debug))?\.js/,
366
parseBasePath: function(src, pattern) {
367
var match = src.match(pattern),
371
path = RegExp.leftContext || src.slice(0, src.indexOf(match[0]));
373
// this is to set up the path to the loader. The file
374
// filter for loader should match the yui include.
377
// extract correct path for mixed combo urls
378
// http://yuilibrary.com/projects/yui3/ticket/2528423
380
path += '?' + match[1];
389
getBase: G_ENV && G_ENV.getBase ||
391
var nodes = (doc && doc.getElementsByTagName('script')) || [],
392
path = Env.cdn, parsed,
395
for (i = 0, len = nodes.length; i < len; ++i) {
398
parsed = Y.Env.parseBasePath(src, pattern);
400
filter = parsed.filter;
415
Env._loaded[VERSION] = {};
417
if (G_ENV && Y !== YUI) {
418
Env._yidx = ++G_ENV._yidx;
419
Env._guidp = ('yui_' + VERSION + '_' +
420
Env._yidx + '_' + time).replace(/\./g, '_');
421
} else if (YUI._YUI) {
423
G_ENV = YUI._YUI.Env;
424
Env._yidx += G_ENV._yidx;
425
Env._uidx += G_ENV._uidx;
427
for (prop in G_ENV) {
428
if (!(prop in Env)) {
429
Env[prop] = G_ENV[prop];
443
// configuration defaults
444
Y.config = Y.config || {
451
useBrowserConsole: true,
456
//Register the CSS stamp element
457
if (doc && !doc.getElementById(CSS_STAMP_EL)) {
458
el = doc.createElement('div');
459
el.innerHTML = '<div id="' + CSS_STAMP_EL + '" style="position: absolute !important; visibility: hidden !important"></div>';
460
YUI.Env.cssStampEl = el.firstChild;
461
docEl.insertBefore(YUI.Env.cssStampEl, docEl.firstChild);
464
Y.config.lang = Y.config.lang || 'en-US';
466
Y.config.base = YUI.config.base || Y.Env.getBase(Y.Env._BASE_RE);
468
if (!filter || (!('mindebug').indexOf(filter))) {
471
filter = (filter) ? '-' + filter : filter;
472
Y.config.loaderPath = YUI.config.loaderPath || 'loader/loader' + filter + '.js';
477
* Finishes the instance setup. Attaches whatever modules were defined
478
* when the yui modules was registered.
482
_setup: function(o) {
486
//extras = Y.config.core || ['get','features','intl-base','yui-log', 'yui-log-nodejs', 'yui-later','loader-base', 'loader-rollup', 'loader-yui3'];
487
extras = Y.config.core || [].concat(YUI.Env.core); //Clone it..
489
for (i = 0; i < extras.length; i++) {
490
if (mods[extras[i]]) {
491
core.push(extras[i]);
495
Y._attach(['yui-base']);
502
// Y.log(Y.id + ' initialized', 'info', 'yui');
506
* Executes a method on a YUI instance with
507
* the specified id if the specified method is whitelisted.
509
* @param id {String} the YUI instance id.
510
* @param method {String} the name of the method to exectute.
512
* @param args {Array} the arguments to apply to the method.
513
* @return {Object} the return value from the applied method or null.
515
applyTo: function(id, method, args) {
516
if (!(method in APPLY_TO_AUTH)) {
517
this.log(method + ': applyTo not allowed', 'warn', 'yui');
521
var instance = instances[id], nest, m, i;
523
nest = method.split('.');
525
for (i = 0; i < nest.length; i = i + 1) {
528
this.log('applyTo not found: ' + method, 'warn', 'yui');
531
return m && m.apply(instance, args);
538
Registers a module with the YUI global. The easiest way to create a
539
first-class YUI module is to use the YUI component build tool.
541
http://yuilibrary.com/projects/builder
543
The build system will produce the `YUI.add` wrapper for you module, along
544
with any configuration info required for the module.
546
@param name {String} module name.
547
@param fn {Function} entry point into the module that is used to bind module to the YUI instance.
548
@param {YUI} fn.Y The YUI instance this module is executed in.
549
@param {String} fn.name The name of the module
550
@param version {String} version string.
551
@param details {Object} optional config data:
552
@param details.requires {Array} features that must be present before this module can be attached.
553
@param details.optional {Array} optional features that should be present if loadOptional
554
is defined. Note: modules are not often loaded this way in YUI 3,
555
but this field is still useful to inform the user that certain
556
features in the component will require additional dependencies.
557
@param details.use {Array} features that are included within this module which need to
558
be attached automatically when this module is attached. This
559
supports the YUI 3 rollup system -- a module with submodules
560
defined will need to have the submodules listed in the 'use'
561
config. The YUI component build tool does this for you.
562
@return {YUI} the YUI instance.
565
YUI.add('davglass', function(Y, name) {
566
Y.davglass = function() {
567
alert('Dav was here!');
569
}, '3.4.0', { requires: ['yui-base', 'harley-davidson', 'mt-dew'] });
572
add: function(name, fn, version, details) {
573
details = details || {};
582
i, versions = env.versions;
584
env.mods[name] = mod;
585
versions[version] = versions[version] || {};
586
versions[version][name] = mod;
588
for (i in instances) {
589
if (instances.hasOwnProperty(i)) {
590
loader = instances[i].Env._loader;
592
if (!loader.moduleInfo[name] || loader.moduleInfo[name].temp) {
593
loader.addModule(details, name);
603
* Executes the function associated with each required
604
* module, binding the module to the YUI instance.
605
* @param {Array} r The array of modules to attach
606
* @param {Boolean} [moot=false] Don't throw a warning if the module is not attached
610
_attach: function(r, moot) {
611
var i, name, mod, details, req, use, after,
613
aliases = YUI.Env.aliases,
615
loader = Y.Env._loader,
616
done = Y.Env._attached,
617
len = r.length, loader,
620
//Check for conditional modules (in a second+ instance) and add their requirements
621
//TODO I hate this entire method, it needs to be fixed ASAP (3.5.0) ^davglass
622
for (i = 0; i < len; i++) {
626
if (loader && loader.conditions[name]) {
627
Y.Object.each(loader.conditions[name], function(def) {
628
var go = def && ((def.ua && Y.UA[def.ua]) || (def.test && def.test(Y)));
638
for (i = 0; i < len; i++) {
643
if (aliases && aliases[name]) {
644
Y._attach(aliases[name]);
648
if (loader && loader.moduleInfo[name]) {
649
mod = loader.moduleInfo[name];
653
// Y.log('no js def for: ' + name, 'info', 'yui');
655
//if (!loader || !loader.moduleInfo[name]) {
656
//if ((!loader || !loader.moduleInfo[name]) && !moot) {
658
if ((name.indexOf('skin-') === -1) && (name.indexOf('css') === -1)) {
659
Y.Env._missed.push(name);
660
Y.Env._missed = Y.Array.dedupe(Y.Env._missed);
661
Y.message('NOT loaded: ' + name, 'warn', 'yui');
666
//Don't like this, but in case a mod was asked for once, then we fetch it
667
//We need to remove it from the missed list ^davglass
668
for (j = 0; j < Y.Env._missed.length; j++) {
669
if (Y.Env._missed[j] === name) {
670
Y.message('Found: ' + name + ' (was reported as missing earlier)', 'warn', 'yui');
671
Y.Env._missed.splice(j, 1);
674
details = mod.details;
675
req = details.requires;
677
after = details.after;
680
for (j = 0; j < req.length; j++) {
682
if (!Y._attach(req)) {
691
for (j = 0; j < after.length; j++) {
692
if (!done[after[j]]) {
693
if (!Y._attach(after, true)) {
705
Y.error('Attach error: ' + name, e, name);
711
for (j = 0; j < use.length; j++) {
713
if (!Y._attach(use)) {
731
* Attaches one or more modules to the YUI instance. When this
732
* is executed, the requirements are analyzed, and one of
733
* several things can happen:
735
* * All requirements are available on the page -- The modules
736
* are attached to the instance. If supplied, the use callback
737
* is executed synchronously.
739
* * Modules are missing, the Get utility is not available OR
740
* the 'bootstrap' config is false -- A warning is issued about
741
* the missing modules and all available modules are attached.
743
* * Modules are missing, the Loader is not available but the Get
744
* utility is and boostrap is not false -- The loader is bootstrapped
745
* before doing the following....
747
* * Modules are missing and the Loader is available -- The loader
748
* expands the dependency tree and fetches missing modules. When
749
* the loader is finshed the callback supplied to use is executed
753
* @param modules* {String|Array} 1-n modules to bind (uses arguments array).
754
* @param [callback] {Function} callback function executed when
755
* the instance has the required functionality. If included, it
756
* must be the last parameter.
757
* @param callback.Y {YUI} The `YUI` instance created for this sandbox
758
* @param callback.data {Object} Object data returned from `Loader`.
761
* // loads and attaches dd and its dependencies
762
* YUI().use('dd', function(Y) {});
764
* // loads and attaches dd and node as well as all of their dependencies (since 3.4.0)
765
* YUI().use(['dd', 'node'], function(Y) {});
767
* // attaches all modules that are available on the page
768
* YUI().use('*', function(Y) {});
770
* // intrinsic YUI gallery support (since 3.1.0)
771
* YUI().use('gallery-yql', function(Y) {});
773
* // intrinsic YUI 2in3 support (since 3.1.0)
774
* YUI().use('yui2-datatable', function(Y) {});
776
* @return {YUI} the YUI instance.
779
var args = SLICE.call(arguments, 0),
780
callback = args[args.length - 1],
788
// The last argument supplied to use can be a load complete callback
789
if (Y.Lang.isFunction(callback)) {
794
if (Y.Lang.isArray(args[0])) {
798
if (Y.config.cacheUse) {
799
while ((name = args[i++])) {
800
if (!Env._attached[name]) {
808
Y.log('already provisioned: ' + args, 'info', 'yui');
810
Y._notify(callback, ALREADY_DONE, args);
816
Y._useQueue = Y._useQueue || new Y.Queue();
817
Y._useQueue.add([args, callback]);
819
Y._use(args, function(Y, response) {
820
Y._notify(callback, response, args);
827
* Notify handler from Loader for attachment/load errors
829
* @param callback {Function} The callback to pass to the `Y.config.loadErrorFn`
830
* @param response {Object} The response returned from Loader
831
* @param args {Array} The aruments passed from Loader
834
_notify: function(callback, response, args) {
835
if (!response.success && this.config.loadErrorFn) {
836
this.config.loadErrorFn.call(this, this, callback, response, args);
837
} else if (callback) {
839
callback(this, response);
841
this.error('use callback error', e, args);
847
* This private method is called from the `use` method queue. To ensure that only one set of loading
848
* logic is performed at a time.
851
* @param args* {String} 1-n modules to bind (uses arguments array).
852
* @param *callback {Function} callback function executed when
853
* the instance has the required functionality. If included, it
854
* must be the last parameter.
856
_use: function(args, callback) {
859
this._attach(['yui-base']);
862
var len, loader, handleBoot, handleRLS,
868
aliases = G_ENV.aliases,
869
queue = G_ENV._loaderQueue,
873
boot = config.bootstrap,
877
fetchCSS = config.fetchCSS,
878
process = function(names, skip) {
887
for (i = 0; i < names.length; i++) {
888
if (aliases[names[i]]) {
889
a = [].concat(a, aliases[names[i]]);
897
YArray.each(names, function(name) {
899
// add this module to full list of things to attach
904
// only attach a module once
909
var m = mods[name], req, use;
913
req = m.details.requires;
916
// CSS files don't register themselves, see if it has
918
if (!G_ENV._loaded[VERSION][name]) {
921
used[name] = true; // probably css
925
// make sure requirements are attached
926
if (req && req.length) {
930
// make sure we grab the submodule dependencies too
931
if (use && use.length) {
937
handleLoader = function(fromLoader) {
938
var response = fromLoader || {
944
data = response.data;
949
origMissing = missing;
953
redo = missing.length;
955
if (missing.sort().join() ==
956
origMissing.sort().join()) {
964
Y._use(missing, function() {
965
Y.log('Nested use callback: ' + data, 'info', 'yui');
966
if (Y._attach(data)) {
967
Y._notify(callback, response, data);
972
// Y.log('attaching from loader: ' + data, 'info', 'yui');
973
ret = Y._attach(data);
976
Y._notify(callback, response, args);
980
if (Y._useQueue && Y._useQueue.size() && !Y._loading) {
981
Y._use.apply(Y, Y._useQueue.next());
986
// Y.log(Y.id + ': use called: ' + a + ' :: ' + callback, 'info', 'yui');
988
// YUI().use('*'); // bind everything available
989
if (firstArg === '*') {
990
ret = Y._attach(Y.Object.keys(mods));
997
if (mods['loader'] && !Y.Loader) {
998
Y.log('Loader was found in meta, but it is not attached. Attaching..', 'info', 'yui');
999
Y._attach(['loader']);
1002
// Y.log('before loader requirements: ' + args, 'info', 'yui');
1004
// use loader to expand dependencies and sort the
1005
// requirements if it is available.
1006
if (boot && Y.Loader && args.length) {
1007
loader = getLoader(Y);
1008
loader.require(args);
1009
loader.ignoreRegistered = true;
1010
loader._boot = true;
1011
loader.calculate(null, (fetchCSS) ? null : 'js');
1012
args = loader.sorted;
1013
loader._boot = false;
1016
// process each requirement and any additional requirements
1017
// the module metadata specifies
1020
len = missing.length;
1023
missing = Y.Object.keys(YArray.hash(missing));
1024
len = missing.length;
1025
Y.log('Modules missing: ' + missing + ', ' + missing.length, 'info', 'yui');
1030
if (boot && len && Y.Loader) {
1031
// Y.log('Using loader to fetch missing deps: ' + missing, 'info', 'yui');
1032
Y.log('Using Loader', 'info', 'yui');
1034
loader = getLoader(Y);
1035
loader.onEnd = handleLoader;
1038
loader.ignoreRegistered = false;
1039
loader.require(args);
1040
loader.insert(null, (fetchCSS) ? null : 'js');
1042
} else if (boot && len && Y.Get && !Env.bootstrapped) {
1046
handleBoot = function() {
1048
queue.running = false;
1049
Env.bootstrapped = true;
1050
G_ENV._bootstrapping = false;
1051
if (Y._attach(['loader'])) {
1052
Y._use(args, callback);
1056
if (G_ENV._bootstrapping) {
1057
Y.log('Waiting for loader', 'info', 'yui');
1058
queue.add(handleBoot);
1060
G_ENV._bootstrapping = true;
1061
Y.log('Fetching loader: ' + config.base + config.loaderPath, 'info', 'yui');
1062
Y.Get.script(config.base + config.loaderPath, {
1068
Y.log('Attaching available dependencies: ' + args, 'info', 'yui');
1069
ret = Y._attach(args);
1080
Adds a namespace object onto the YUI global if called statically.
1082
// creates YUI.your.namespace.here as nested objects
1083
YUI.namespace("your.namespace.here");
1085
If called as a method on a YUI <em>instance</em>, it creates the
1086
namespace on the instance.
1088
// creates Y.property.package
1089
Y.namespace("property.package");
1091
Dots in the input string cause `namespace` to create nested objects for
1092
each token. If any part of the requested namespace already exists, the
1093
current object will be left in place. This allows multiple calls to
1094
`namespace` to preserve existing namespaced properties.
1096
If the first token in the namespace string is "YAHOO", the token is
1099
Be careful with namespace tokens. Reserved words may work in some browsers
1100
and not others. For instance, the following will fail in some browsers
1101
because the supported version of JavaScript reserves the word "long":
1103
Y.namespace("really.long.nested.namespace");
1105
<em>Note: If you pass multiple arguments to create multiple namespaces, only
1106
the last one created is returned from this function.</em>
1109
@param {String} namespace* namespaces to create.
1110
@return {Object} A reference to the last namespace object created.
1112
namespace: function() {
1113
var a = arguments, o, i = 0, j, d, arg;
1115
for (; i < a.length; i++) {
1116
o = this; //Reset base object per argument or it will get reused from the last
1118
if (arg.indexOf(PERIOD) > -1) { //Skip this if no "." is present
1119
d = arg.split(PERIOD);
1120
for (j = (d[0] == 'YAHOO') ? 1 : 0; j < d.length; j++) {
1121
o[d[j]] = o[d[j]] || {};
1125
o[arg] = o[arg] || {};
1126
o = o[arg]; //Reset base object to the new object so it's returned
1132
// this is replaced if the log module is included
1135
// this is replaced if the dump module is included
1136
dump: function (o) { return ''+o; },
1139
* Report an error. The reporting mechanism is controlled by
1140
* the `throwFail` configuration attribute. If throwFail is
1141
* not specified, the message is written to the Logger, otherwise
1142
* a JS error is thrown. If an `errorFn` is specified in the config
1143
* it must return `true` to keep the error from being thrown.
1145
* @param msg {String} the error message.
1146
* @param e {Error|String} Optional JS error that was caught, or an error string.
1147
* @param src Optional additional info (passed to `Y.config.errorFn` and `Y.message`)
1148
* and `throwFail` is specified, this error will be re-thrown.
1149
* @return {YUI} this YUI instance.
1151
error: function(msg, e, src) {
1152
//TODO Add check for window.onerror here
1156
if (Y.config.errorFn) {
1157
ret = Y.config.errorFn.apply(Y, arguments);
1160
if (Y.config.throwFail && !ret) {
1161
throw (e || new Error(msg));
1163
Y.message(msg, 'error', ''+src); // don't scrub this one
1170
* Generate an id that is unique among all YUI instances
1172
* @param pre {String} optional guid prefix.
1173
* @return {String} the guid.
1175
guid: function(pre) {
1176
var id = this.Env._guidp + '_' + (++this.Env._uidx);
1177
return (pre) ? (pre + id) : id;
1181
* Returns a `guid` associated with an object. If the object
1182
* does not have one, a new one is created unless `readOnly`
1185
* @param o {Object} The object to stamp.
1186
* @param readOnly {Boolean} if `true`, a valid guid will only
1187
* be returned if the object has one assigned to it.
1188
* @return {String} The object's guid or null.
1190
stamp: function(o, readOnly) {
1196
// IE generates its own unique ID for dom nodes
1197
// The uniqueID property of a document node returns a new ID
1198
if (o.uniqueID && o.nodeType && o.nodeType !== 9) {
1201
uid = (typeof o === 'string') ? o : o._yuid;
1218
* Destroys the YUI instance
1222
destroy: function() {
1227
delete instances[Y.id];
1233
* instanceof check for objects that works around
1234
* memory leak in IE when the item tested is
1236
* @method instanceOf
1237
* @param o {Object} The object to check.
1238
* @param type {Object} The class to check against.
1243
YUI.prototype = proto;
1245
// inheritance utilities are not available yet
1246
for (prop in proto) {
1247
if (proto.hasOwnProperty(prop)) {
1248
YUI[prop] = proto[prop];
1253
Static method on the Global YUI object to apply a config to all YUI instances.
1254
It's main use case is "mashups" where several third party scripts are trying to write to
1255
a global YUI config at the same time. This way they can all call `YUI.applyConfig({})` instead of
1256
overwriting other scripts configs.
1260
@param {Object} o the configuration object.
1266
fullpath: './davglass.js'
1274
fullpath: './foo.js'
1279
YUI().use('davglass', function(Y) {
1280
//Module davglass will be available here..
1284
YUI.applyConfig = function(o) {
1288
//If there is a GlobalConfig, apply it first to set the defaults
1289
if (YUI.GlobalConfig) {
1290
this.prototype.applyConfig.call(this, YUI.GlobalConfig);
1292
//Apply this config to it
1293
this.prototype.applyConfig.call(this, o);
1294
//Reset GlobalConfig to the combined config
1295
YUI.GlobalConfig = this.config;
1298
// set up the environment
1302
// add a window load event at load time so we can capture
1303
// the case where it fires before dynamic loading is
1305
add(window, 'load', handleLoad);
1311
YUI.Env.remove = remove;
1314
// Support the CommonJS method for exporting our single global
1315
if (typeof exports == 'object') {
1323
* The config object contains all of the configuration options for
1324
* the `YUI` instance. This object is supplied by the implementer
1325
* when instantiating a `YUI` instance. Some properties have default
1326
* values if they are not supplied by the implementer. This should
1327
* not be updated directly because some values are cached. Use
1328
* `applyConfig()` to update the config object on a YUI instance that
1329
* has already been configured.
1336
* Allows the YUI seed file to fetch the loader component and library
1337
* metadata to dynamically load additional dependencies.
1339
* @property bootstrap
1345
* Turns on writing Ylog messages to the browser console.
1353
* Log to the browser console if debug is on and the browser has a
1354
* supported console.
1356
* @property useBrowserConsole
1362
* A hash of log sources that should be logged. If specified, only
1363
* log messages from these sources will be logged.
1365
* @property logInclude
1370
* A hash of log sources that should be not be logged. If specified,
1371
* all sources are logged if not on this list.
1373
* @property logExclude
1378
* Set to true if the yui seed file was dynamically loaded in
1379
* order to bootstrap components relying on the window load event
1380
* and the `domready` custom event.
1382
* @property injected
1388
* If `throwFail` is set, `Y.error` will generate or re-throw a JS Error.
1389
* Otherwise the failure is logged.
1391
* @property throwFail
1397
* The window/frame that this instance should operate in.
1401
* @default the window hosting YUI
1405
* The document associated with the 'win' configuration.
1409
* @default the document hosting YUI
1413
* A list of modules that defines the YUI core (overrides the default list).
1417
* @default [ get,features,intl-base,yui-log,yui-later,loader-base, loader-rollup, loader-yui3 ]
1421
* A list of languages in order of preference. This list is matched against
1422
* the list of available languages in modules that the YUI instance uses to
1423
* determine the best possible localization of language sensitive modules.
1424
* Languages are represented using BCP 47 language tags, such as "en-GB" for
1425
* English as used in the United Kingdom, or "zh-Hans-CN" for simplified
1426
* Chinese as used in China. The list can be provided as a comma-separated
1427
* list or as an array.
1430
* @type string|string[]
1434
* The default date format
1435
* @property dateFormat
1437
* @deprecated use configuration in `DataType.Date.format()` instead.
1441
* The default locale
1444
* @deprecated use `config.lang` instead.
1448
* The default interval when polling in milliseconds.
1449
* @property pollInterval
1455
* The number of dynamic nodes to insert by default before
1456
* automatically removing them. This applies to script nodes
1457
* because removing the node will not make the evaluated script
1458
* unavailable. Dynamic CSS is not auto purged, because removing
1459
* a linked style sheet will also remove the style definitions.
1460
* @property purgethreshold
1466
* The default interval when polling in milliseconds.
1467
* @property windowResizeDelay
1473
* Base directory for dynamic loading
1479
* The secure base dir (not implemented)
1480
* For dynamic loading.
1481
* @property secureBase
1486
* The YUI combo service base dir. Ex: `http://yui.yahooapis.com/combo?`
1487
* For dynamic loading.
1488
* @property comboBase
1493
* The root path to prepend to module path for the combo service.
1494
* Ex: 3.0.0b1/build/
1495
* For dynamic loading.
1501
* A filter to apply to result urls. This filter will modify the default
1502
* path for all modules. The default path for the YUI library is the
1503
* minified version of the files (e.g., event-min.js). The filter property
1504
* can be a predefined filter or a custom filter. The valid predefined
1508
* <dd>Selects the debug versions of the library (e.g., event-debug.js).
1509
* This option will automatically include the Logger widget</dd>
1511
* <dd>Selects the non-minified version of the library (e.g., event.js).</dd>
1513
* You can also define a custom filter, which must be an object literal
1514
* containing a search expression and a replace string:
1517
* 'searchExp': "-min\\.js",
1518
* 'replaceStr': "-debug.js"
1521
* For dynamic loading.
1524
* @type string|object
1528
* The `skin` config let's you configure application level skin
1529
* customizations. It contains the following attributes which
1530
* can be specified to override the defaults:
1532
* // The default skin, which is automatically applied if not
1533
* // overriden by a component-specific skin definition.
1534
* // Change this in to apply a different skin globally
1535
* defaultSkin: 'sam',
1537
* // This is combined with the loader base property to get
1538
* // the default root directory for a skin.
1539
* base: 'assets/skins/',
1541
* // Any component-specific overrides can be specified here,
1542
* // making it possible to load different skins for different
1543
* // components. It is possible to load more than one skin
1544
* // for a given component as well.
1546
* slider: ['capsule', 'round']
1549
* For dynamic loading.
1555
* Hash of per-component filter specification. If specified for a given
1556
* component, this overrides the filter config.
1558
* For dynamic loading.
1564
* Use the YUI combo service to reduce the number of http connections
1565
* required to load your dependencies. Turning this off will
1566
* disable combo handling for YUI and all module groups configured
1567
* with a combo service.
1569
* For dynamic loading.
1573
* @default true if 'base' is not supplied, false if it is.
1577
* A list of modules that should never be dynamically loaded
1584
* A list of modules that should always be loaded when required, even if already
1585
* present on the page.
1592
* Node or id for a node that should be used as the insertion point for new
1593
* nodes. For dynamic loading.
1595
* @property insertBefore
1600
* Object literal containing attributes to add to dynamically loaded script
1602
* @property jsAttributes
1607
* Object literal containing attributes to add to dynamically loaded link
1609
* @property cssAttributes
1614
* Number of milliseconds before a timeout occurs when dynamically
1615
* loading nodes. If not set, there is no timeout.
1621
* Callback for the 'CSSComplete' event. When dynamically loading YUI
1622
* components with CSS, this property fires when the CSS is finished
1623
* loading but script loading is still ongoing. This provides an
1624
* opportunity to enhance the presentation of a loading page a little
1625
* bit before the entire loading process is done.
1632
* A hash of module definitions to add to the list of YUI components.
1633
* These components can then be dynamically loaded side by side with
1634
* YUI via the `use()` method. This is a hash, the key is the module
1635
* name, and the value is an object literal specifying the metdata
1636
* for the module. See `Loader.addModule` for the supported module
1637
* metadata fields. Also see groups, which provides a way to
1638
* configure the base and combo spec for a set of modules.
1642
* requires: ['node'],
1643
* fullpath: '/mymod1/mymod1.js'
1646
* requires: ['mymod1'],
1647
* fullpath: '/mymod2/mymod2.js'
1649
* mymod3: '/js/mymod3.js',
1650
* mycssmod: '/css/mycssmod.css'
1659
* Aliases are dynamic groups of modules that can be used as
1664
* davglass: [ 'node', 'yql', 'dd' ],
1665
* mine: [ 'davglass', 'autocomplete']
1667
* }).use('mine', function(Y) {
1668
* //Node, YQL, DD & AutoComplete available here..
1676
* A hash of module group definitions. It for each group you
1677
* can specify a list of modules and the base path and
1678
* combo spec to use when dynamically loading the modules.
1682
* // specify whether or not this group has a combo service
1685
* // The comboSeperator to use with this group's combo handler
1688
* // The maxURLLength for this server
1689
* maxURLLength: 500,
1691
* // the base path for non-combo paths
1692
* base: 'http://yui.yahooapis.com/2.8.0r4/build/',
1694
* // the path to the combo service
1695
* comboBase: 'http://yui.yahooapis.com/combo?',
1697
* // a fragment to prepend to the path attribute when
1698
* // when building combo urls
1699
* root: '2.8.0r4/build/',
1701
* // the module definitions
1704
* path: "yahoo-dom-event/yahoo-dom-event.js"
1707
* path: "animation/animation.js",
1708
* requires: ['yui2_yde']
1719
* The loader 'path' attribute to the loader itself. This is combined
1720
* with the 'base' attribute to dynamically load the loader component
1721
* when boostrapping with the get utility alone.
1723
* @property loaderPath
1725
* @default loader/loader-min.js
1729
* Specifies whether or not YUI().use(...) will attempt to load CSS
1730
* resources at all. Any truthy value will cause CSS dependencies
1731
* to load when fetching script. The special value 'force' will
1732
* cause CSS dependencies to be loaded even if no script is needed.
1734
* @property fetchCSS
1735
* @type boolean|string
1740
* The default gallery version to build gallery module urls
1747
* The default YUI 2 version to build yui2 module urls. This is for
1748
* intrinsic YUI 2 support via the 2in3 project. Also see the '2in3'
1749
* config for pulling different revisions of the wrapped YUI 2
1758
* The 2in3 project is a deployment of the various versions of YUI 2
1759
* deployed as first-class YUI 3 modules. Eventually, the wrapper
1760
* for the modules will change (but the underlying YUI 2 code will
1761
* be the same), and you can select a particular version of
1762
* the wrapper modules via this config.
1770
* Alternative console log function for use in environments without
1771
* a supported native console. The function is executed in the
1772
* YUI instance context.
1779
* A callback to execute when Y.error is called. It receives the
1780
* error message and an javascript error object if Y.error was
1781
* executed because a javascript error was caught. The function
1782
* is executed in the YUI instance context. Returning `true` from this
1783
* function will stop the Error from being thrown.
1791
* A callback to execute when the loader fails to load one or
1792
* more resource. This could be because of a script load
1793
* failure. It can also fail if a javascript module fails
1794
* to register itself, but only when the 'requireRegistration'
1795
* is true. If this function is defined, the use() callback will
1796
* only be called when the loader succeeds, otherwise it always
1797
* executes unless there was a javascript error when attaching
1801
* @property loadErrorFn
1806
* When set to true, the YUI loader will expect that all modules
1807
* it is responsible for loading will be first-class YUI modules
1808
* that register themselves with the YUI global. If this is
1809
* set to true, loader will fail if the module registration fails
1810
* to happen after the script is loaded.
1813
* @property requireRegistration
1819
* Cache serviced use() requests.
1821
* @property cacheUse
1824
* @deprecated no longer used
1828
* Whether or not YUI should use native ES5 functionality when available for
1829
* features like `Y.Array.each()`, `Y.Object()`, etc. When `false`, YUI will
1830
* always use its own fallback implementations instead of relying on ES5
1831
* functionality, even when it's available.
1833
* @method useNativeES5
1838
YUI.add('yui-base', function(Y) {
1843
* @submodule yui-base
1846
* The YUI module contains the components required for building the YUI
1847
* seed file. This includes the script loading mechanism, a simple queue,
1848
* and the core utilities for the library.
1850
* @submodule yui-base
1854
* Provides core language utilites and extensions used throughout YUI.
1860
var L = Y.Lang || (Y.Lang = {}),
1862
STRING_PROTO = String.prototype,
1863
TOSTRING = Object.prototype.toString,
1866
'undefined' : 'undefined',
1867
'number' : 'number',
1868
'boolean' : 'boolean',
1869
'string' : 'string',
1870
'[object Function]': 'function',
1871
'[object RegExp]' : 'regexp',
1872
'[object Array]' : 'array',
1873
'[object Date]' : 'date',
1874
'[object Error]' : 'error'
1877
SUBREGEX = /\{\s*([^|}]+?)\s*(?:\|([^}]*))?\s*\}/g,
1878
TRIMREGEX = /^\s+|\s+$/g,
1879
NATIVE_FN_REGEX = /\{\s*\[(?:native code|function)\]\s*\}/i;
1881
// -- Protected Methods --------------------------------------------------------
1884
Returns `true` if the given function appears to be implemented in native code,
1885
`false` otherwise. Will always return `false` -- even in ES5-capable browsers --
1886
if the `useNativeES5` YUI config option is set to `false`.
1888
This isn't guaranteed to be 100% accurate and won't work for anything other than
1889
functions, but it can be useful for determining whether a function like
1890
`Array.prototype.forEach` is native or a JS shim provided by another library.
1892
There's a great article by @kangax discussing certain flaws with this technique:
1893
<http://perfectionkills.com/detecting-built-in-host-methods/>
1895
While his points are valid, it's still possible to benefit from this function
1896
as long as it's used carefully and sparingly, and in such a way that false
1897
negatives have minimal consequences. It's used internally to avoid using
1898
potentially broken non-native ES5 shims that have been added to the page by
1902
@param {Function} fn Function to test.
1903
@return {Boolean} `true` if _fn_ appears to be native, `false` otherwise.
1908
L._isNative = function (fn) {
1909
return !!(Y.config.useNativeES5 && fn && NATIVE_FN_REGEX.test(fn));
1912
// -- Public Methods -----------------------------------------------------------
1915
* Determines whether or not the provided item is an array.
1917
* Returns `false` for array-like collections such as the function `arguments`
1918
* collection or `HTMLElement` collections. Use `Y.Array.test()` if you want to
1919
* test for an array-like collection.
1922
* @param o The object to test.
1923
* @return {boolean} true if o is an array.
1926
L.isArray = L._isNative(Array.isArray) ? Array.isArray : function (o) {
1927
return L.type(o) === 'array';
1931
* Determines whether or not the provided item is a boolean.
1934
* @param o The object to test.
1935
* @return {boolean} true if o is a boolean.
1937
L.isBoolean = function(o) {
1938
return typeof o === 'boolean';
1942
* Determines whether or not the supplied item is a date instance.
1945
* @param o The object to test.
1946
* @return {boolean} true if o is a date.
1948
L.isDate = function(o) {
1949
return L.type(o) === 'date' && o.toString() !== 'Invalid Date' && !isNaN(o);
1954
* Determines whether or not the provided item is a function.
1955
* Note: Internet Explorer thinks certain functions are objects:
1959
* var obj = document.createElement("object");
1960
* Y.Lang.isFunction(obj.getAttribute) // reports false in IE
1962
* var input = document.createElement("input"); // append to body
1963
* Y.Lang.isFunction(input.focus) // reports false in IE
1967
* You will have to implement additional tests if these functions
1971
* @method isFunction
1973
* @param o The object to test.
1974
* @return {boolean} true if o is a function.
1976
L.isFunction = function(o) {
1977
return L.type(o) === 'function';
1981
* Determines whether or not the provided item is null.
1984
* @param o The object to test.
1985
* @return {boolean} true if o is null.
1987
L.isNull = function(o) {
1992
* Determines whether or not the provided item is a legal number.
1995
* @param o The object to test.
1996
* @return {boolean} true if o is a number.
1998
L.isNumber = function(o) {
1999
return typeof o === 'number' && isFinite(o);
2003
* Determines whether or not the provided item is of type object
2004
* or function. Note that arrays are also objects, so
2005
* <code>Y.Lang.isObject([]) === true</code>.
2008
* @param o The object to test.
2009
* @param failfn {boolean} fail if the input is a function.
2010
* @return {boolean} true if o is an object.
2011
* @see isPlainObject
2013
L.isObject = function(o, failfn) {
2015
return (o && (t === 'object' ||
2016
(!failfn && (t === 'function' || L.isFunction(o))))) || false;
2020
* Determines whether or not the provided item is a string.
2023
* @param o The object to test.
2024
* @return {boolean} true if o is a string.
2026
L.isString = function(o) {
2027
return typeof o === 'string';
2031
* Determines whether or not the provided item is undefined.
2032
* @method isUndefined
2034
* @param o The object to test.
2035
* @return {boolean} true if o is undefined.
2037
L.isUndefined = function(o) {
2038
return typeof o === 'undefined';
2042
* A convenience method for detecting a legitimate non-null value.
2043
* Returns false for null/undefined/NaN, true for other values,
2044
* including 0/false/''
2047
* @param o The item to test.
2048
* @return {boolean} true if it is not null/undefined/NaN || false.
2050
L.isValue = function(o) {
2057
case 'null': // fallthru
2067
* Returns the current time in milliseconds.
2070
* @return {Number} Current time in milliseconds.
2074
L.now = Date.now || function () {
2075
return new Date().getTime();
2079
* Lightweight version of <code>Y.substitute</code>. Uses the same template
2080
* structure as <code>Y.substitute</code>, but doesn't support recursion,
2081
* auto-object coersion, or formats.
2083
* @param {string} s String to be modified.
2084
* @param {object} o Object containing replacement values.
2085
* @return {string} the substitute result.
2089
L.sub = function(s, o) {
2090
return s.replace ? s.replace(SUBREGEX, function (match, key) {
2091
return L.isUndefined(o[key]) ? match : o[key];
2096
* Returns a string without any leading or trailing whitespace. If
2097
* the input is not a string, the input will be returned untouched.
2100
* @param s {string} the string to trim.
2101
* @return {string} the trimmed string.
2103
L.trim = STRING_PROTO.trim ? function(s) {
2104
return s && s.trim ? s.trim() : s;
2107
return s.replace(TRIMREGEX, '');
2114
* Returns a string without any leading whitespace.
2117
* @param s {string} the string to trim.
2118
* @return {string} the trimmed string.
2120
L.trimLeft = STRING_PROTO.trimLeft ? function (s) {
2121
return s.trimLeft();
2123
return s.replace(/^\s+/, '');
2127
* Returns a string without any trailing whitespace.
2130
* @param s {string} the string to trim.
2131
* @return {string} the trimmed string.
2133
L.trimRight = STRING_PROTO.trimRight ? function (s) {
2134
return s.trimRight();
2136
return s.replace(/\s+$/, '');
2140
Returns one of the following strings, representing the type of the item passed
2157
* `typeof HTMLElementCollection` returns function in Safari, but
2158
`Y.Lang.type()` reports "object", which could be a good thing --
2159
but it actually caused the logic in <code>Y.Lang.isObject</code> to fail.
2162
@param o the item to test.
2163
@return {string} the detected type.
2166
L.type = function(o) {
2167
return TYPES[typeof o] || TYPES[TOSTRING.call(o)] || (o ? 'object' : 'null');
2175
Native = Array.prototype,
2177
hasOwn = Object.prototype.hasOwnProperty;
2180
Provides utility methods for working with arrays. Additional array helpers can
2181
be found in the `collection` and `array-extras` modules.
2183
`Y.Array(thing)` returns a native array created from _thing_. Depending on
2184
_thing_'s type, one of the following will happen:
2186
* Arrays are returned unmodified unless a non-zero _startIndex_ is
2188
* Array-like collections (see `Array.test()`) are converted to arrays.
2189
* For everything else, a new array is created with _thing_ as the sole
2192
Note: elements that are also collections, such as `<form>` and `<select>`
2193
elements, are not automatically converted to arrays. To force a conversion,
2194
pass `true` as the value of the _force_ parameter.
2198
@param {Any} thing The thing to arrayify.
2199
@param {Number} [startIndex=0] If non-zero and _thing_ is an array or array-like
2200
collection, a subset of items starting at the specified index will be
2202
@param {Boolean} [force=false] If `true`, _thing_ will be treated as an
2203
array-like collection no matter what.
2204
@return {Array} A native array created from _thing_, according to the rules
2207
function YArray(thing, startIndex, force) {
2210
startIndex || (startIndex = 0);
2212
if (force || YArray.test(thing)) {
2213
// IE throws when trying to slice HTMLElement collections.
2215
return Native.slice.call(thing, startIndex);
2219
for (len = thing.length; startIndex < len; ++startIndex) {
2220
result.push(thing[startIndex]);
2233
Dedupes an array of strings, returning an array that's guaranteed to contain
2234
only one copy of a given string.
2236
This method differs from `Array.unique()` in that it's optimized for use only
2237
with strings, whereas `unique` may be used with other types (but is slower).
2238
Using `dedupe()` with non-string values may result in unexpected behavior.
2241
@param {String[]} array Array of strings to dedupe.
2242
@return {Array} Deduped copy of _array_.
2246
YArray.dedupe = function (array) {
2251
for (i = 0, len = array.length; i < len; ++i) {
2254
if (!hasOwn.call(hash, item)) {
2264
Executes the supplied function on each item in the array. This method wraps
2265
the native ES5 `Array.forEach()` method if available.
2268
@param {Array} array Array to iterate.
2269
@param {Function} fn Function to execute on each item in the array. The function
2270
will receive the following arguments:
2271
@param {Any} fn.item Current array item.
2272
@param {Number} fn.index Current array index.
2273
@param {Array} fn.array Array being iterated.
2274
@param {Object} [thisObj] `this` object to use when calling _fn_.
2275
@return {YUI} The YUI instance.
2278
YArray.each = YArray.forEach = Lang._isNative(Native.forEach) ? function (array, fn, thisObj) {
2279
Native.forEach.call(array || [], fn, thisObj || Y);
2281
} : function (array, fn, thisObj) {
2282
for (var i = 0, len = (array && array.length) || 0; i < len; ++i) {
2284
fn.call(thisObj || Y, array[i], i, array);
2299
Returns an object using the first array as keys and the second as values. If
2300
the second array is not provided, or if it doesn't contain the same number of
2301
values as the first array, then `true` will be used in place of the missing
2306
Y.Array.hash(['a', 'b', 'c'], ['foo', 'bar']);
2307
// => {a: 'foo', b: 'bar', c: true}
2310
@param {String[]} keys Array of strings to use as keys.
2311
@param {Array} [values] Array to use as values.
2312
@return {Object} Hash using the first array as keys and the second as values.
2315
YArray.hash = function (keys, values) {
2317
vlen = (values && values.length) || 0,
2320
for (i = 0, len = keys.length; i < len; ++i) {
2322
hash[keys[i]] = vlen > i && i in values ? values[i] : true;
2330
Returns the index of the first item in the array that's equal (using a strict
2331
equality check) to the specified _value_, or `-1` if the value isn't found.
2333
This method wraps the native ES5 `Array.indexOf()` method if available.
2336
@param {Array} array Array to search.
2337
@param {Any} value Value to search for.
2338
@param {Number} [from=0] The index at which to begin the search.
2339
@return {Number} Index of the item strictly equal to _value_, or `-1` if not
2343
YArray.indexOf = Lang._isNative(Native.indexOf) ? function (array, value, from) {
2344
return Native.indexOf.call(array, value, from);
2345
} : function (array, value, from) {
2346
// http://es5.github.com/#x15.4.4.14
2347
var len = array.length;
2350
from = (from > 0 || -1) * Math.floor(Math.abs(from));
2360
for (; from < len; ++from) {
2361
if (from in array && array[from] === value) {
2370
Numeric sort convenience function.
2372
The native `Array.prototype.sort()` function converts values to strings and
2373
sorts them in lexicographic order, which is unsuitable for sorting numeric
2374
values. Provide `Array.numericSort` as a custom sort function when you want
2375
to sort values in numeric order.
2379
[42, 23, 8, 16, 4, 15].sort(Y.Array.numericSort);
2380
// => [4, 8, 15, 16, 23, 42]
2383
@param {Number} a First value to compare.
2384
@param {Number} b Second value to compare.
2385
@return {Number} Difference between _a_ and _b_.
2388
YArray.numericSort = function (a, b) {
2393
Executes the supplied function on each item in the array. Returning a truthy
2394
value from the function will stop the processing of remaining items.
2397
@param {Array} array Array to iterate over.
2398
@param {Function} fn Function to execute on each item. The function will receive
2399
the following arguments:
2400
@param {Any} fn.value Current array item.
2401
@param {Number} fn.index Current array index.
2402
@param {Array} fn.array Array being iterated over.
2403
@param {Object} [thisObj] `this` object to use when calling _fn_.
2404
@return {Boolean} `true` if the function returns a truthy value on any of the
2405
items in the array; `false` otherwise.
2408
YArray.some = Lang._isNative(Native.some) ? function (array, fn, thisObj) {
2409
return Native.some.call(array, fn, thisObj);
2410
} : function (array, fn, thisObj) {
2411
for (var i = 0, len = array.length; i < len; ++i) {
2412
if (i in array && fn.call(thisObj, array[i], i, array)) {
2421
Evaluates _obj_ to determine if it's an array, an array-like collection, or
2422
something else. This is useful when working with the function `arguments`
2423
collection and `HTMLElement` collections.
2425
Note: This implementation doesn't consider elements that are also
2426
collections, such as `<form>` and `<select>`, to be array-like.
2429
@param {Object} obj Object to test.
2430
@return {Number} A number indicating the results of the test:
2432
* 0: Neither an array nor an array-like collection.
2434
* 2: Array-like collection.
2438
YArray.test = function (obj) {
2441
if (Lang.isArray(obj)) {
2443
} else if (Lang.isObject(obj)) {
2445
// indexed, but no tagName (element) or alert (window),
2446
// or functions without apply/call (Safari
2447
// HTMLElementCollection bug).
2448
if ('length' in obj && !obj.tagName && !obj.alert && !obj.apply) {
2457
* The YUI module contains the components required for building the YUI
2458
* seed file. This includes the script loading mechanism, a simple queue,
2459
* and the core utilities for the library.
2461
* @submodule yui-base
2465
* A simple FIFO queue. Items are added to the Queue with add(1..n items) and
2466
* removed using next().
2470
* @param {MIXED} item* 0..n items to seed the queue.
2474
this.add.apply(this, arguments);
2479
* Initialize the queue
2486
* The collection of enqueued items
2496
* Get the next item in the queue. FIFO support
2499
* @return {MIXED} the next item in the queue.
2502
return this._q.shift();
2506
* Get the last in the queue. LIFO support.
2509
* @return {MIXED} the last item in the queue.
2512
return this._q.pop();
2516
* Add 0..n items to the end of the queue.
2519
* @param {MIXED} item* 0..n items.
2520
* @return {object} this queue.
2523
this._q.push.apply(this._q, arguments);
2529
* Returns the current number of queued items.
2532
* @return {Number} The size.
2535
return this._q.length;
2541
YUI.Env._loaderQueue = YUI.Env._loaderQueue || new Queue();
2544
The YUI module contains the components required for building the YUI seed file.
2545
This includes the script loading mechanism, a simple queue, and the core
2546
utilities for the library.
2552
var CACHED_DELIMITER = '__',
2554
hasOwn = Object.prototype.hasOwnProperty,
2555
isObject = Y.Lang.isObject;
2558
Returns a wrapper for a function which caches the return value of that function,
2559
keyed off of the combined string representation of the argument values provided
2560
when the wrapper is called.
2562
Calling this function again with the same arguments will return the cached value
2563
rather than executing the wrapped function.
2565
Note that since the cache is keyed off of the string representation of arguments
2566
passed to the wrapper function, arguments that aren't strings and don't provide
2567
a meaningful `toString()` method may result in unexpected caching behavior. For
2568
example, the objects `{}` and `{foo: 'bar'}` would both be converted to the
2569
string `[object Object]` when used as a cache key.
2572
@param {Function} source The function to memoize.
2573
@param {Object} [cache={}] Object in which to store cached values. You may seed
2574
this object with pre-existing cached values if desired.
2575
@param {any} [refetch] If supplied, this value is compared with the cached value
2576
using a `==` comparison. If the values are equal, the wrapped function is
2577
executed again even though a cached value exists.
2578
@return {Function} Wrapped function.
2581
Y.cached = function (source, cache, refetch) {
2582
cache || (cache = {});
2584
return function (arg) {
2585
var key = arguments.length > 1 ?
2586
Array.prototype.join.call(arguments, CACHED_DELIMITER) :
2589
if (!(key in cache) || (refetch && cache[key] == refetch)) {
2590
cache[key] = source.apply(source, arguments);
2598
Returns the `location` object from the window/frame in which this YUI instance
2599
operates, or `undefined` when executing in a non-browser environment
2602
It is _not_ recommended to hold references to the `window.location` object
2603
outside of the scope of a function in which its properties are being accessed or
2604
its methods are being called. This is because of a nasty bug/issue that exists
2605
in both Safari and MobileSafari browsers:
2606
[WebKit Bug 34679](https://bugs.webkit.org/show_bug.cgi?id=34679).
2609
@return {location} The `location` object from the window/frame in which this YUI
2613
Y.getLocation = function () {
2614
// It is safer to look this up every time because yui-base is attached to a
2615
// YUI instance before a user's config is applied; i.e. `Y.config.win` does
2616
// not point the correct window object when this file is loaded.
2617
var win = Y.config.win;
2619
// It is not safe to hold a reference to the `location` object outside the
2620
// scope in which it is being used. The WebKit engine used in Safari and
2621
// MobileSafari will "disconnect" the `location` object from the `window`
2622
// when a page is restored from back/forward history cache.
2623
return win && win.location;
2627
Returns a new object containing all of the properties of all the supplied
2628
objects. The properties from later objects will overwrite those in earlier
2631
Passing in a single object will create a shallow copy of it. For a deep copy,
2635
@param {Object} objects* One or more objects to merge.
2636
@return {Object} A new merged object.
2638
Y.merge = function () {
2639
var args = arguments,
2644
for (; i < len; ++i) {
2645
Y.mix(result, args[i], true);
2652
Mixes _supplier_'s properties into _receiver_.
2654
Properties on _receiver_ or _receiver_'s prototype will not be overwritten or
2655
shadowed unless the _overwrite_ parameter is `true`, and will not be merged
2656
unless the _merge_ parameter is `true`.
2658
In the default mode (0), only properties the supplier owns are copied (prototype
2659
properties are not copied). The following copying modes are available:
2661
* `0`: _Default_. Object to object.
2662
* `1`: Prototype to prototype.
2663
* `2`: Prototype to prototype and object to object.
2664
* `3`: Prototype to object.
2665
* `4`: Object to prototype.
2668
@param {Function|Object} receiver The object or function to receive the mixed
2670
@param {Function|Object} supplier The object or function supplying the
2671
properties to be mixed.
2672
@param {Boolean} [overwrite=false] If `true`, properties that already exist
2673
on the receiver will be overwritten with properties from the supplier.
2674
@param {String[]} [whitelist] An array of property names to copy. If
2675
specified, only the whitelisted properties will be copied, and all others
2677
@param {Number} [mode=0] Mix mode to use. See above for available modes.
2678
@param {Boolean} [merge=false] If `true`, objects and arrays that already
2679
exist on the receiver will have the corresponding object/array from the
2680
supplier merged into them, rather than being skipped or overwritten. When
2681
both _overwrite_ and _merge_ are `true`, _merge_ takes precedence.
2682
@return {Function|Object|YUI} The receiver, or the YUI instance if the
2683
specified receiver is falsy.
2685
Y.mix = function(receiver, supplier, overwrite, whitelist, mode, merge) {
2686
var alwaysOverwrite, exists, from, i, key, len, to;
2688
// If no supplier is given, we return the receiver. If no receiver is given,
2689
// we return Y. Returning Y doesn't make much sense to me, but it's
2690
// grandfathered in for backcompat reasons.
2691
if (!receiver || !supplier) {
2692
return receiver || Y;
2696
// In mode 2 (prototype to prototype and object to object), we recurse
2697
// once to do the proto to proto mix. The object to object mix will be
2698
// handled later on.
2700
Y.mix(receiver.prototype, supplier.prototype, overwrite,
2701
whitelist, 0, merge);
2704
// Depending on which mode is specified, we may be copying from or to
2705
// the prototypes of the supplier and receiver.
2706
from = mode === 1 || mode === 3 ? supplier.prototype : supplier;
2707
to = mode === 1 || mode === 4 ? receiver.prototype : receiver;
2709
// If either the supplier or receiver doesn't actually have a
2710
// prototype property, then we could end up with an undefined `from`
2711
// or `to`. If that happens, we abort and return the receiver.
2720
// If `overwrite` is truthy and `merge` is falsy, then we can skip a
2721
// property existence check on each iteration and save some time.
2722
alwaysOverwrite = overwrite && !merge;
2725
for (i = 0, len = whitelist.length; i < len; ++i) {
2728
// We call `Object.prototype.hasOwnProperty` instead of calling
2729
// `hasOwnProperty` on the object itself, since the object's
2730
// `hasOwnProperty` method may have been overridden or removed.
2731
// Also, some native objects don't implement a `hasOwnProperty`
2733
if (!hasOwn.call(from, key)) {
2737
// The `key in to` check here is (sadly) intentional for backwards
2738
// compatibility reasons. It prevents undesired shadowing of
2739
// prototype members on `to`.
2740
exists = alwaysOverwrite ? false : key in to;
2742
if (merge && exists && isObject(to[key], true)
2743
&& isObject(from[key], true)) {
2744
// If we're in merge mode, and the key is present on both
2745
// objects, and the value on both objects is either an object or
2746
// an array (but not a function), then we recurse to merge the
2747
// `from` value into the `to` value instead of overwriting it.
2749
// Note: It's intentional that the whitelist isn't passed to the
2750
// recursive call here. This is legacy behavior that lots of
2751
// code still depends on.
2752
Y.mix(to[key], from[key], overwrite, null, 0, merge);
2753
} else if (overwrite || !exists) {
2754
// We're not in merge mode, so we'll only copy the `from` value
2755
// to the `to` value if we're in overwrite mode or if the
2756
// current key doesn't exist on the `to` object.
2757
to[key] = from[key];
2762
// The code duplication here is for runtime performance reasons.
2763
// Combining whitelist and non-whitelist operations into a single
2764
// loop or breaking the shared logic out into a function both result
2765
// in worse performance, and Y.mix is critical enough that the byte
2766
// tradeoff is worth it.
2767
if (!hasOwn.call(from, key)) {
2771
// The `key in to` check here is (sadly) intentional for backwards
2772
// compatibility reasons. It prevents undesired shadowing of
2773
// prototype members on `to`.
2774
exists = alwaysOverwrite ? false : key in to;
2776
if (merge && exists && isObject(to[key], true)
2777
&& isObject(from[key], true)) {
2778
Y.mix(to[key], from[key], overwrite, null, 0, merge);
2779
} else if (overwrite || !exists) {
2780
to[key] = from[key];
2784
// If this is an IE browser with the JScript enumeration bug, force
2785
// enumeration of the buggy properties by making a recursive call with
2786
// the buggy properties as the whitelist.
2787
if (Y.Object._hasEnumBug) {
2788
Y.mix(to, from, overwrite, Y.Object._forceEnum, mode, merge);
2795
* The YUI module contains the components required for building the YUI
2796
* seed file. This includes the script loading mechanism, a simple queue,
2797
* and the core utilities for the library.
2799
* @submodule yui-base
2803
* Adds utilities to the YUI instance for working with objects.
2809
hasOwn = Object.prototype.hasOwnProperty,
2811
UNDEFINED, // <-- Note the comma. We're still declaring vars.
2814
* Returns a new object that uses _obj_ as its prototype. This method wraps the
2815
* native ES5 `Object.create()` method if available, but doesn't currently
2816
* pass through `Object.create()`'s second argument (properties) in order to
2817
* ensure compatibility with older browsers.
2820
* @param {Object} obj Prototype object.
2821
* @return {Object} New object using _obj_ as its prototype.
2824
O = Y.Object = Lang._isNative(Object.create) ? function (obj) {
2825
// We currently wrap the native Object.create instead of simply aliasing it
2826
// to ensure consistency with our fallback shim, which currently doesn't
2827
// support Object.create()'s second argument (properties). Once we have a
2828
// safe fallback for the properties arg, we can stop wrapping
2830
return Object.create(obj);
2832
// Reusable constructor function for the Object.create() shim.
2836
return function (obj) {
2843
* Property names that IE doesn't enumerate in for..in loops, even when they
2844
* should be enumerable. When `_hasEnumBug` is `true`, it's necessary to
2845
* manually enumerate these properties.
2847
* @property _forceEnum
2852
forceEnum = O._forceEnum = [
2855
'propertyIsEnumerable',
2862
* `true` if this browser has the JScript enumeration bug that prevents
2863
* enumeration of the properties named in the `_forceEnum` array, `false`
2867
* - <https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug>
2868
* - <http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation>
2870
* @property _hasEnumBug
2875
hasEnumBug = O._hasEnumBug = !{valueOf: 0}.propertyIsEnumerable('valueOf'),
2878
* `true` if this browser incorrectly considers the `prototype` property of
2879
* functions to be enumerable. Currently known to affect Opera 11.50.
2881
* @property _hasProtoEnumBug
2886
hasProtoEnumBug = O._hasProtoEnumBug = (function () {}).propertyIsEnumerable('prototype'),
2889
* Returns `true` if _key_ exists on _obj_, `false` if _key_ doesn't exist or
2890
* exists only on _obj_'s prototype. This is essentially a safer version of
2891
* `obj.hasOwnProperty()`.
2894
* @param {Object} obj Object to test.
2895
* @param {String} key Property name to look for.
2896
* @return {Boolean} `true` if _key_ exists on _obj_, `false` otherwise.
2899
owns = O.owns = function (obj, key) {
2900
return !!obj && hasOwn.call(obj, key);
2901
}; // <-- End of var declarations.
2904
* Alias for `owns()`.
2907
* @param {Object} obj Object to test.
2908
* @param {String} key Property name to look for.
2909
* @return {Boolean} `true` if _key_ exists on _obj_, `false` otherwise.
2915
* Returns an array containing the object's enumerable keys. Does not include
2916
* prototype keys or non-enumerable keys.
2918
* Note that keys are returned in enumeration order (that is, in the same order
2919
* that they would be enumerated by a `for-in` loop), which may not be the same
2920
* as the order in which they were defined.
2922
* This method is an alias for the native ES5 `Object.keys()` method if
2927
* Y.Object.keys({a: 'foo', b: 'bar', c: 'baz'});
2928
* // => ['a', 'b', 'c']
2931
* @param {Object} obj An object.
2932
* @return {String[]} Array of keys.
2935
O.keys = Lang._isNative(Object.keys) ? Object.keys : function (obj) {
2936
if (!Lang.isObject(obj)) {
2937
throw new TypeError('Object.keys called on a non-object');
2943
if (hasProtoEnumBug && typeof obj === 'function') {
2945
if (owns(obj, key) && key !== 'prototype') {
2951
if (owns(obj, key)) {
2958
for (i = 0, len = forceEnum.length; i < len; ++i) {
2961
if (owns(obj, key)) {
2971
* Returns an array containing the values of the object's enumerable keys.
2973
* Note that values are returned in enumeration order (that is, in the same
2974
* order that they would be enumerated by a `for-in` loop), which may not be the
2975
* same as the order in which they were defined.
2979
* Y.Object.values({a: 'foo', b: 'bar', c: 'baz'});
2980
* // => ['foo', 'bar', 'baz']
2983
* @param {Object} obj An object.
2984
* @return {Array} Array of values.
2987
O.values = function (obj) {
2988
var keys = O.keys(obj),
2993
for (; i < len; ++i) {
2994
values.push(obj[keys[i]]);
3001
* Returns the number of enumerable keys owned by an object.
3004
* @param {Object} obj An object.
3005
* @return {Number} The object's size.
3008
O.size = function (obj) {
3010
return O.keys(obj).length;
3012
return 0; // Legacy behavior for non-objects.
3017
* Returns `true` if the object owns an enumerable property with the specified
3021
* @param {Object} obj An object.
3022
* @param {any} value The value to search for.
3023
* @return {Boolean} `true` if _obj_ contains _value_, `false` otherwise.
3026
O.hasValue = function (obj, value) {
3027
return Y.Array.indexOf(O.values(obj), value) > -1;
3031
* Executes a function on each enumerable property in _obj_. The function
3032
* receives the value, the key, and the object itself as parameters (in that
3035
* By default, only properties owned by _obj_ are enumerated. To include
3036
* prototype properties, set the _proto_ parameter to `true`.
3039
* @param {Object} obj Object to enumerate.
3040
* @param {Function} fn Function to execute on each enumerable property.
3041
* @param {mixed} fn.value Value of the current property.
3042
* @param {String} fn.key Key of the current property.
3043
* @param {Object} fn.obj Object being enumerated.
3044
* @param {Object} [thisObj] `this` object to use when calling _fn_.
3045
* @param {Boolean} [proto=false] Include prototype properties.
3046
* @return {YUI} the YUI instance.
3050
O.each = function (obj, fn, thisObj, proto) {
3054
if (proto || owns(obj, key)) {
3055
fn.call(thisObj || Y, obj[key], key, obj);
3063
* Executes a function on each enumerable property in _obj_, but halts if the
3064
* function returns a truthy value. The function receives the value, the key,
3065
* and the object itself as paramters (in that order).
3067
* By default, only properties owned by _obj_ are enumerated. To include
3068
* prototype properties, set the _proto_ parameter to `true`.
3071
* @param {Object} obj Object to enumerate.
3072
* @param {Function} fn Function to execute on each enumerable property.
3073
* @param {mixed} fn.value Value of the current property.
3074
* @param {String} fn.key Key of the current property.
3075
* @param {Object} fn.obj Object being enumerated.
3076
* @param {Object} [thisObj] `this` object to use when calling _fn_.
3077
* @param {Boolean} [proto=false] Include prototype properties.
3078
* @return {Boolean} `true` if any execution of _fn_ returns a truthy value,
3079
* `false` otherwise.
3082
O.some = function (obj, fn, thisObj, proto) {
3086
if (proto || owns(obj, key)) {
3087
if (fn.call(thisObj || Y, obj[key], key, obj)) {
3097
* Retrieves the sub value at the provided path,
3098
* from the value object provided.
3102
* @param o The object from which to extract the property value.
3103
* @param path {Array} A path array, specifying the object traversal path
3104
* from which to obtain the sub value.
3105
* @return {Any} The value stored in the path, undefined if not found,
3106
* undefined if the source is not an object. Returns the source object
3107
* if an empty path is provided.
3109
O.getValue = function(o, path) {
3110
if (!Lang.isObject(o)) {
3118
for (i = 0; o !== UNDEFINED && i < l; i++) {
3126
* Sets the sub-attribute value at the provided path on the
3127
* value object. Returns the modified value object, or
3128
* undefined if the path is invalid.
3132
* @param o The object on which to set the sub value.
3133
* @param path {Array} A path array, specifying the object traversal path
3134
* at which to set the sub value.
3135
* @param val {Any} The new value for the sub-attribute.
3136
* @return {Object} The modified object, with the new sub value set, or
3137
* undefined, if the path was invalid.
3139
O.setValue = function(o, path, val) {
3142
leafIdx = p.length - 1,
3146
for (i = 0; ref !== UNDEFINED && i < leafIdx; i++) {
3150
if (ref !== UNDEFINED) {
3161
* Returns `true` if the object has no enumerable properties of its own.
3164
* @param {Object} obj An object.
3165
* @return {Boolean} `true` if the object is empty.
3169
O.isEmpty = function (obj) {
3170
return !O.keys(Object(obj)).length;
3173
* The YUI module contains the components required for building the YUI seed
3174
* file. This includes the script loading mechanism, a simple queue, and the
3175
* core utilities for the library.
3177
* @submodule yui-base
3181
* YUI user agent detection.
3182
* Do not fork for a browser if it can be avoided. Use feature detection when
3183
* you can. Use the user agent as a last resort. For all fields listed
3184
* as @type float, UA stores a version number for the browser engine,
3185
* 0 otherwise. This value may or may not map to the version number of
3186
* the browser using the engine. The value is presented as a float so
3187
* that it can easily be used for boolean evaluation as well as for
3188
* looking for a particular range of versions. Because of this,
3189
* some of the granularity of the version info may be lost. The fields that
3190
* are @type string default to null. The API docs list the values that
3191
* these fields can have.
3197
* Static method on `YUI.Env` for parsing a UA string. Called at instantiation
3198
* to populate `Y.UA`.
3202
* @param {String} [subUA=navigator.userAgent] UA string to parse
3203
* @return {Object} The Y.UA object
3205
YUI.Env.parseUA = function(subUA) {
3207
var numberify = function(s) {
3209
return parseFloat(s.replace(/\./g, function() {
3210
return (c++ == 1) ? '' : '.';
3216
nav = win && win.navigator,
3221
* Internet Explorer version number or 0. Example: 6
3229
* Opera version number or 0. Example: 9.2
3237
* Gecko engine revision number. Will evaluate to 1 if Gecko
3238
* is detected but the revision could not be found. Other browsers
3239
* will be 0. Example: 1.8
3241
* Firefox 1.0.0.4: 1.7.8 <-- Reports 1.7
3242
* Firefox 1.5.0.9: 1.8.0.9 <-- 1.8
3243
* Firefox 2.0.0.3: 1.8.1.3 <-- 1.81
3244
* Firefox 3.0 <-- 1.9
3245
* Firefox 3.5 <-- 1.91
3254
* AppleWebKit version. KHTML browsers that are not WebKit browsers
3255
* will evaluate to 1, other browsers 0. Example: 418.9
3257
* Safari 1.3.2 (312.6): 312.8.1 <-- Reports 312.8 -- currently the
3258
* latest available for Mac OSX 10.3.
3259
* Safari 2.0.2: 416 <-- hasOwnProperty introduced
3260
* Safari 2.0.4: 418 <-- preventDefault fixed
3261
* Safari 2.0.4 (419.3): 418.9.1 <-- One version of Safari may run
3262
* different versions of webkit
3263
* Safari 2.0.4 (419.3): 419 <-- Tiger installations that have been
3264
* updated, but not updated
3265
* to the latest patch.
3266
* Webkit 212 nightly: 522+ <-- Safari 3.0 precursor (with native
3267
* SVG and many major issues fixed).
3268
* Safari 3.0.4 (523.12) 523.12 <-- First Tiger release - automatic
3269
* update from 2.x via the 10.4.11 OS patch.
3270
* Webkit nightly 1/2008:525+ <-- Supports DOMContentLoaded event.
3271
* yahoo.com user agent hack removed.
3273
* http://en.wikipedia.org/wiki/Safari_version_history
3281
* Safari will be detected as webkit, but this property will also
3282
* be populated with the Safari version number
3290
* Chrome will be detected as webkit, but this property will also
3291
* be populated with the Chrome version number
3299
* The mobile property will be set to a string containing any relevant
3300
* user agent information when a modern mobile browser is detected.
3301
* Currently limited to Safari on the iPhone/iPod Touch, Nokia N-series
3302
* devices with the WebKit-based browser, and Opera Mini.
3311
* Adobe AIR version number or 0. Only populated if webkit is detected.
3318
* Detects Apple iPad's OS version
3325
* Detects Apple iPhone's OS version
3332
* Detects Apples iPod's OS version
3339
* General truthy check for iPad, iPhone or iPod
3347
* Detects Googles Android OS version
3354
* Detects Kindle Silk
3361
* Detects Kindle Silk Acceleration
3368
* Detects Palms WebOS version
3376
* Google Caja version number or 0.
3380
caja: nav && nav.cajaVersion,
3383
* Set to true if the page appears to be in SSL
3391
* The operating system. Currently only detecting windows or macintosh
3400
* The Nodejs Version
3409
ua = subUA || nav && nav.userAgent,
3411
loc = win && win.location,
3413
href = loc && loc.href,
3418
* The User Agent string that was parsed
3419
* @property userAgent
3426
o.secure = href && (href.toLowerCase().indexOf('https') === 0);
3430
if ((/windows|win32/i).test(ua)) {
3432
} else if ((/macintosh|mac_powerpc/i).test(ua)) {
3434
} else if ((/android/i).test(ua)) {
3436
} else if ((/symbos/i).test(ua)) {
3438
} else if ((/linux/i).test(ua)) {
3440
} else if ((/rhino/i).test(ua)) {
3444
// Modern KHTML browsers should qualify as Safari X-Grade
3445
if ((/KHTML/).test(ua)) {
3448
if ((/IEMobile|XBLWP7/).test(ua)) {
3449
o.mobile = 'windows';
3451
if ((/Fennec/).test(ua)) {
3454
// Modern WebKit browsers are at least X-Grade
3455
m = ua.match(/AppleWebKit\/([^\s]*)/);
3457
o.webkit = numberify(m[1]);
3458
o.safari = o.webkit;
3460
// Mobile browser check
3461
if (/ Mobile\//.test(ua) || (/iPad|iPod|iPhone/).test(ua)) {
3462
o.mobile = 'Apple'; // iPhone or iPod Touch
3464
m = ua.match(/OS ([^\s]*)/);
3466
m = numberify(m[1].replace('_', '.'));
3470
o.ipad = o.ipod = o.iphone = 0;
3472
m = ua.match(/iPad|iPod|iPhone/);
3474
o[m[0].toLowerCase()] = o.ios;
3477
m = ua.match(/NokiaN[^\/]*|webOS\/\d\.\d/);
3479
// Nokia N-series, webOS, ex: NokiaN95
3482
if (/webOS/.test(ua)) {
3484
m = ua.match(/webOS\/([^\s]*);/);
3486
o.webos = numberify(m[1]);
3489
if (/ Android/.test(ua)) {
3490
if (/Mobile/.test(ua)) {
3491
o.mobile = 'Android';
3493
m = ua.match(/Android ([^\s]*);/);
3495
o.android = numberify(m[1]);
3499
if (/Silk/.test(ua)) {
3500
m = ua.match(/Silk\/([^\s]*)\)/);
3502
o.silk = numberify(m[1]);
3505
o.android = 2.34; //Hack for desktop mode in Kindle
3508
if (/Accelerated=true/.test(ua)) {
3514
m = ua.match(/(Chrome|CrMo)\/([^\s]*)/);
3515
if (m && m[1] && m[2]) {
3516
o.chrome = numberify(m[2]); // Chrome
3517
o.safari = 0; //Reset safari back to 0
3518
if (m[1] === 'CrMo') {
3519
o.mobile = 'chrome';
3522
m = ua.match(/AdobeAIR\/([^\s]*)/);
3524
o.air = m[0]; // Adobe AIR 1.0 or better
3529
if (!o.webkit) { // not webkit
3530
// @todo check Opera/8.01 (J2ME/MIDP; Opera Mini/2.0.4509/1316; fi; U; ssr)
3531
if (/Opera/.test(ua)) {
3532
m = ua.match(/Opera[\s\/]([^\s]*)/);
3534
o.opera = numberify(m[1]);
3536
m = ua.match(/Version\/([^\s]*)/);
3538
o.opera = numberify(m[1]); // opera 10+
3541
if (/Opera Mobi/.test(ua)) {
3543
m = ua.replace('Opera Mobi', '').match(/Opera ([^\s]*)/);
3545
o.opera = numberify(m[1]);
3548
m = ua.match(/Opera Mini[^;]*/);
3551
o.mobile = m[0]; // ex: Opera Mini/2.0.4509/1316
3553
} else { // not opera or webkit
3554
m = ua.match(/MSIE\s([^;]*)/);
3556
o.ie = numberify(m[1]);
3557
} else { // not opera, webkit, or ie
3558
m = ua.match(/Gecko\/([^\s]*)/);
3560
o.gecko = 1; // Gecko detected, look for revision
3561
m = ua.match(/rv:([^\s\)]*)/);
3563
o.gecko = numberify(m[1]);
3571
//It was a parsed UA, do not assign the global value.
3574
if (typeof process == 'object') {
3576
if (process.versions && process.versions.node) {
3578
o.os = process.platform;
3579
o.nodejs = process.versions.node;
3591
Y.UA = YUI.Env.UA || YUI.Env.parseUA();
3593
"anim": ["anim-base","anim-color","anim-curve","anim-easing","anim-node-plugin","anim-scroll","anim-xy"],
3594
"app": ["app-base","app-transitions","model","model-list","router","view"],
3595
"attribute": ["attribute-base","attribute-complex"],
3596
"autocomplete": ["autocomplete-base","autocomplete-sources","autocomplete-list","autocomplete-plugin"],
3597
"base": ["base-base","base-pluginhost","base-build"],
3598
"cache": ["cache-base","cache-offline","cache-plugin"],
3599
"collection": ["array-extras","arraylist","arraylist-add","arraylist-filter","array-invoke"],
3600
"controller": ["router"],
3601
"dataschema": ["dataschema-base","dataschema-json","dataschema-xml","dataschema-array","dataschema-text"],
3602
"datasource": ["datasource-local","datasource-io","datasource-get","datasource-function","datasource-cache","datasource-jsonschema","datasource-xmlschema","datasource-arrayschema","datasource-textschema","datasource-polling"],
3603
"datatable": ["datatable-core","datatable-head","datatable-body","datatable-base","datatable-column-widths","datatable-message","datatable-mutable","datatable-sort","datatable-datasource"],
3604
"datatable-deprecated": ["datatable-base-deprecated","datatable-datasource-deprecated","datatable-sort-deprecated","datatable-scroll-deprecated"],
3605
"datatype": ["datatype-number","datatype-date","datatype-xml"],
3606
"datatype-date": ["datatype-date-parse","datatype-date-format"],
3607
"datatype-number": ["datatype-number-parse","datatype-number-format"],
3608
"datatype-xml": ["datatype-xml-parse","datatype-xml-format"],
3609
"dd": ["dd-ddm-base","dd-ddm","dd-ddm-drop","dd-drag","dd-proxy","dd-constrain","dd-drop","dd-scroll","dd-delegate"],
3610
"dom": ["dom-base","dom-screen","dom-style","selector-native","selector"],
3611
"editor": ["frame","editor-selection","exec-command","editor-base","editor-para","editor-br","editor-bidi","editor-tab","createlink-base"],
3612
"event": ["event-base","event-delegate","event-synthetic","event-mousewheel","event-mouseenter","event-key","event-focus","event-resize","event-hover","event-outside","event-touch","event-move","event-flick","event-valuechange"],
3613
"event-custom": ["event-custom-base","event-custom-complex"],
3614
"event-gestures": ["event-flick","event-move"],
3615
"handlebars": ["handlebars-compiler"],
3616
"highlight": ["highlight-base","highlight-accentfold"],
3617
"history": ["history-base","history-hash","history-hash-ie","history-html5"],
3618
"io": ["io-base","io-xdr","io-form","io-upload-iframe","io-queue"],
3619
"json": ["json-parse","json-stringify"],
3620
"loader": ["loader-base","loader-rollup","loader-yui3"],
3621
"node": ["node-base","node-event-delegate","node-pluginhost","node-screen","node-style"],
3622
"pluginhost": ["pluginhost-base","pluginhost-config"],
3623
"querystring": ["querystring-parse","querystring-stringify"],
3624
"recordset": ["recordset-base","recordset-sort","recordset-filter","recordset-indexer"],
3625
"resize": ["resize-base","resize-proxy","resize-constrain"],
3626
"slider": ["slider-base","slider-value-range","clickable-rail","range-slider"],
3627
"text": ["text-accentfold","text-wordbreak"],
3628
"widget": ["widget-base","widget-htmlparser","widget-skin","widget-uievents"]
3633
YUI.add('get', function(Y) {
3636
* NodeJS specific Get module used to load remote resources. It contains the same signature as the default Get module so there is no code change needed.
3637
* @module get-nodejs
3641
var path = require('path'),
3644
request = require('request');
3647
Y.Get = function() {
3650
//Setup the default config base path
3651
Y.config.base = path.join(__dirname, '../');
3653
YUI.require = require;
3654
YUI.process = process;
3657
* Escape the path for Windows, they need to be double encoded when used as `__dirname` or `__filename`
3658
* @method escapeWinPath
3660
* @param {String} p The path to modify
3661
* @return {String} The encoded path
3663
var escapeWinPath = function(p) {
3664
return p.replace(/\\/g, '\\\\');
3668
* Takes the raw JS files and wraps them to be executed in the YUI context so they can be loaded
3669
* into the YUI object
3672
* @param {String} data The JS to execute
3673
* @param {String} url The path to the file that was parsed
3674
* @param {Callback} cb The callback to execute when this is completed
3675
* @param {Error} cb.err=null Error object
3676
* @param {String} cb.url The URL that was just parsed
3679
Y.Get._exec = function(data, url, cb) {
3680
var dirName = escapeWinPath(path.dirname(url));
3681
var fileName = escapeWinPath(url);
3683
if (dirName.match(/^https?:\/\//)) {
3685
fileName = 'remoteResource';
3688
var mod = "(function(YUI) { var __dirname = '" + dirName + "'; "+
3689
"var __filename = '" + fileName + "'; " +
3690
"var process = YUI.process;" +
3691
"var require = function(file) {" +
3692
" if (file.indexOf('./') === 0) {" +
3693
" file = __dirname + file.replace('./', '/'); }" +
3694
" return YUI.require(file); }; " +
3695
data + " ;return YUI; })";
3697
//var mod = "(function(YUI) { " + data + ";return YUI; })";
3698
var script = vm.createScript(mod, url);
3699
var fn = script.runInThisContext(mod);
3705
* Fetches the content from a remote URL or a file from disc and passes the content
3706
* off to `_exec` for parsing
3709
* @param {String} url The URL/File path to fetch the content from
3710
* @param {Callback} cb The callback to fire once the content has been executed via `_exec`
3712
Y.Get._include = function(url, cb) {
3715
if (url.match(/^https?:\/\//)) {
3718
timeout: self.timeout
3720
request(cfg, function (err, response, body) {
3722
Y.log(err, 'error', 'get');
3725
Y.Get._exec(body, url, cb);
3729
if (Y.config.useSync) {
3730
//Needs to be in useSync
3731
if (path.existsSync(url)) {
3732
var mod = fs.readFileSync(url,'utf8');
3733
Y.Get._exec(mod, url, cb);
3735
cb('Path does not exist: ' + url, url);
3738
fs.readFile(url, 'utf8', function(err, mod) {
3742
Y.Get._exec(mod, url, cb);
3751
var end = function(cb, msg, result) {
3752
//Y.log('Get end: ' + cb.onEnd);
3753
if (Y.Lang.isFunction(cb.onEnd)) {
3754
cb.onEnd.call(Y, msg, result);
3756
}, pass = function(cb) {
3757
//Y.log('Get pass: ' + cb.onSuccess);
3758
if (Y.Lang.isFunction(cb.onSuccess)) {
3759
cb.onSuccess.call(Y, cb);
3761
end(cb, 'success', 'success');
3762
}, fail = function(cb, er) {
3763
//Y.log('Get fail: ' + er);
3764
if (Y.Lang.isFunction(cb.onFailure)) {
3765
cb.onFailure.call(Y, er, cb);
3767
end(cb, er, 'fail');
3772
* Override for Get.script for loading local or remote YUI modules.
3774
* @param {Array|String} s The URL's to load into this context
3775
* @param {Object} options Transaction options
3777
Y.Get.js = function(s, options) {
3780
urls = A(s), url, i, l = urls.length, c= 0,
3781
check = function() {
3789
for (i=0; i<l; i++) {
3791
if (Y.Lang.isObject(url)) {
3795
url = url.replace(/'/g, '%27');
3796
Y.log('URL: ' + url, 'info', 'get');
3797
Y.Get._include(url, function(err, url) {
3803
if (options.onProgress) {
3804
options.onProgress.call(options.context || Y, url);
3806
Y.log('After Load: ' + url, 'info', 'get');
3809
Y.log('----------------------------------------------------------', 'error', 'get');
3810
Y.log(err, 'error', 'get');
3811
Y.log('----------------------------------------------------------', 'error', 'get');
3821
* Alias for `Y.Get.js`
3824
Y.Get.script = Y.Get.js;
3826
//Place holder for SS Dom access
3827
Y.Get.css = function(s, cb) {
3828
Y.log('Y.Get.css is not supported, just reporting that it has loaded but not fetching.', 'warn', 'get');
3834
}, '3.5.0' ,{requires:['yui-base']});
3835
YUI.add('features', function(Y) {
3837
var feature_tests = {};
3840
Contains the core of YUI's feature test architecture.
3850
Y.mix(Y.namespace('Features'), {
3853
* Object hash of all registered feature tests
3857
tests: feature_tests,
3860
* Add a test to the system
3863
* Y.Features.add("load", "1", {});
3867
* @param {String} cat The category, right now only 'load' is supported
3868
* @param {String} name The number sequence of the test, how it's reported in the URL or config: 1, 2, 3
3869
* @param {Object} o Object containing test properties
3870
* @param {String} o.name The name of the test
3871
* @param {Function} o.test The test function to execute, the only argument to the function is the `Y` instance
3872
* @param {String} o.trigger The module that triggers this test.
3874
add: function(cat, name, o) {
3875
feature_tests[cat] = feature_tests[cat] || {};
3876
feature_tests[cat][name] = o;
3879
* Execute all tests of a given category and return the serialized results
3885
* @param {String} cat The category to execute
3886
* @param {Array} args The arguments to pass to the test function
3887
* @return {String} A semi-colon separated string of tests and their success/failure: 1:1;2:1;3:0
3889
all: function(cat, args) {
3890
var cat_o = feature_tests[cat],
3894
Y.Object.each(cat_o, function(v, k) {
3895
result.push(k + ':' + (Y.Features.test(cat, k, args) ? 1 : 0));
3899
return (result.length) ? result.join(';') : '';
3902
* Run a sepecific test and return a Boolean response.
3905
* Y.Features.test("load", "1");
3909
* @param {String} cat The category of the test to run
3910
* @param {String} name The name of the test to run
3911
* @param {Array} args The arguments to pass to the test function
3912
* @return {Boolean} True or false if the test passed/failed.
3914
test: function(cat, name, args) {
3916
var result, ua, test,
3917
cat_o = feature_tests[cat],
3918
feature = cat_o && cat_o[name];
3921
Y.log('Feature test ' + cat + ', ' + name + ' not found');
3924
result = feature.result;
3926
if (Y.Lang.isUndefined(result)) {
3930
result = (Y.UA[ua]);
3933
test = feature.test;
3934
if (test && ((!ua) || result)) {
3935
result = test.apply(Y, args);
3938
feature.result = result;
3946
// Y.Features.add("load", "1", {});
3947
// Y.Features.test("load", "1");
3948
// caps=1:1;2:0;3:1;
3950
/* This file is auto-generated by src/loader/scripts/meta_join.py */
3951
var add = Y.Features.add;
3954
"name": "io-nodejs",
3955
"trigger": "io-base",
3958
// graphics-canvas-default
3960
"name": "graphics-canvas-default",
3961
"test": function(Y) {
3962
var DOCUMENT = Y.config.doc,
3963
useCanvas = Y.config.defaultGraphicEngine && Y.config.defaultGraphicEngine == "canvas",
3964
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
3965
svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
3966
return (!svg || useCanvas) && (canvas && canvas.getContext && canvas.getContext("2d"));
3968
"trigger": "graphics"
3970
// autocomplete-list-keys
3972
"name": "autocomplete-list-keys",
3973
"test": function (Y) {
3974
// Only add keyboard support to autocomplete-list if this doesn't appear to
3975
// be an iOS or Android-based mobile device.
3977
// There's currently no feasible way to actually detect whether a device has
3978
// a hardware keyboard, so this sniff will have to do. It can easily be
3979
// overridden by manually loading the autocomplete-list-keys module.
3981
// Worth noting: even though iOS supports bluetooth keyboards, Mobile Safari
3982
// doesn't fire the keyboard events used by AutoCompleteList, so there's
3983
// no point loading the -keys module even when a bluetooth keyboard may be
3985
return !(Y.UA.ios || Y.UA.android);
3987
"trigger": "autocomplete-list"
3991
"name": "graphics-svg",
3992
"test": function(Y) {
3993
var DOCUMENT = Y.config.doc,
3994
useSVG = !Y.config.defaultGraphicEngine || Y.config.defaultGraphicEngine != "canvas",
3995
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
3996
svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
3998
return svg && (useSVG || !canvas);
4000
"trigger": "graphics"
4004
"name": "editor-para-ie",
4005
"trigger": "editor-para",
4009
// graphics-vml-default
4011
"name": "graphics-vml-default",
4012
"test": function(Y) {
4013
var DOCUMENT = Y.config.doc,
4014
canvas = DOCUMENT && DOCUMENT.createElement("canvas");
4015
return (DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d")));
4017
"trigger": "graphics"
4019
// graphics-svg-default
4021
"name": "graphics-svg-default",
4022
"test": function(Y) {
4023
var DOCUMENT = Y.config.doc,
4024
useSVG = !Y.config.defaultGraphicEngine || Y.config.defaultGraphicEngine != "canvas",
4025
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
4026
svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
4028
return svg && (useSVG || !canvas);
4030
"trigger": "graphics"
4034
"name": "history-hash-ie",
4035
"test": function (Y) {
4036
var docMode = Y.config.doc && Y.config.doc.documentMode;
4038
return Y.UA.ie && (!('onhashchange' in Y.config.win) ||
4039
!docMode || docMode < 8);
4041
"trigger": "history-hash"
4045
"name": "transition-timer",
4046
"test": function (Y) {
4047
var DOCUMENT = Y.config.doc,
4048
node = (DOCUMENT) ? DOCUMENT.documentElement: null,
4051
if (node && node.style) {
4052
ret = !('MozTransition' in node.style || 'WebkitTransition' in node.style);
4057
"trigger": "transition"
4061
"name": "dom-style-ie",
4062
"test": function (Y) {
4064
var testFeature = Y.Features.test,
4065
addFeature = Y.Features.add,
4066
WINDOW = Y.config.win,
4067
DOCUMENT = Y.config.doc,
4068
DOCUMENT_ELEMENT = 'documentElement',
4071
addFeature('style', 'computedStyle', {
4073
return WINDOW && 'getComputedStyle' in WINDOW;
4077
addFeature('style', 'opacity', {
4079
return DOCUMENT && 'opacity' in DOCUMENT[DOCUMENT_ELEMENT].style;
4083
ret = (!testFeature('style', 'opacity') &&
4084
!testFeature('style', 'computedStyle'));
4088
"trigger": "dom-style"
4092
"name": "selector-css2",
4093
"test": function (Y) {
4094
var DOCUMENT = Y.config.doc,
4095
ret = DOCUMENT && !('querySelectorAll' in DOCUMENT);
4099
"trigger": "selector"
4103
"name": "widget-base-ie",
4104
"trigger": "widget-base",
4109
"name": "event-base-ie",
4110
"test": function(Y) {
4111
var imp = Y.config.doc && Y.config.doc.implementation;
4112
return (imp && (!imp.hasFeature('Events', '2.0')));
4114
"trigger": "node-base"
4118
"name": "dd-gestures",
4119
"test": function(Y) {
4120
return ((Y.config.win && ("ontouchstart" in Y.config.win)) && !(Y.UA.chrome && Y.UA.chrome < 6));
4122
"trigger": "dd-drag"
4124
// scrollview-base-ie
4126
"name": "scrollview-base-ie",
4127
"trigger": "scrollview-base",
4130
// app-transitions-native
4132
"name": "app-transitions-native",
4133
"test": function (Y) {
4134
var doc = Y.config.doc,
4135
node = doc ? doc.documentElement : null;
4137
if (node && node.style) {
4138
return ('MozTransition' in node.style || 'WebkitTransition' in node.style);
4143
"trigger": "app-transitions"
4147
"name": "graphics-canvas",
4148
"test": function(Y) {
4149
var DOCUMENT = Y.config.doc,
4150
useCanvas = Y.config.defaultGraphicEngine && Y.config.defaultGraphicEngine == "canvas",
4151
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
4152
svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
4153
return (!svg || useCanvas) && (canvas && canvas.getContext && canvas.getContext("2d"));
4155
"trigger": "graphics"
4159
"name": "graphics-vml",
4160
"test": function(Y) {
4161
var DOCUMENT = Y.config.doc,
4162
canvas = DOCUMENT && DOCUMENT.createElement("canvas");
4163
return (DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d")));
4165
"trigger": "graphics"
4169
}, '3.5.0' ,{requires:['yui-base']});
4170
YUI.add('intl-base', function(Y) {
4173
* The Intl utility provides a central location for managing sets of
4174
* localized resources (strings and formatting patterns).
4181
var SPLIT_REGEX = /[, ]/;
4183
Y.mix(Y.namespace('Intl'), {
4186
* Returns the language among those available that
4187
* best matches the preferred language list, using the Lookup
4188
* algorithm of BCP 47.
4189
* If none of the available languages meets the user's preferences,
4190
* then "" is returned.
4191
* Extended language ranges are not supported.
4193
* @method lookupBestLang
4194
* @param {String[] | String} preferredLanguages The list of preferred
4195
* languages in descending preference order, represented as BCP 47
4196
* language tags. A string array or a comma-separated list.
4197
* @param {String[]} availableLanguages The list of languages
4198
* that the application supports, represented as BCP 47 language
4201
* @return {String} The available language that best matches the
4202
* preferred language list, or "".
4205
lookupBestLang: function(preferredLanguages, availableLanguages) {
4207
var i, language, result, index;
4209
// check whether the list of available languages contains language;
4211
function scan(language) {
4213
for (i = 0; i < availableLanguages.length; i += 1) {
4214
if (language.toLowerCase() ===
4215
availableLanguages[i].toLowerCase()) {
4216
return availableLanguages[i];
4221
if (Y.Lang.isString(preferredLanguages)) {
4222
preferredLanguages = preferredLanguages.split(SPLIT_REGEX);
4225
for (i = 0; i < preferredLanguages.length; i += 1) {
4226
language = preferredLanguages[i];
4227
if (!language || language === '*') {
4230
// check the fallback sequence for one language
4231
while (language.length > 0) {
4232
result = scan(language);
4236
index = language.lastIndexOf('-');
4238
language = language.substring(0, index);
4239
// one-character subtags get cut along with the
4241
if (index >= 2 && language.charAt(index - 2) === '-') {
4242
language = language.substring(0, index - 2);
4245
// nothing available for this language
4257
}, '3.5.0' ,{requires:['yui-base']});
4258
YUI.add('yui-log', function(Y) {
4261
* Provides console log capability and exposes a custom event for
4262
* console implementations. This module is a `core` YUI module, <a href="../classes/YUI.html#method_log">it's documentation is located under the YUI class</a>.
4265
* @submodule yui-log
4269
LOGEVENT = 'yui:log',
4270
UNDEFINED = 'undefined',
4271
LEVELS = { debug: 1,
4277
* If the 'debug' config is true, a 'yui:log' event will be
4278
* dispatched, which the Console widget and anything else
4279
* can consume. If the 'useBrowserConsole' config is true, it will
4280
* write to the browser console if available. YUI-specific log
4281
* messages will only be present in the -debug versions of the
4282
* JS files. The build system is supposed to remove log statements
4283
* from the raw and minified versions of the files.
4287
* @param {String} msg The message to log.
4288
* @param {String} cat The log category for the message. Default
4289
* categories are "info", "warn", "error", time".
4290
* Custom categories can be used as well. (opt).
4291
* @param {String} src The source of the the message (opt).
4292
* @param {boolean} silent If true, the log event won't fire.
4293
* @return {YUI} YUI instance.
4295
INSTANCE.log = function(msg, cat, src, silent) {
4296
var bail, excl, incl, m, f,
4299
publisher = (Y.fire) ? Y : YUI.Env.globalEvents;
4300
// suppress log message if the config is off or the event stack
4301
// or the event call stack contains a consumer of the yui:log event
4303
// apply source filters
4305
excl = c.logExclude;
4306
incl = c.logInclude;
4307
if (incl && !(src in incl)) {
4309
} else if (incl && (src in incl)) {
4311
} else if (excl && (src in excl)) {
4316
if (c.useBrowserConsole) {
4317
m = (src) ? src + ': ' + msg : msg;
4318
if (Y.Lang.isFunction(c.logFn)) {
4319
c.logFn.call(Y, msg, cat, src);
4320
} else if (typeof console != UNDEFINED && console.log) {
4321
f = (cat && console[cat] && (cat in LEVELS)) ? cat : 'log';
4323
} else if (typeof opera != UNDEFINED) {
4328
if (publisher && !silent) {
4330
if (publisher == Y && (!publisher.getEvent(LOGEVENT))) {
4331
publisher.publish(LOGEVENT, {
4336
publisher.fire(LOGEVENT, {
4349
* Write a system message. This message will be preserved in the
4350
* minified and raw versions of the YUI files, unlike log statements.
4353
* @param {String} msg The message to log.
4354
* @param {String} cat The log category for the message. Default
4355
* categories are "info", "warn", "error", time".
4356
* Custom categories can be used as well. (opt).
4357
* @param {String} src The source of the the message (opt).
4358
* @param {boolean} silent If true, the log event won't fire.
4359
* @return {YUI} YUI instance.
4361
INSTANCE.message = function() {
4362
return INSTANCE.log.apply(INSTANCE, arguments);
4366
}, '3.5.0' ,{requires:['yui-base']});
4367
YUI.add('yui-log-nodejs', function(Y) {
4369
var sys = require(process.binding('natives').util ? 'util' : 'sys'),
4373
var stdio = require("stdio");
4374
hasColor = stdio.isStderrATTY();
4379
Y.config.useColor = hasColor;
4381
Y.consoleColor = function(str, num) {
4382
if (!this.config.useColor) {
4388
return "\033[" + num +"m" + str + "\033[0m"
4392
var logFn = function(str, t, m) {
4395
id = '[' + this.id + ']:';
4398
m = (m) ? this.consoleColor(' (' + m.toLowerCase() + '):', 35) : '';
4404
if ((typeof str === 'object') || str instanceof Array) {
4406
//Should we use this?
4407
if (str.tagName || str._yuid || str._query) {
4408
str = str.toString();
4410
str = sys.inspect(str);
4417
var lvl = '37;40', mLvl = ((str) ? '' : 31);
4418
t = t+''; //Force to a string..
4419
switch (t.toLowerCase()) {
4430
if (typeof str === 'string') {
4431
if (str && str.indexOf("\n") !== -1) {
4436
// output log messages to stderr
4437
sys.error(this.consoleColor(t.toLowerCase() + ':', lvl) + m + ' ' + this.consoleColor(str, mLvl));
4440
if (!Y.config.logFn) {
4441
Y.config.logFn = logFn;
4446
}, '3.5.0' ,{requires:['yui-log']});
4447
YUI.add('yui-later', function(Y) {
4450
* Provides a setTimeout/setInterval wrapper. This module is a `core` YUI module, <a href="../classes/YUI.html#method_later">it's documentation is located under the YUI class</a>.
4453
* @submodule yui-later
4459
* Executes the supplied function in the context of the supplied
4460
* object 'when' milliseconds later. Executes the function a
4461
* single time unless periodic is set to true.
4464
* @param when {int} the number of milliseconds to wait until the fn
4466
* @param o the context object.
4467
* @param fn {Function|String} the function to execute or the name of
4468
* the method in the 'o' object to execute.
4469
* @param data [Array] data that is provided to the function. This
4470
* accepts either a single item or an array. If an array is provided,
4471
* the function is executed with one parameter for each array item.
4472
* If you need to pass a single array parameter, it needs to be wrapped
4473
* in an array [myarray].
4475
* Note: native methods in IE may not have the call and apply methods.
4476
* In this case, it will work, but you are limited to four arguments.
4478
* @param periodic {boolean} if true, executes continuously at supplied
4479
* interval until canceled.
4480
* @return {object} a timer object. Call the cancel() method on this
4481
* object to stop the timer.
4483
Y.later = function(when, o, fn, data, periodic) {
4485
data = (!Y.Lang.isUndefined(data)) ? Y.Array(data) : NO_ARGS;
4486
o = o || Y.config.win || Y;
4488
var cancelled = false,
4489
method = (o && Y.Lang.isString(fn)) ? o[fn] : fn,
4490
wrapper = function() {
4491
// IE 8- may execute a setInterval callback one last time
4492
// after clearInterval was called, so in order to preserve
4493
// the cancel() === no more runny-run, we have to jump through
4496
if (!method.apply) {
4497
method(data[0], data[1], data[2], data[3]);
4499
method.apply(o, data || NO_ARGS);
4503
id = (periodic) ? setInterval(wrapper, when) : setTimeout(wrapper, when);
4508
cancel: function() {
4510
if (this.interval) {
4519
Y.Lang.later = Y.later;
4523
}, '3.5.0' ,{requires:['yui-base']});
4524
YUI.add('loader-base', function(Y) {
4527
* The YUI loader core
4529
* @submodule loader-base
4532
if (!YUI.Env[Y.version]) {
4535
var VERSION = Y.version,
4537
ROOT = VERSION + BUILD,
4538
CDN_BASE = Y.Env.base,
4539
GALLERY_VERSION = '${loader.gallery}',
4541
TNT_VERSION = '${loader.tnt}',
4542
YUI2_VERSION = '${loader.yui2}',
4543
COMBO_BASE = CDN_BASE + 'combo?',
4544
META = { version: VERSION,
4547
comboBase: COMBO_BASE,
4548
skin: { defaultSkin: 'sam',
4549
base: 'assets/skins/',
4556
'cssfonts-context']},
4559
groups = META.groups,
4560
yui2Update = function(tnt, yui2, config) {
4562
var root = TNT + '.' +
4563
(tnt || TNT_VERSION) + '/' +
4564
(yui2 || YUI2_VERSION) + BUILD,
4565
base = (config && config.base) ? config.base : CDN_BASE,
4566
combo = (config && config.comboBase) ? config.comboBase : COMBO_BASE;
4568
groups.yui2.base = base + root;
4569
groups.yui2.root = root;
4570
groups.yui2.comboBase = combo;
4572
galleryUpdate = function(tag, config) {
4573
var root = (tag || GALLERY_VERSION) + BUILD,
4574
base = (config && config.base) ? config.base : CDN_BASE,
4575
combo = (config && config.comboBase) ? config.comboBase : COMBO_BASE;
4577
groups.gallery.base = base + root;
4578
groups.gallery.root = root;
4579
groups.gallery.comboBase = combo;
4583
groups[VERSION] = {};
4588
comboBase: COMBO_BASE,
4589
update: galleryUpdate,
4590
patterns: { 'gallery-': { },
4591
'lang/gallery-': {},
4592
'gallerycss-': { type: 'css' } }
4598
comboBase: COMBO_BASE,
4602
configFn: function(me) {
4603
if (/-skin|reset|fonts|grids|base/.test(me.name)) {
4605
me.path = me.path.replace(/\.js/, '.css');
4606
// this makes skins in builds earlier than
4607
// 2.6.0 work as long as combine is false
4608
me.path = me.path.replace(/\/yui2-skin/,
4609
'/assets/skins/sam/yui2-skin');
4619
YUI.Env[VERSION] = META;
4625
* Loader dynamically loads script and css files. It includes the dependency
4626
* information for the version of the library in use, and will automatically pull in
4627
* dependencies for the modules requested. It can also load the
4628
* files from the Yahoo! CDN, and it can utilize the combo service provided on
4629
* this network to reduce the number of http connections required to download
4634
* @submodule loader-base
4638
NO_REQUIREMENTS = [],
4639
MAX_URL_LENGTH = 1024,
4640
GLOBAL_ENV = YUI.Env,
4641
GLOBAL_LOADED = GLOBAL_ENV._loaded,
4645
VERSION = Y.version,
4648
oeach = YObject.each,
4650
_queue = GLOBAL_ENV._loaderQueue,
4651
META = GLOBAL_ENV[VERSION],
4652
SKIN_PREFIX = 'skin-',
4654
ON_PAGE = GLOBAL_ENV.mods,
4657
_path = function(dir, file, type, nomin) {
4658
var path = dir + '/' + file;
4662
path += '.' + (type || CSS);
4668
* The component metadata is stored in Y.Env.meta.
4669
* Part of the loader module.
4676
* Loader dynamically loads script and css files. It includes the dependency
4677
* info for the version of the library in use, and will automatically pull in
4678
* dependencies for the modules requested. It can load the
4679
* files from the Yahoo! CDN, and it can utilize the combo service provided on
4680
* this network to reduce the number of http connections required to download
4681
* YUI files. You can also specify an external, custom combo service to host
4682
* your modules as well.
4685
var loader = new Y.Loader({
4690
require: ['node', 'dd', 'console']
4692
var out = loader.resolve(true);
4696
* @param {Object} config an optional set of configuration options.
4697
* @param {String} config.base The base dir which to fetch this module from
4698
* @param {String} config.comboBase The Combo service base path. Ex: `http://yui.yahooapis.com/combo?`
4699
* @param {String} config.root The root path to prepend to module names for the combo service. Ex: `2.5.2/build/`
4700
* @param {String|Object} config.filter A filter to apply to result urls. <a href="#property_filter">See filter property</a>
4701
* @param {Object} config.filters Per-component filter specification. If specified for a given component, this overrides the filter config.
4702
* @param {Boolean} config.combine Use a combo service to reduce the number of http connections required to load your dependencies
4703
* @param {Array} config.ignore: A list of modules that should never be dynamically loaded
4704
* @param {Array} config.force A list of modules that should always be loaded when required, even if already present on the page
4705
* @param {HTMLElement|String} config.insertBefore Node or id for a node that should be used as the insertion point for new nodes
4706
* @param {Object} config.jsAttributes Object literal containing attributes to add to script nodes
4707
* @param {Object} config.cssAttributes Object literal containing attributes to add to link nodes
4708
* @param {Number} config.timeout The number of milliseconds before a timeout occurs when dynamically loading nodes. If not set, there is no timeout
4709
* @param {Object} config.context Execution context for all callbacks
4710
* @param {Function} config.onSuccess Callback for the 'success' event
4711
* @param {Function} config.onFailure Callback for the 'failure' event
4712
* @param {Function} config.onCSS Callback for the 'CSSComplete' event. When loading YUI components with CSS the CSS is loaded first, then the script. This provides a moment you can tie into to improve the presentation of the page while the script is loading.
4713
* @param {Function} config.onTimeout Callback for the 'timeout' event
4714
* @param {Function} config.onProgress Callback executed each time a script or css file is loaded
4715
* @param {Object} config.modules A list of module definitions. See <a href="#method_addModule">Loader.addModule</a> for the supported module metadata
4716
* @param {Object} config.groups A list of group definitions. Each group can contain specific definitions for `base`, `comboBase`, `combine`, and accepts a list of `modules`.
4717
* @param {String} config.2in3 The version of the YUI 2 in 3 wrapper to use. The intrinsic support for YUI 2 modules in YUI 3 relies on versions of the YUI 2 components inside YUI 3 module wrappers. These wrappers change over time to accomodate the issues that arise from running YUI 2 in a YUI 3 sandbox.
4718
* @param {String} config.yui2 When using the 2in3 project, you can select the version of YUI 2 to use. Valid values are `2.2.2`, `2.3.1`, `2.4.1`, `2.5.2`, `2.6.0`, `2.7.0`, `2.8.0`, `2.8.1` and `2.9.0` [default] -- plus all versions of YUI 2 going forward.
4720
Y.Loader = function(o) {
4722
var defaults = META.modules,
4725
//Catch no config passed.
4728
modulekey = META.md5;
4731
* Internal callback to handle multiple internal insert() calls
4732
* so that css is inserted prior to js
4733
* @property _internalCallback
4736
// self._internalCallback = null;
4739
* Callback that will be executed when the loader is finished
4744
// self.onSuccess = null;
4747
* Callback that will be executed if there is a failure
4751
// self.onFailure = null;
4754
* Callback for the 'CSSComplete' event. When loading YUI components
4755
* with CSS the CSS is loaded first, then the script. This provides
4756
* a moment you can tie into to improve the presentation of the page
4757
* while the script is loading.
4761
// self.onCSS = null;
4764
* Callback executed each time a script or css file is loaded
4765
* @method onProgress
4768
// self.onProgress = null;
4771
* Callback that will be executed if a timeout occurs
4775
// self.onTimeout = null;
4778
* The execution context for all callbacks
4780
* @default {YUI} the YUI instance
4785
* Data that is passed to all callbacks
4788
// self.data = null;
4791
* Node reference or id where new nodes should be inserted before
4792
* @property insertBefore
4793
* @type string|HTMLElement
4795
// self.insertBefore = null;
4798
* The charset attribute for inserted nodes
4801
* @deprecated , use cssAttributes or jsAttributes.
4803
// self.charset = null;
4806
* An object literal containing attributes to add to link nodes
4807
* @property cssAttributes
4810
// self.cssAttributes = null;
4813
* An object literal containing attributes to add to script nodes
4814
* @property jsAttributes
4817
// self.jsAttributes = null;
4820
* The base directory.
4823
* @default http://yui.yahooapis.com/[YUI VERSION]/build/
4825
self.base = Y.Env.meta.base + Y.Env.meta.root;
4828
* Base path for the combo service
4829
* @property comboBase
4831
* @default http://yui.yahooapis.com/combo?
4833
self.comboBase = Y.Env.meta.comboBase;
4836
* Base path for language packs.
4838
// self.langBase = Y.Env.meta.langBase;
4842
* If configured, the loader will attempt to use the combo
4843
* service for YUI resources and configured external resources.
4846
* @default true if a base dir isn't in the config
4848
self.combine = o.base &&
4849
(o.base.indexOf(self.comboBase.substr(0, 20)) > -1);
4852
* The default seperator to use between files in a combo URL
4853
* @property comboSep
4855
* @default Ampersand
4857
self.comboSep = '&';
4859
* Max url length for combo urls. The default is 2048. This is the URL
4860
* limit for the Yahoo! hosted combo servers. If consuming
4861
* a different combo service that has a different URL limit
4862
* it is possible to override this default by supplying
4863
* the maxURLLength config option. The config option will
4864
* only take effect if lower than the default.
4866
* @property maxURLLength
4869
self.maxURLLength = MAX_URL_LENGTH;
4872
* Ignore modules registered on the YUI global
4873
* @property ignoreRegistered
4876
//self.ignoreRegistered = false;
4879
* Root path to prepend to module path for the combo
4883
* @default [YUI VERSION]/build/
4885
self.root = Y.Env.meta.root;
4888
* Timeout value in milliseconds. If set, self value will be used by
4889
* the get utility. the timeout event will fire if
4897
* A list of modules that should not be loaded, even if
4898
* they turn up in the dependency tree
4902
// self.ignore = null;
4905
* A list of modules that should always be loaded, even
4906
* if they have already been inserted into the page.
4910
// self.force = null;
4915
* Should we allow rollups
4916
* @property allowRollup
4920
self.allowRollup = false;
4923
* A filter to apply to result urls. This filter will modify the default
4924
* path for all modules. The default path for the YUI library is the
4925
* minified version of the files (e.g., event-min.js). The filter property
4926
* can be a predefined filter or a custom filter. The valid predefined
4930
* <dd>Selects the debug versions of the library (e.g., event-debug.js).
4931
* This option will automatically include the Logger widget</dd>
4933
* <dd>Selects the non-minified version of the library (e.g., event.js).
4936
* You can also define a custom filter, which must be an object literal
4937
* containing a search expression and a replace string:
4940
* 'searchExp': "-min\\.js",
4941
* 'replaceStr': "-debug.js"
4945
* @type string| {searchExp: string, replaceStr: string}
4947
// self.filter = null;
4950
* per-component filter specification. If specified for a given
4951
* component, this overrides the filter config.
4958
* The list of requested modules
4959
* @property required
4960
* @type {string: boolean}
4965
* If a module name is predefined when requested, it is checked againsts
4966
* the patterns provided in this property. If there is a match, the
4967
* module is added with the default configuration.
4969
* At the moment only supporting module prefixes, but anticipate
4970
* supporting at least regular expressions.
4971
* @property patterns
4974
// self.patterns = Y.merge(Y.Env.meta.patterns);
4978
* The library metadata
4979
* @property moduleInfo
4981
// self.moduleInfo = Y.merge(Y.Env.meta.moduleInfo);
4982
self.moduleInfo = {};
4984
self.groups = Y.merge(Y.Env.meta.groups);
4987
* Provides the information used to skin the skinnable components.
4988
* The following skin definition would result in 'skin1' and 'skin2'
4989
* being loaded for calendar (if calendar was requested), and
4990
* 'sam' for all other skinnable components:
4993
* // The default skin, which is automatically applied if not
4994
* // overriden by a component-specific skin definition.
4995
* // Change this in to apply a different skin globally
4996
* defaultSkin: 'sam',
4998
* // This is combined with the loader base property to get
4999
* // the default root directory for a skin. ex:
5000
* // http://yui.yahooapis.com/2.3.0/build/assets/skins/sam/
5001
* base: 'assets/skins/',
5003
* // Any component-specific overrides can be specified here,
5004
* // making it possible to load different skins for different
5005
* // components. It is possible to load more than one skin
5006
* // for a given component as well.
5008
* calendar: ['skin1', 'skin2']
5014
self.skin = Y.merge(Y.Env.meta.skin);
5017
* Map of conditional modules
5020
self.conditions = {};
5022
// map of modules with a hash of modules that meet the requirement
5023
// self.provides = {};
5026
self._internal = true;
5029
cache = GLOBAL_ENV._renderedMods;
5032
oeach(cache, function modCache(v, k) {
5033
self.moduleInfo[k] = Y.merge(v);
5036
cache = GLOBAL_ENV._conditions;
5038
oeach(cache, function condCache(v, k) {
5039
self.conditions[k] = Y.merge(v);
5043
oeach(defaults, self.addModule, self);
5048
* Set when beginning to compute the dependency tree.
5049
* Composed of what YUI reports to be loaded combined
5050
* with what has been loaded by any instance on the page
5051
* with the version number specified in the metadata.
5053
* @type {string: boolean}
5055
self.loaded = GLOBAL_LOADED[VERSION];
5058
self._inspectPage();
5060
self._internal = false;
5064
self.forceMap = (self.force) ? Y.Array.hash(self.force) : {};
5066
self.testresults = null;
5068
if (Y.config.tests) {
5069
self.testresults = Y.config.tests;
5073
* List of rollup files found in the library metadata
5076
// self.rollups = null;
5079
* Whether or not to load optional dependencies for
5080
* the requested modules
5081
* @property loadOptional
5085
// self.loadOptional = false;
5088
* All of the derived dependencies in sorted order, which
5089
* will be populated when either calculate() or insert()
5097
* A list of modules to attach to the YUI instance when complete.
5098
* If not supplied, the sorted list of dependencies are applied.
5099
* @property attaching
5101
// self.attaching = null;
5104
* Flag to indicate the dependency tree needs to be recomputed
5105
* if insert is called again.
5113
* List of modules inserted by the utility
5114
* @property inserted
5115
* @type {string: boolean}
5120
* List of skipped modules during insert() because the module
5126
// Y.on('yui:load', self.loadNext, self);
5131
* Cached sorted calculate results
5135
//self.results = {};
5139
Y.Loader.prototype = {
5141
Regex that matches a CSS URL. Used to guess the file type when it's not
5150
REGEX_CSS: /\.css(?:[?;].*)?$/i,
5153
* Default filters for raw and debug
5154
* @property FILTER_DEFS
5161
'searchExp': '-min\\.js',
5165
'searchExp': '-min\\.js',
5166
'replaceStr': '-debug.js'
5170
* Check the pages meta-data and cache the result.
5171
* @method _inspectPage
5174
_inspectPage: function() {
5176
//Inspect the page for CSS only modules and mark them as loaded.
5177
oeach(this.moduleInfo, function(v, k) {
5178
if (v.type && v.type === CSS) {
5179
if (this.isCSSLoaded(v.name)) {
5180
Y.log('Found CSS module on page: ' + v.name, 'info', 'loader');
5181
this.loaded[k] = true;
5186
oeach(ON_PAGE, function(v, k) {
5188
var m = this.moduleInfo[k],
5189
req = v.details.requires,
5190
mr = m && m.requires;
5192
if (!m._inspected && req && mr.length != req.length) {
5193
// console.log('deleting ' + m.name);
5197
m = this.addModule(v.details, k);
5199
m._inspected = true;
5204
* returns true if b is not loaded, and is required directly or by means of modules it supersedes.
5207
* @param {String} mod1 The first module to compare
5208
* @param {String} mod2 The second module to compare
5210
_requires: function(mod1, mod2) {
5212
var i, rm, after_map, s,
5213
info = this.moduleInfo,
5221
rm = m.expanded_map;
5222
after_map = m.after_map;
5224
// check if this module should be sorted after the other
5225
// do this first to short circut circular deps
5226
if (after_map && (mod2 in after_map)) {
5230
after_map = other.after_map;
5233
if (after_map && (mod1 in after_map)) {
5237
// check if this module requires one the other supersedes
5238
s = info[mod2] && info[mod2].supersedes;
5240
for (i = 0; i < s.length; i++) {
5241
if (this._requires(mod1, s[i])) {
5247
s = info[mod1] && info[mod1].supersedes;
5249
for (i = 0; i < s.length; i++) {
5250
if (this._requires(mod2, s[i])) {
5256
// check if this module requires the other directly
5257
// if (r && YArray.indexOf(r, mod2) > -1) {
5258
if (rm && (mod2 in rm)) {
5262
// external css files should be sorted below yui css
5263
if (m.ext && m.type == CSS && !other.ext && other.type == CSS) {
5270
* Apply a new config to the Loader instance
5273
* @param {Object} o The new configuration
5275
_config: function(o) {
5276
var i, j, val, f, group, groupName, self = this;
5277
// apply config values
5280
if (o.hasOwnProperty(i)) {
5282
if (i == 'require') {
5284
} else if (i == 'skin') {
5285
//If the config.skin is a string, format to the expected object
5286
if (typeof val === 'string') {
5287
self.skin.defaultSkin = o.skin;
5293
Y.mix(self.skin, val, true);
5294
} else if (i == 'groups') {
5296
if (val.hasOwnProperty(j)) {
5297
// Y.log('group: ' + j);
5300
self.addGroup(group, groupName);
5301
if (group.aliases) {
5302
oeach(group.aliases, self.addAlias, self);
5307
} else if (i == 'modules') {
5308
// add a hash of module definitions
5309
oeach(val, self.addModule, self);
5310
} else if (i === 'aliases') {
5311
oeach(val, self.addAlias, self);
5312
} else if (i == 'gallery') {
5313
this.groups.gallery.update(val, o);
5314
} else if (i == 'yui2' || i == '2in3') {
5315
this.groups.yui2.update(o['2in3'], o.yui2, o);
5326
if (L.isString(f)) {
5327
f = f.toUpperCase();
5328
self.filterName = f;
5329
self.filter = self.FILTER_DEFS[f];
5331
self.require('yui-log', 'dump');
5337
//Removed this so that when Loader is invoked
5338
//it doesn't request what it doesn't need.
5339
//self.require('intl-base', 'intl');
5345
* Returns the skin module name for the specified skin name. If a
5346
* module name is supplied, the returned skin module name is
5347
* specific to the module passed in.
5348
* @method formatSkin
5349
* @param {string} skin the name of the skin.
5350
* @param {string} mod optional: the name of a module to skin.
5351
* @return {string} the full skin module name.
5353
formatSkin: function(skin, mod) {
5354
var s = SKIN_PREFIX + skin;
5363
* Adds the skin def to the module info
5365
* @param {string} skin the name of the skin.
5366
* @param {string} mod the name of the module.
5367
* @param {string} parent parent module if this is a skin of a
5368
* submodule or plugin.
5369
* @return {string} the module name for the skin.
5372
_addSkin: function(skin, mod, parent) {
5373
var mdef, pkg, name, nmod,
5374
info = this.moduleInfo,
5376
ext = info[mod] && info[mod].ext;
5378
// Add a module definition for the module-specific skin css
5380
name = this.formatSkin(skin, mod);
5383
pkg = mdef.pkg || mod;
5389
path: (parent || pkg) + '/' + sinf.base + skin +
5394
nmod.base = mdef.base;
5396
if (mdef.configFn) {
5397
nmod.configFn = mdef.configFn;
5399
this.addModule(nmod, name);
5401
Y.log('Adding skin (' + name + '), ' + parent + ', ' + pkg + ', ' + info[name].path, 'info', 'loader');
5408
* Adds an alias module to the system
5410
* @param {Array} use An array of modules that makes up this alias
5411
* @param {String} name The name of the alias
5413
* var loader = new Y.Loader({});
5414
* loader.addAlias([ 'node', 'yql' ], 'davglass');
5415
* loader.require(['davglass']);
5416
* var out = loader.resolve(true);
5418
* //out.js will contain Node and YQL modules
5420
addAlias: function(use, name) {
5421
YUI.Env.aliases[name] = use;
5428
* Add a new module group
5430
* @param {Object} config An object containing the group configuration data
5431
* @param {String} config.name required, the group name
5432
* @param {String} config.base The base directory for this module group
5433
* @param {String} config.root The root path to add to each combo resource path
5434
* @param {Boolean} config.combine Should the request be combined
5435
* @param {String} config.comboBase Combo service base path
5436
* @param {Object} config.modules The group of modules
5437
* @param {String} name the group name.
5439
* var loader = new Y.Loader({});
5443
* comboBase: '/combo?',
5446
* //Module List here
5450
addGroup: function(o, name) {
5451
var mods = o.modules,
5453
name = name || o.name;
5455
self.groups[name] = o;
5458
oeach(o.patterns, function(v, k) {
5460
self.patterns[k] = v;
5465
oeach(mods, function(v, k) {
5466
if (typeof v === 'string') {
5467
v = { name: k, fullpath: v };
5470
self.addModule(v, k);
5476
* Add a new module to the component metadata.
5478
* @param {Object} config An object containing the module data.
5479
* @param {String} config.name Required, the component name
5480
* @param {String} config.type Required, the component type (js or css)
5481
* @param {String} config.path Required, the path to the script from `base`
5482
* @param {Array} config.requires Array of modules required by this component
5483
* @param {Array} [config.optional] Array of optional modules for this component
5484
* @param {Array} [config.supersedes] Array of the modules this component replaces
5485
* @param {Array} [config.after] Array of modules the components which, if present, should be sorted above this one
5486
* @param {Object} [config.after_map] Faster alternative to 'after' -- supply a hash instead of an array
5487
* @param {Number} [config.rollup] The number of superseded modules required for automatic rollup
5488
* @param {String} [config.fullpath] If `fullpath` is specified, this is used instead of the configured `base + path`
5489
* @param {Boolean} [config.skinnable] Flag to determine if skin assets should automatically be pulled in
5490
* @param {Object} [config.submodules] Hash of submodules
5491
* @param {String} [config.group] The group the module belongs to -- this is set automatically when it is added as part of a group configuration.
5492
* @param {Array} [config.lang] Array of BCP 47 language tags of languages for which this module has localized resource bundles, e.g., `["en-GB", "zh-Hans-CN"]`
5493
* @param {Object} [config.condition] Specifies that the module should be loaded automatically if a condition is met. This is an object with up to three fields:
5494
* @param {String} [config.condition.trigger] The name of a module that can trigger the auto-load
5495
* @param {Function} [config.condition.test] A function that returns true when the module is to be loaded.
5496
* @param {String} [config.condition.when] Specifies the load order of the conditional module
5497
* with regard to the position of the trigger module.
5498
* This should be one of three values: `before`, `after`, or `instead`. The default is `after`.
5499
* @param {Object} [config.testresults] A hash of test results from `Y.Features.all()`
5500
* @param {Function} [config.configFn] A function to exectute when configuring this module
5501
* @param {Object} config.configFn.mod The module config, modifying this object will modify it's config. Returning false will delete the module's config.
5502
* @param {String} [name] The module name, required if not in the module data.
5503
* @return {Object} the module definition or null if the object passed in did not provide all required attributes.
5505
addModule: function(o, name) {
5506
name = name || o.name;
5508
if (typeof o === 'string') {
5509
o = { name: name, fullpath: o };
5512
//Only merge this data if the temp flag is set
5513
//from an earlier pass from a pattern or else
5514
//an override module (YUI_config) can not be used to
5515
//replace a default module.
5516
if (this.moduleInfo[name] && this.moduleInfo[name].temp) {
5517
//This catches temp modules loaded via a pattern
5518
// The module will be added twice, once from the pattern and
5519
// Once from the actual add call, this ensures that properties
5520
// that were added to the module the first time around (group: gallery)
5521
// are also added the second time around too.
5522
o = Y.merge(this.moduleInfo[name], o);
5527
if (!o || !o.name) {
5532
//Always assume it's javascript unless the CSS pattern is matched.
5534
var p = o.path || o.fullpath;
5535
if (p && this.REGEX_CSS.test(p)) {
5536
Y.log('Auto determined module type as CSS', 'warn', 'loader');
5541
if (!o.path && !o.fullpath) {
5542
o.path = _path(name, name, o.type);
5544
o.supersedes = o.supersedes || o.use;
5546
o.ext = ('ext' in o) ? o.ext : (this._internal) ? false : true;
5548
// Handle submodule logic
5549
var subs = o.submodules, i, l, t, sup, s, smod, plugins, plug,
5550
j, langs, packName, supName, flatSup, flatLang, lang, ret,
5551
overrides, skinname, when,
5552
conditions = this.conditions, trigger;
5553
// , existing = this.moduleInfo[name], newr;
5555
this.moduleInfo[name] = o;
5557
o.requires = o.requires || [];
5560
skinname = this._addSkin(this.skin.defaultSkin, name);
5561
o.requires.unshift(skinname);
5564
o.requires = this.filterRequires(o.requires) || [];
5566
if (!o.langPack && o.lang) {
5567
langs = YArray(o.lang);
5568
for (j = 0; j < langs.length; j++) {
5570
packName = this.getLangPackName(lang, name);
5571
smod = this.moduleInfo[packName];
5573
smod = this._addLangPack(lang, o, packName);
5580
sup = o.supersedes || [];
5584
if (subs.hasOwnProperty(i)) {
5587
s.path = s.path || _path(name, i, o.type);
5592
sup = sup.concat(s.supersedes);
5595
smod = this.addModule(s, i);
5598
if (smod.skinnable) {
5600
overrides = this.skin.overrides;
5601
if (overrides && overrides[i]) {
5602
for (j = 0; j < overrides[i].length; j++) {
5603
skinname = this._addSkin(overrides[i][j],
5608
skinname = this._addSkin(this.skin.defaultSkin,
5613
// looks like we are expected to work out the metadata
5614
// for the parent module language packs from what is
5615
// specified in the child modules.
5616
if (s.lang && s.lang.length) {
5618
langs = YArray(s.lang);
5619
for (j = 0; j < langs.length; j++) {
5621
packName = this.getLangPackName(lang, name);
5622
supName = this.getLangPackName(lang, i);
5623
smod = this.moduleInfo[packName];
5626
smod = this._addLangPack(lang, o, packName);
5629
flatSup = flatSup || YArray.hash(smod.supersedes);
5631
if (!(supName in flatSup)) {
5632
smod.supersedes.push(supName);
5635
o.lang = o.lang || [];
5637
flatLang = flatLang || YArray.hash(o.lang);
5639
if (!(lang in flatLang)) {
5643
// Y.log('pack ' + packName + ' should supersede ' + supName);
5644
// Add rollup file, need to add to supersedes list too
5647
packName = this.getLangPackName(ROOT_LANG, name);
5648
supName = this.getLangPackName(ROOT_LANG, i);
5650
smod = this.moduleInfo[packName];
5653
smod = this._addLangPack(lang, o, packName);
5656
if (!(supName in flatSup)) {
5657
smod.supersedes.push(supName);
5660
// Y.log('pack ' + packName + ' should supersede ' + supName);
5661
// Add rollup file, need to add to supersedes list too
5669
//o.supersedes = YObject.keys(YArray.hash(sup));
5670
o.supersedes = YArray.dedupe(sup);
5671
if (this.allowRollup) {
5672
o.rollup = (l < 4) ? l : Math.min(l - 1, 4);
5676
plugins = o.plugins;
5678
for (i in plugins) {
5679
if (plugins.hasOwnProperty(i)) {
5682
plug.path = plug.path || _path(name, i, o.type);
5683
plug.requires = plug.requires || [];
5684
plug.group = o.group;
5685
this.addModule(plug, i);
5687
this._addSkin(this.skin.defaultSkin, i, name);
5695
t = o.condition.trigger;
5696
if (YUI.Env.aliases[t]) {
5697
t = YUI.Env.aliases[t];
5699
if (!Y.Lang.isArray(t)) {
5703
for (i = 0; i < t.length; i++) {
5705
when = o.condition.when;
5706
conditions[trigger] = conditions[trigger] || {};
5707
conditions[trigger][name] = o.condition;
5708
// the 'when' attribute can be 'before', 'after', or 'instead'
5709
// the default is after.
5710
if (when && when != 'after') {
5711
if (when == 'instead') { // replace the trigger
5712
o.supersedes = o.supersedes || [];
5713
o.supersedes.push(trigger);
5714
} else { // before the trigger
5715
// the trigger requires the conditional mod,
5716
// so it should appear before the conditional
5717
// mod if we do not intersede.
5719
} else { // after the trigger
5720
o.after = o.after || [];
5721
o.after.push(trigger);
5727
o.supersedes = this.filterRequires(o.supersedes);
5731
o.after = this.filterRequires(o.after);
5732
o.after_map = YArray.hash(o.after);
5735
// this.dirty = true;
5738
ret = o.configFn(o);
5739
if (ret === false) {
5740
Y.log('Config function returned false for ' + name + ', skipping.', 'info', 'loader');
5741
delete this.moduleInfo[name];
5742
delete GLOBAL_ENV._renderedMods[name];
5746
//Add to global cache
5748
if (!GLOBAL_ENV._renderedMods) {
5749
GLOBAL_ENV._renderedMods = {};
5751
GLOBAL_ENV._renderedMods[name] = Y.merge(o);
5752
GLOBAL_ENV._conditions = conditions;
5759
* Add a requirement for one or more module
5761
* @param {string[] | string*} what the modules to load.
5763
require: function(what) {
5764
var a = (typeof what === 'string') ? YArray(arguments) : what;
5766
this.required = Y.merge(this.required, YArray.hash(this.filterRequires(a)));
5768
this._explodeRollups();
5771
* Grab all the items that were asked for, check to see if the Loader
5772
* meta-data contains a "use" array. If it doesm remove the asked item and replace it with
5773
* the content of the "use".
5774
* This will make asking for: "dd"
5775
* Actually ask for: "dd-ddm-base,dd-ddm,dd-ddm-drop,dd-drag,dd-proxy,dd-constrain,dd-drop,dd-scroll,dd-drop-plugin"
5777
* @method _explodeRollups
5779
_explodeRollups: function() {
5782
if (!self.allowRollup) {
5783
oeach(r, function(v, name) {
5784
m = self.getModule(name);
5787
YArray.each(m.use, function(v) {
5788
m = self.getModule(v);
5791
YArray.each(m.use, function(v) {
5805
* Explodes the required array to remove aliases and replace them with real modules
5806
* @method filterRequires
5807
* @param {Array} r The original requires array
5808
* @return {Array} The new array of exploded requirements
5810
filterRequires: function(r) {
5812
if (!Y.Lang.isArray(r)) {
5816
var c = [], i, mod, o, m;
5818
for (i = 0; i < r.length; i++) {
5819
mod = this.getModule(r[i]);
5820
if (mod && mod.use) {
5821
for (o = 0; o < mod.use.length; o++) {
5822
//Must walk the other modules in case a module is a rollup of rollups (datatype)
5823
m = this.getModule(mod.use[o]);
5825
c = Y.Array.dedupe([].concat(c, this.filterRequires(m.use)));
5839
* Returns an object containing properties for all modules required
5840
* in order to load the requested module
5841
* @method getRequires
5842
* @param {object} mod The module definition from moduleInfo.
5843
* @return {array} the expanded requirement list.
5845
getRequires: function(mod) {
5848
//console.log('returning no reqs for ' + mod.name);
5849
return NO_REQUIREMENTS;
5853
//console.log('returning requires for ' + mod.name, mod.requires);
5854
return mod.expanded || NO_REQUIREMENTS;
5857
//TODO add modue cache here out of scope..
5859
var i, m, j, add, packName, lang, testresults = this.testresults,
5860
name = mod.name, cond,
5861
adddef = ON_PAGE[name] && ON_PAGE[name].details,
5864
o, skinmod, skindef, skinpar, skinname,
5865
intl = mod.lang || mod.intl,
5866
info = this.moduleInfo,
5867
ftests = Y.Features && Y.Features.tests.load,
5870
// console.log(name);
5872
// pattern match leaves module stub that needs to be filled out
5873
if (mod.temp && adddef) {
5875
mod = this.addModule(adddef, name);
5876
mod.group = old_mod.group;
5877
mod.pkg = old_mod.pkg;
5878
delete mod.expanded;
5881
// console.log('cache: ' + mod.langCache + ' == ' + this.lang);
5883
// if (mod.expanded && (!mod.langCache || mod.langCache == this.lang)) {
5884
if (mod.expanded && (!this.lang || mod.langCache === this.lang)) {
5885
//Y.log('Already expanded ' + name + ', ' + mod.expanded);
5886
return mod.expanded;
5892
r = this.filterRequires(mod.requires);
5894
//If a module has a lang attribute, auto add the intl requirement.
5899
o = this.filterRequires(mod.optional);
5901
// Y.log("getRequires: " + name + " (dirty:" + this.dirty +
5902
// ", expanded:" + mod.expanded + ")");
5905
mod.langCache = this.lang;
5907
for (i = 0; i < r.length; i++) {
5908
//Y.log(name + ' requiring ' + r[i], 'info', 'loader');
5912
m = this.getModule(r[i]);
5914
add = this.getRequires(m);
5915
intl = intl || (m.expanded_map &&
5916
(INTL in m.expanded_map));
5917
for (j = 0; j < add.length; j++) {
5924
// get the requirements from superseded modules, if any
5925
r = this.filterRequires(mod.supersedes);
5927
for (i = 0; i < r.length; i++) {
5929
// if this module has submodules, the requirements list is
5930
// expanded to include the submodules. This is so we can
5931
// prevent dups when a submodule is already loaded and the
5932
// parent is requested.
5933
if (mod.submodules) {
5938
m = this.getModule(r[i]);
5941
add = this.getRequires(m);
5942
intl = intl || (m.expanded_map &&
5943
(INTL in m.expanded_map));
5944
for (j = 0; j < add.length; j++) {
5952
if (o && this.loadOptional) {
5953
for (i = 0; i < o.length; i++) {
5959
add = this.getRequires(m);
5960
intl = intl || (m.expanded_map &&
5961
(INTL in m.expanded_map));
5962
for (j = 0; j < add.length; j++) {
5970
cond = this.conditions[name];
5973
//Set the module to not parsed since we have conditionals and this could change the dependency tree.
5974
mod._parsed = false;
5975
if (testresults && ftests) {
5976
oeach(testresults, function(result, id) {
5977
var condmod = ftests[id].name;
5978
if (!hash[condmod] && ftests[id].trigger == name) {
5979
if (result && ftests[id]) {
5980
hash[condmod] = true;
5986
oeach(cond, function(def, condmod) {
5987
if (!hash[condmod]) {
5988
//first see if they've specfied a ua check
5989
//then see if they've got a test fn & if it returns true
5990
//otherwise just having a condition block is enough
5991
var go = def && ((!def.ua && !def.test) || (def.ua && Y.UA[def.ua]) ||
5992
(def.test && def.test(Y, r)));
5995
hash[condmod] = true;
5997
m = this.getModule(condmod);
5999
add = this.getRequires(m);
6000
for (j = 0; j < add.length; j++) {
6011
// Create skin modules
6012
if (mod.skinnable) {
6013
skindef = this.skin.overrides;
6014
oeach(YUI.Env.aliases, function(o, n) {
6015
if (Y.Array.indexOf(o, name) > -1) {
6019
if (skindef && (skindef[name] || (skinpar && skindef[skinpar]))) {
6021
if (skindef[skinpar]) {
6024
for (i = 0; i < skindef[skinname].length; i++) {
6025
skinmod = this._addSkin(skindef[skinname][i], name);
6026
if (!this.isCSSLoaded(skinmod, this._boot)) {
6031
skinmod = this._addSkin(this.skin.defaultSkin, name);
6032
if (!this.isCSSLoaded(skinmod, this._boot)) {
6038
mod._parsed = false;
6042
if (mod.lang && !mod.langPack && Y.Intl) {
6043
lang = Y.Intl.lookupBestLang(this.lang || ROOT_LANG, mod.lang);
6044
//Y.log('Best lang: ' + lang + ', this.lang: ' + this.lang + ', mod.lang: ' + mod.lang);
6045
packName = this.getLangPackName(lang, name);
6047
d.unshift(packName);
6053
mod.expanded_map = YArray.hash(d);
6055
mod.expanded = YObject.keys(mod.expanded_map);
6057
return mod.expanded;
6060
* Check to see if named css module is already loaded on the page
6061
* @method isCSSLoaded
6062
* @param {String} name The name of the css file
6065
isCSSLoaded: function(name, skip) {
6066
//TODO - Make this call a batching call with name being an array
6067
if (!name || !YUI.Env.cssStampEl || (!skip && this.ignoreRegistered)) {
6068
Y.log('isCSSLoaded was skipped for ' + name, 'warn', 'loader');
6072
var el = YUI.Env.cssStampEl,
6074
style = el.currentStyle; //IE
6076
//Add the classname to the element
6077
el.className = name;
6080
style = Y.config.doc.defaultView.getComputedStyle(el, null);
6083
if (style && style['display'] === 'none') {
6087
Y.log('Has Skin? ' + name + ' : ' + ret, 'info', 'loader');
6089
el.className = ''; //Reset the classname to ''
6094
* Returns a hash of module names the supplied module satisfies.
6095
* @method getProvides
6096
* @param {string} name The name of the module.
6097
* @return {object} what this module provides.
6099
getProvides: function(name) {
6100
var m = this.getModule(name), o, s;
6101
// supmap = this.provides;
6107
if (m && !m.provides) {
6112
YArray.each(s, function(v) {
6113
Y.mix(o, this.getProvides(v));
6126
* Calculates the dependency tree, the result is stored in the sorted
6129
* @param {object} o optional options object.
6130
* @param {string} type optional argument to prune modules.
6132
calculate: function(o, type) {
6133
if (o || type || this.dirty) {
6145
if (this.allowRollup) {
6148
this._explodeRollups();
6155
* Creates a "psuedo" package for languages provided in the lang array
6156
* @method _addLangPack
6158
* @param {String} lang The language to create
6159
* @param {Object} m The module definition to create the language pack around
6160
* @param {String} packName The name of the package (e.g: lang/datatype-date-en-US)
6161
* @return {Object} The module definition
6163
_addLangPack: function(lang, m, packName) {
6166
existing = this.moduleInfo[packName];
6170
packPath = _path((m.pkg || name), packName, JS, true);
6182
conf.configFn = m.configFn;
6185
this.addModule(conf, packName);
6188
Y.Env.lang = Y.Env.lang || {};
6189
Y.Env.lang[lang] = Y.Env.lang[lang] || {};
6190
Y.Env.lang[lang][name] = true;
6194
return this.moduleInfo[packName];
6198
* Investigates the current YUI configuration on the page. By default,
6199
* modules already detected will not be loaded again unless a force
6200
* option is encountered. Called by calculate()
6204
_setup: function() {
6205
var info = this.moduleInfo, name, i, j, m, l,
6208
for (name in info) {
6209
if (info.hasOwnProperty(name)) {
6214
//m.requires = YObject.keys(YArray.hash(m.requires));
6215
m.requires = YArray.dedupe(m.requires);
6217
// Create lang pack modules
6218
if (m.lang && m.lang.length) {
6219
// Setup root package if the module has lang defined,
6220
// it needs to provide a root language pack
6221
packName = this.getLangPackName(ROOT_LANG, name);
6222
this._addLangPack(null, m, packName);
6230
//l = Y.merge(this.inserted);
6233
// available modules
6234
if (!this.ignoreRegistered) {
6235
Y.mix(l, GLOBAL_ENV.mods);
6238
// add the ignore list to the list of loaded packages
6240
Y.mix(l, YArray.hash(this.ignore));
6243
// expand the list to include superseded modules
6245
if (l.hasOwnProperty(j)) {
6246
Y.mix(l, this.getProvides(j));
6250
// remove modules on the force list from the loaded list
6252
for (i = 0; i < this.force.length; i++) {
6253
if (this.force[i] in l) {
6254
delete l[this.force[i]];
6259
Y.mix(this.loaded, l);
6265
* Builds a module name for a language pack
6266
* @method getLangPackName
6267
* @param {string} lang the language code.
6268
* @param {string} mname the module to build it for.
6269
* @return {string} the language pack module name.
6271
getLangPackName: function(lang, mname) {
6272
return ('lang/' + mname + ((lang) ? '_' + lang : ''));
6275
* Inspects the required modules list looking for additional
6276
* dependencies. Expands the required list to include all
6277
* required modules. Called by calculate()
6281
_explode: function() {
6282
//TODO Move done out of scope
6283
var r = this.required, m, reqs, done = {},
6286
// the setup phase is over, all modules have been created
6289
self._explodeRollups();
6292
oeach(r, function(v, name) {
6295
m = self.getModule(name);
6297
var expound = m.expound;
6300
r[expound] = self.getModule(expound);
6301
reqs = self.getRequires(r[expound]);
6302
Y.mix(r, YArray.hash(reqs));
6305
reqs = self.getRequires(m);
6306
Y.mix(r, YArray.hash(reqs));
6311
// Y.log('After explode: ' + YObject.keys(r));
6314
* Get's the loader meta data for the requested module
6316
* @param {String} mname The module name to get
6317
* @return {Object} The module metadata
6319
getModule: function(mname) {
6320
//TODO: Remove name check - it's a quick hack to fix pattern WIP
6325
var p, found, pname,
6326
m = this.moduleInfo[mname],
6327
patterns = this.patterns;
6329
// check the patterns library to see if we should automatically add
6330
// the module with defaults
6332
// Y.log('testing patterns ' + YObject.keys(patterns));
6333
for (pname in patterns) {
6334
if (patterns.hasOwnProperty(pname)) {
6335
// Y.log('testing pattern ' + i);
6336
p = patterns[pname];
6338
//There is no test method, create a default one that tests
6339
// the pattern against the mod name
6341
p.test = function(mname, pname) {
6342
return (mname.indexOf(pname) > -1);
6346
if (p.test(mname, pname)) {
6347
// use the metadata supplied for the pattern
6348
// as the module definition.
6357
// Y.log('executing pattern action: ' + pname);
6358
p.action.call(this, mname, pname);
6360
Y.log('Undefined module: ' + mname + ', matched a pattern: ' +
6361
pname, 'info', 'loader');
6362
// ext true or false?
6363
m = this.addModule(Y.merge(found), mname);
6372
// impl in rollup submodule
6373
_rollup: function() { },
6376
* Remove superceded modules and loaded modules. Called by
6377
* calculate() after we have the mega list of all dependencies
6379
* @return {object} the reduced dependency hash.
6382
_reduce: function(r) {
6384
r = r || this.required;
6386
var i, j, s, m, type = this.loadType,
6387
ignore = this.ignore ? YArray.hash(this.ignore) : false;
6390
if (r.hasOwnProperty(i)) {
6391
m = this.getModule(i);
6392
// remove if already loaded
6393
if (((this.loaded[i] || ON_PAGE[i]) &&
6394
!this.forceMap[i] && !this.ignoreRegistered) ||
6395
(type && m && m.type != type)) {
6398
if (ignore && ignore[i]) {
6401
// remove anything this module supersedes
6402
s = m && m.supersedes;
6404
for (j = 0; j < s.length; j++) {
6416
* Handles the queue when a module has been loaded for all cases
6419
* @param {String} msg The message from Loader
6420
* @param {Boolean} success A boolean denoting success or failure
6422
_finish: function(msg, success) {
6423
Y.log('loader finishing: ' + msg + ', ' + Y.id + ', ' +
6424
this.data, 'info', 'loader');
6426
_queue.running = false;
6428
var onEnd = this.onEnd;
6430
onEnd.call(this.context, {
6439
* The default Loader onSuccess handler, calls this.onSuccess with a payload
6440
* @method _onSuccess
6443
_onSuccess: function() {
6444
var self = this, skipped = Y.merge(self.skipped), fn,
6445
failed = [], rreg = self.requireRegistration,
6448
oeach(skipped, function(k) {
6449
delete self.inserted[k];
6454
oeach(self.inserted, function(v, k) {
6455
var mod = self.getModule(k);
6456
if (mod && rreg && mod.type == JS && !(k in YUI.Env.mods)) {
6459
Y.mix(self.loaded, self.getProvides(k));
6463
fn = self.onSuccess;
6464
msg = (failed.length) ? 'notregistered' : 'success';
6465
success = !(failed.length);
6467
fn.call(self.context, {
6475
self._finish(msg, success);
6478
* The default Loader onProgress handler, calls this.onProgress with a payload
6479
* @method _onProgress
6482
_onProgress: function(e) {
6484
if (self.onProgress) {
6485
self.onProgress.call(self.context, {
6492
* The default Loader onFailure handler, calls this.onFailure with a payload
6493
* @method _onFailure
6496
_onFailure: function(o) {
6497
var f = this.onFailure, msg = [], i = 0, len = o.errors.length;
6499
for (i; i < len; i++) {
6500
msg.push(o.errors[i].error);
6503
msg = msg.join(',');
6505
Y.log('load error: ' + msg + ', ' + Y.id, 'error', 'loader');
6508
f.call(this.context, {
6515
this._finish(msg, false);
6520
* The default Loader onTimeout handler, calls this.onTimeout with a payload
6521
* @method _onTimeout
6524
_onTimeout: function() {
6525
Y.log('loader timeout: ' + Y.id, 'error', 'loader');
6526
var f = this.onTimeout;
6528
f.call(this.context, {
6537
* Sorts the dependency tree. The last step of calculate()
6543
// create an indexed list
6544
var s = YObject.keys(this.required),
6545
// loaded = this.loaded,
6546
//TODO Move this out of scope
6548
p = 0, l, a, b, j, k, moved, doneKey;
6550
// keep going until we make a pass without moving anything
6556
// start the loop after items that are already sorted
6557
for (j = p; j < l; j++) {
6559
// check the next module on the list to see if its
6560
// dependencies have been met
6563
// check everything below current item and move if we
6564
// find a requirement for the current item
6565
for (k = j + 1; k < l; k++) {
6568
if (!done[doneKey] && this._requires(a, s[k])) {
6570
// extract the dependency so we can move it up
6573
// insert the dependency above the item that
6575
s.splice(j, 0, b[0]);
6577
// only swap two dependencies once to short circut
6578
// circular dependencies
6579
done[doneKey] = true;
6588
// jump out of loop if we moved something
6591
// this item is sorted, move our pointer and keep going
6597
// when we make it here and moved is false, we are
6609
* Handles the actual insertion of script/link tags
6612
* @param {Object} source The YUI instance the request came from
6613
* @param {Object} o The metadata to include
6614
* @param {String} type JS or CSS
6615
* @param {Boolean} [skipcalc=false] Do a Loader.calculate on the meta
6617
_insert: function(source, o, type, skipcalc) {
6619
Y.log('private _insert() ' + (type || '') + ', ' + Y.id, "info", "loader");
6621
// restore the state at the time of the request
6623
this._config(source);
6626
// build the dependency list
6627
// don't include type so we can process CSS and script in
6628
// one pass when the type is not specified.
6633
var modules = this.resolve(),
6634
self = this, comp = 0, actions = 0;
6637
//Filter out the opposite type and reset the array so the checks later work
6638
modules[((type === JS) ? CSS : JS)] = [];
6640
if (modules.js.length) {
6643
if (modules.css.length) {
6647
//console.log('Resolved Modules: ', modules);
6649
var complete = function(d) {
6651
var errs = {}, i = 0, u = '', fn;
6653
if (d && d.errors) {
6654
for (i = 0; i < d.errors.length; i++) {
6655
if (d.errors[i].request) {
6656
u = d.errors[i].request.url;
6664
if (d && d.data && d.data.length && (d.type === 'success')) {
6665
for (i = 0; i < d.data.length; i++) {
6666
self.inserted[d.data[i].name] = true;
6670
if (actions === comp) {
6671
self._loading = null;
6672
Y.log('Loader actions complete!', 'info', 'loader');
6674
Y.log('Firing final Loader callback!', 'info', 'loader');
6682
this._loading = true;
6684
if (!modules.js.length && !modules.css.length) {
6685
Y.log('No modules resolved..', 'warn', 'loader');
6694
if (modules.css.length) { //Load CSS first
6695
Y.log('Loading CSS modules', 'info', 'loader');
6696
Y.Get.css(modules.css, {
6697
data: modules.cssMods,
6698
attributes: self.cssAttributes,
6699
insertBefore: self.insertBefore,
6700
charset: self.charset,
6701
timeout: self.timeout,
6703
onProgress: function(e) {
6704
self._onProgress.call(self, e);
6706
onTimeout: function(d) {
6707
self._onTimeout.call(self, d);
6709
onSuccess: function(d) {
6711
d.fn = self._onSuccess;
6712
complete.call(self, d);
6714
onFailure: function(d) {
6716
d.fn = self._onFailure;
6717
complete.call(self, d);
6722
if (modules.js.length) {
6723
Y.log('Loading JS modules', 'info', 'loader');
6724
Y.Get.js(modules.js, {
6725
data: modules.jsMods,
6726
insertBefore: self.insertBefore,
6727
attributes: self.jsAttributes,
6728
charset: self.charset,
6729
timeout: self.timeout,
6733
onProgress: function(e) {
6734
self._onProgress.call(self, e);
6736
onTimeout: function(d) {
6737
self._onTimeout.call(self, d);
6739
onSuccess: function(d) {
6741
d.fn = self._onSuccess;
6742
complete.call(self, d);
6744
onFailure: function(d) {
6746
d.fn = self._onFailure;
6747
complete.call(self, d);
6753
* Once a loader operation is completely finished, process any additional queued items.
6757
_continue: function() {
6758
if (!(_queue.running) && _queue.size() > 0) {
6759
_queue.running = true;
6765
* inserts the requested modules and their dependencies.
6766
* <code>type</code> can be "js" or "css". Both script and
6767
* css are inserted if type is not provided.
6769
* @param {object} o optional options object.
6770
* @param {string} type the type of dependency to insert.
6772
insert: function(o, type, skipsort) {
6773
Y.log('public insert() ' + (type || '') + ', ' +
6774
Y.Object.keys(this.required), "info", "loader");
6775
var self = this, copy = Y.merge(this);
6776
delete copy.require;
6778
_queue.add(function() {
6779
self._insert(copy, o, type, skipsort);
6785
* Executed every time a module is loaded, and if we are in a load
6786
* cycle, we attempt to load the next script. Public so that it
6787
* is possible to call this if using a method other than
6788
* Y.register to determine when scripts are fully loaded
6791
* @param {string} mname optional the name of the module that has
6792
* been loaded (which is usually why it is time to load the next
6795
loadNext: function(mname) {
6796
Y.log('loadNext was called..', 'error', 'loader');
6801
* Apply filter defined for this instance to a url/path
6803
* @param {string} u the string to filter.
6804
* @param {string} name the name of the module, if we are processing
6805
* a single module as opposed to a combined url.
6806
* @return {string} the filtered string.
6809
_filter: function(u, name, group) {
6810
var f = this.filter,
6811
hasFilter = name && (name in this.filters),
6812
modFilter = hasFilter && this.filters[name],
6813
groupName = group || (this.moduleInfo[name] ? this.moduleInfo[name].group : null);
6815
if (groupName && this.groups[groupName] && this.groups[groupName].filter) {
6816
modFilter = this.groups[groupName].filter;
6822
f = (L.isString(modFilter)) ?
6823
this.FILTER_DEFS[modFilter.toUpperCase()] || null :
6827
u = u.replace(new RegExp(f.searchExp, 'g'), f.replaceStr);
6835
* Generates the full url for a module
6837
* @param {string} path the path fragment.
6838
* @param {String} name The name of the module
6839
* @param {String} [base=self.base] The base url to use
6840
* @return {string} the full url.
6843
_url: function(path, name, base) {
6844
return this._filter((base || this.base || '') + path, name);
6847
* Returns an Object hash of file arrays built from `loader.sorted` or from an arbitrary list of sorted modules.
6849
* @param {Boolean} [calc=false] Perform a loader.calculate() before anything else
6850
* @param {Array} [s=loader.sorted] An override for the loader.sorted array
6851
* @return {Object} Object hash (js and css) of two arrays of file lists
6852
* @example This method can be used as an off-line dep calculator
6855
* var loader = new Y.Loader({
6860
* require: ['node', 'dd', 'console']
6862
* var out = loader.resolve(true);
6865
resolve: function(calc, s) {
6867
var len, i, m, url, fn, msg, attr, group, groupName, j, frag,
6868
comboSource, comboSources, mods, comboBase,
6869
base, urls, u = [], tmpBase, baseLen, resCombos = {},
6870
self = this, comboSep, maxURLLength, singles = [],
6871
inserted = (self.ignoreRegistered) ? {} : self.inserted,
6872
resolved = { js: [], jsMods: [], css: [], cssMods: [] },
6873
type = self.loadType || 'js';
6878
s = s || self.sorted;
6880
var addSingle = function(m) {
6883
group = (m.group && self.groups[m.group]) || NOT_FOUND;
6885
//Always assume it's async
6886
if (group.async === false) {
6887
m.async = group.async;
6890
url = (m.fullpath) ? self._filter(m.fullpath, s[i]) :
6891
self._url(m.path, s[i], group.base || m.base);
6893
if (m.attributes || m.async === false) {
6899
url.attributes = m.attributes
6902
resolved[m.type].push(url);
6903
resolved[m.type + 'Mods'].push(m);
6905
Y.log('Undefined Module', 'warn', 'loader');
6912
// the default combo base
6913
comboBase = self.comboBase;
6919
for (i = 0; i < len; i++) {
6920
comboSource = comboBase;
6921
m = self.getModule(s[i]);
6922
groupName = m && m.group;
6923
group = self.groups[groupName];
6924
if (groupName && group) {
6926
if (!group.combine || m.fullpath) {
6927
//This is not a combo module, skip it and load it singly later.
6928
//singles.push(s[i]);
6933
if (group.comboBase) {
6934
comboSource = group.comboBase;
6937
if ("root" in group && L.isValue(group.root)) {
6938
m.root = group.root;
6940
m.comboSep = group.comboSep || self.comboSep;
6941
m.maxURLLength = group.maxURLLength || self.maxURLLength;
6943
if (!self.combine) {
6944
//This is not a combo module, skip it and load it singly later.
6945
//singles.push(s[i]);
6951
comboSources[comboSource] = comboSources[comboSource] || [];
6952
comboSources[comboSource].push(m);
6955
for (j in comboSources) {
6956
if (comboSources.hasOwnProperty(j)) {
6957
resCombos[j] = resCombos[j] || { js: [], jsMods: [], css: [], cssMods: [] };
6959
mods = comboSources[j];
6963
for (i = 0; i < len; i++) {
6964
if (inserted[mods[i]]) {
6968
// Do not try to combine non-yui JS unless combo def
6970
if (m && (m.combine || !m.ext)) {
6971
resCombos[j].comboSep = m.comboSep;
6972
resCombos[j].group = m.group;
6973
resCombos[j].maxURLLength = m.maxURLLength;
6974
frag = ((L.isValue(m.root)) ? m.root : self.root) + (m.path || m.fullpath);
6975
frag = self._filter(frag, m.name);
6976
resCombos[j][m.type].push(frag);
6977
resCombos[j][m.type + 'Mods'].push(m);
6979
//Add them to the next process..
6981
//singles.push(mods[i].name);
6992
for (j in resCombos) {
6994
comboSep = resCombos[base].comboSep || self.comboSep;
6995
maxURLLength = resCombos[base].maxURLLength || self.maxURLLength;
6996
Y.log('Using maxURLLength of ' + maxURLLength, 'info', 'loader');
6997
for (type in resCombos[base]) {
6998
if (type === JS || type === CSS) {
6999
urls = resCombos[base][type];
7000
mods = resCombos[base][type + 'Mods'];
7002
tmpBase = base + urls.join(comboSep);
7003
baseLen = tmpBase.length;
7004
if (maxURLLength <= base.length) {
7005
Y.log('maxURLLength (' + maxURLLength + ') is lower than the comboBase length (' + base.length + '), resetting to default (' + MAX_URL_LENGTH + ')', 'error', 'loader');
7006
maxURLLength = MAX_URL_LENGTH;
7010
if (baseLen > maxURLLength) {
7011
Y.log('Exceeded maxURLLength (' + maxURLLength + ') for ' + type + ', splitting', 'info', 'loader');
7013
for (s = 0; s < len; s++) {
7015
tmpBase = base + u.join(comboSep);
7017
if (tmpBase.length > maxURLLength) {
7019
tmpBase = base + u.join(comboSep)
7020
resolved[type].push(self._filter(tmpBase, null, resCombos[base].group));
7028
tmpBase = base + u.join(comboSep);
7029
resolved[type].push(self._filter(tmpBase, null, resCombos[base].group));
7032
resolved[type].push(self._filter(tmpBase, null, resCombos[base].group));
7035
resolved[type + 'Mods'] = resolved[type + 'Mods'].concat(mods);
7045
Shortcut to calculate, resolve and load all modules.
7047
var loader = new Y.Loader({
7048
ignoreRegistered: true,
7056
loader.load(function() {
7057
console.log('All modules have loaded..');
7062
@param {Callback} cb Executed after all load operations are complete
7064
load: function(cb) {
7066
Y.log('No callback supplied to load()', 'error', 'loader');
7070
out = self.resolve(true);
7074
self.onEnd = function() {
7075
cb.apply(self.context || self, arguments);
7084
}, '3.5.0' ,{requires:['get', 'features']});
7085
YUI.add('loader-rollup', function(Y) {
7088
* Optional automatic rollup logic for reducing http connections
7089
* when not using a combo service.
7095
* Look for rollup packages to determine if all of the modules a
7096
* rollup supersedes are required. If so, include the rollup to
7097
* help reduce the total number of connections required. Called
7098
* by calculate(). This is an optional feature, and requires the
7099
* appropriate submodule to function.
7104
Y.Loader.prototype._rollup = function() {
7105
var i, j, m, s, r = this.required, roll,
7106
info = this.moduleInfo, rolled, c, smod;
7108
// find and cache rollup modules
7109
if (this.dirty || !this.rollups) {
7112
if (info.hasOwnProperty(i)) {
7113
m = this.getModule(i);
7114
// if (m && m.rollup && m.supersedes) {
7115
if (m && m.rollup) {
7116
this.rollups[i] = m;
7122
// make as many passes as needed to pick up rollup rollups
7126
// go through the rollup candidates
7127
for (i in this.rollups) {
7128
if (this.rollups.hasOwnProperty(i)) {
7129
// there can be only one, unless forced
7130
if (!r[i] && ((!this.loaded[i]) || this.forceMap[i])) {
7131
m = this.getModule(i);
7132
s = m.supersedes || [];
7135
// @TODO remove continue
7142
// check the threshold
7143
for (j = 0; j < s.length; j++) {
7146
// if the superseded module is loaded, we can't
7147
// load the rollup unless it has been forced.
7148
if (this.loaded[s[j]] && !this.forceMap[s[j]]) {
7151
// increment the counter if this module is required.
7152
// if we are beyond the rollup threshold, we will
7153
// use the rollup module
7154
} else if (r[s[j]] && m.type == smod.type) {
7156
// Y.log("adding to thresh: " + c + ", " + s[j]);
7157
roll = (c >= m.rollup);
7159
// Y.log("over thresh " + c + ", " + s[j]);
7166
// Y.log("adding rollup: " + i);
7171
// expand the rollup's dependencies
7172
this.getRequires(m);
7178
// if we made it here w/o rolling up something, we are done
7186
}, '3.5.0' ,{requires:['loader-base']});
7187
YUI.add('loader-yui3', function(Y) {
7189
/* This file is auto-generated by src/loader/scripts/meta_join.py */
7192
* YUI 3 module metadata
7196
YUI.Env[Y.version].modules = YUI.Env[Y.version].modules || {
7235
"anim-node-plugin": {
7246
"anim-shape-transform": {
7277
"app-transitions": {
7282
"app-transitions-css": {
7285
"app-transitions-native": {
7287
"name": "app-transitions-native",
7288
"test": function (Y) {
7289
var doc = Y.config.doc,
7290
node = doc ? doc.documentElement : null;
7292
if (node && node.style) {
7293
return ('MozTransition' in node.style || 'WebkitTransition' in node.style);
7298
"trigger": "app-transitions"
7302
"app-transitions-css",
7327
"arraylist-filter": {
7355
"attribute-complex": {
7365
"attribute-events": {
7370
"attribute-extras": {
7377
"autocomplete-base",
7378
"autocomplete-sources",
7379
"autocomplete-list",
7380
"autocomplete-plugin"
7383
"autocomplete-base": {
7385
"autocomplete-sources"
7391
"event-valuechange",
7395
"autocomplete-filters": {
7401
"autocomplete-filters-accentfold": {
7408
"autocomplete-highlighters": {
7414
"autocomplete-highlighters-accentfold": {
7417
"highlight-accentfold"
7420
"autocomplete-list": {
7422
"autocomplete-sources"
7428
"autocomplete-base",
7435
"widget-position-align"
7439
"autocomplete-list-keys": {
7441
"name": "autocomplete-list-keys",
7442
"test": function (Y) {
7443
// Only add keyboard support to autocomplete-list if this doesn't appear to
7444
// be an iOS or Android-based mobile device.
7446
// There's currently no feasible way to actually detect whether a device has
7447
// a hardware keyboard, so this sniff will have to do. It can easily be
7448
// overridden by manually loading the autocomplete-list-keys module.
7450
// Worth noting: even though iOS supports bluetooth keyboards, Mobile Safari
7451
// doesn't fire the keyboard events used by AutoCompleteList, so there's
7452
// no point loading the -keys module even when a bluetooth keyboard may be
7454
return !(Y.UA.ios || Y.UA.android);
7456
"trigger": "autocomplete-list"
7459
"autocomplete-list",
7463
"autocomplete-plugin": {
7465
"autocomplete-list",
7469
"autocomplete-sources": {
7506
"base-pluginhost": {
7596
"datatype-date-math",
7601
"calendarnavigator": {
7635
"classnamemanager": {
7667
"console-filters": {
7684
"createlink-base": {
7700
"cssbase-context": {
7717
"cssfonts-context": {
7747
"cssreset-context": {
7759
"dataschema-array": {
7764
"dataschema-base": {
7769
"dataschema-json": {
7775
"dataschema-text": {
7790
"datasource-function",
7792
"datasource-jsonschema",
7793
"datasource-xmlschema",
7794
"datasource-arrayschema",
7795
"datasource-textschema",
7796
"datasource-polling"
7799
"datasource-arrayschema": {
7806
"datasource-cache": {
7813
"datasource-function": {
7830
"datasource-jsonschema": {
7837
"datasource-local": {
7842
"datasource-polling": {
7847
"datasource-textschema": {
7854
"datasource-xmlschema": {
7867
"datatable-column-widths",
7868
"datatable-message",
7869
"datatable-mutable",
7871
"datatable-datasource"
7884
"datatable-base-deprecated": {
7900
"datatable-column-widths": {
7909
"node-event-delegate"
7912
"datatable-datasource": {
7919
"datatable-datasource-deprecated": {
7921
"datatable-base-deprecated",
7926
"datatable-deprecated": {
7928
"datatable-base-deprecated",
7929
"datatable-datasource-deprecated",
7930
"datatable-sort-deprecated",
7931
"datatable-scroll-deprecated"
7941
"datatable-message": {
7950
"datatable-mutable": {
7955
"datatable-scroll": {
7958
"datatable-column-widths",
7963
"datatable-scroll-deprecated": {
7965
"datatable-base-deprecated",
7978
"datatable-sort-deprecated": {
7983
"datatable-base-deprecated",
7997
"datatype-date-format"
8000
"datatype-date-parse",
8001
"datatype-date-format"
8004
"datatype-date-format": {
8088
"datatype-date-math": {
8093
"datatype-date-parse": {},
8094
"datatype-number": {
8096
"datatype-number-parse",
8097
"datatype-number-format"
8100
"datatype-number-format": {},
8101
"datatype-number-parse": {},
8104
"datatype-xml-parse",
8105
"datatype-xml-format"
8108
"datatype-xml-format": {},
8109
"datatype-xml-parse": {},
8172
"name": "dd-gestures",
8173
"test": function(Y) {
8174
return ((Y.config.win && ("ontouchstart" in Y.config.win)) && !(Y.UA.chrome && Y.UA.chrome < 6));
8176
"trigger": "dd-drag"
8258
"name": "dom-style-ie",
8259
"test": function (Y) {
8261
var testFeature = Y.Features.test,
8262
addFeature = Y.Features.add,
8263
WINDOW = Y.config.win,
8264
DOCUMENT = Y.config.doc,
8265
DOCUMENT_ELEMENT = 'documentElement',
8268
addFeature('style', 'computedStyle', {
8270
return WINDOW && 'getComputedStyle' in WINDOW;
8274
addFeature('style', 'opacity', {
8276
return DOCUMENT && 'opacity' in DOCUMENT[DOCUMENT_ELEMENT].style;
8280
ret = (!testFeature('style', 'opacity') &&
8281
!testFeature('style', 'computedStyle'));
8285
"trigger": "dom-style"
8338
"editor-para-base": {
8345
"name": "editor-para-ie",
8346
"trigger": "editor-para",
8354
"editor-selection": {
8403
"name": "event-base-ie",
8404
"test": function(Y) {
8405
var imp = Y.config.doc && Y.config.doc.implementation;
8406
return (imp && (!imp.hasFeature('Events', '2.0')));
8408
"trigger": "node-base"
8414
"event-contextmenu": {
8422
"event-custom-base",
8423
"event-custom-complex"
8426
"event-custom-base": {
8431
"event-custom-complex": {
8469
"event-mouseenter": {
8474
"event-mousewheel": {
8502
"event-synthetic": {
8505
"event-custom-complex"
8513
"event-valuechange": {
8567
"graphics-canvas": {
8569
"name": "graphics-canvas",
8570
"test": function(Y) {
8571
var DOCUMENT = Y.config.doc,
8572
useCanvas = Y.config.defaultGraphicEngine && Y.config.defaultGraphicEngine == "canvas",
8573
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
8574
svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
8575
return (!svg || useCanvas) && (canvas && canvas.getContext && canvas.getContext("2d"));
8577
"trigger": "graphics"
8583
"graphics-canvas-default": {
8585
"name": "graphics-canvas-default",
8586
"test": function(Y) {
8587
var DOCUMENT = Y.config.doc,
8588
useCanvas = Y.config.defaultGraphicEngine && Y.config.defaultGraphicEngine == "canvas",
8589
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
8590
svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
8591
return (!svg || useCanvas) && (canvas && canvas.getContext && canvas.getContext("2d"));
8593
"trigger": "graphics"
8598
"name": "graphics-svg",
8599
"test": function(Y) {
8600
var DOCUMENT = Y.config.doc,
8601
useSVG = !Y.config.defaultGraphicEngine || Y.config.defaultGraphicEngine != "canvas",
8602
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
8603
svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
8605
return svg && (useSVG || !canvas);
8607
"trigger": "graphics"
8613
"graphics-svg-default": {
8615
"name": "graphics-svg-default",
8616
"test": function(Y) {
8617
var DOCUMENT = Y.config.doc,
8618
useSVG = !Y.config.defaultGraphicEngine || Y.config.defaultGraphicEngine != "canvas",
8619
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
8620
svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
8622
return svg && (useSVG || !canvas);
8624
"trigger": "graphics"
8629
"name": "graphics-vml",
8630
"test": function(Y) {
8631
var DOCUMENT = Y.config.doc,
8632
canvas = DOCUMENT && DOCUMENT.createElement("canvas");
8633
return (DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d")));
8635
"trigger": "graphics"
8641
"graphics-vml-default": {
8643
"name": "graphics-vml-default",
8644
"test": function(Y) {
8645
var DOCUMENT = Y.config.doc,
8646
canvas = DOCUMENT && DOCUMENT.createElement("canvas");
8647
return (DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d")));
8649
"trigger": "graphics"
8654
"handlebars-compiler"
8657
"handlebars-base": {
8662
"handlebars-compiler": {
8670
"highlight-accentfold"
8673
"highlight-accentfold": {
8697
"event-custom-complex"
8710
"history-hash-ie": {
8712
"name": "history-hash-ie",
8713
"test": function (Y) {
8714
var docMode = Y.config.doc && Y.config.doc.documentMode;
8716
return Y.UA.ie && (!('onhashchange' in Y.config.win) ||
8717
!docMode || docMode < 8);
8719
"trigger": "history-hash"
8765
"event-custom-base",
8766
"querystring-stringify-simple"
8777
"name": "io-nodejs",
8778
"trigger": "io-base",
8791
"io-upload-iframe": {
8800
"datatype-xml-parse"
8879
"node-event-delegate",
8898
"node-deprecated": {
8903
"node-event-delegate": {
8909
"node-event-html5": {
8914
"node-event-simulate": {
8929
"node-focusmanager": {
8934
"node-event-simulate",
8954
"node-pluginhost": {
8982
"widget-position-align",
8984
"widget-position-constrain"
8995
"widget-position-align",
8996
"widget-position-constrain",
9016
"node-event-delegate",
9038
"pluginhost-base": {
9043
"pluginhost-config": {
9055
"querystring-parse",
9056
"querystring-stringify"
9059
"querystring-parse": {
9065
"querystring-parse-simple": {
9070
"querystring-stringify": {
9075
"querystring-stringify-simple": {
9088
"slider-value-range",
9106
"recordset-filter": {
9113
"recordset-indexer": {
9146
"resize-constrain": {
9186
"scrollview-scrollbars"
9189
"scrollview-base": {
9198
"scrollview-base-ie": {
9200
"name": "scrollview-base-ie",
9201
"trigger": "scrollview-base",
9208
"scrollview-list": {
9215
"scrollview-paginator": {
9220
"scrollview-scrollbars": {
9235
"name": "selector-css2",
9236
"test": function (Y) {
9237
var DOCUMENT = Y.config.doc,
9238
ret = DOCUMENT && !('querySelectorAll' in DOCUMENT);
9242
"trigger": "selector"
9254
"selector-native": {
9268
"slider-value-range",
9282
"slider-value-range": {
9294
"sortable-scroll": {
9339
"node-event-delegate",
9371
"text-accentfold": {
9374
"text-data-accentfold"
9377
"text-data-accentfold": {
9382
"text-data-wordbreak": {
9390
"text-data-wordbreak"
9398
"transition-timer": {
9400
"name": "transition-timer",
9401
"test": function (Y) {
9402
var DOCUMENT = Y.config.doc,
9403
node = (DOCUMENT) ? DOCUMENT.documentElement: null,
9406
if (node && node.style) {
9407
ret = !('MozTransition' in node.style || 'WebkitTransition' in node.style);
9412
"trigger": "transition"
9424
"uploader-deprecated": {
9448
"node-event-simulate",
9462
"node-event-delegate"
9473
"widget-htmlparser",
9485
"widget-autohide": {
9507
"name": "widget-base-ie",
9508
"trigger": "widget-base",
9528
"widget-htmlparser": {
9538
"widget-modality": {
9553
"widget-position": {
9560
"widget-position-align": {
9565
"widget-position-constrain": {
9588
"widget-uievents": {
9590
"node-event-delegate",
9619
YUI.Env[Y.version].md5 = 'f5a3bc9bda2441a3b15fb52c567fc1f7';
9622
}, '3.5.0' ,{requires:['loader-base']});
9625
YUI.add('yui', function(Y){}, '3.5.0' ,{use:['yui-base','get','features','intl-base','yui-log','yui-log-nodejs','yui-later','loader-base', 'loader-rollup', 'loader-yui3']});
added
removed
backend/stats/static/js/yui/build/yui-nodejs/yui-nodejs-debug.js
