yui.js revision 4fcbec6145d16637205990699912fb90f6a3807c
/**
* YUI core
* @module yui
*/
(function() {
var _instances = {},
// @TODO: this needs to be created at build time from module metadata
'io.xdrReady': 1,
'io.start': 1,
'io.success': 1,
'io.failure': 1,
'io.abort': 1
};
/**
* The YUI global namespace object. If YUI is already defined, the
* existing YUI object will not be overwritten so that defined
* namespaces are preserved.
*
* @class YUI
* @constructor
* @global
* @uses Event.Target
* @param o Optional configuration object. Options:
* <ul>
* <li>------------------------------------------------------------------------</li>
* <li>Global:</li>
* <li>------------------------------------------------------------------------</li>
* <li>debug:
* Turn debug statements on or off</li>
* <li>useConsole:
* Log to the browser console if debug is on and the console is available</li>
* <li>logInclude:
* A hash of log sources that should be logged. If specified, only log messages from these sources will be logged.
*
* </li>
* <li>logExclude:
* A hash of log sources that should be not be logged. If specified, all sources are logged if not on this list.</li>
* <li>throwFail:
* If throwFail is set, Y.fail will generate or re-throw a JS error. Otherwise the failure is logged.
* <li>win:
* <li>core:
* A list of modules that defines the YUI core (overrides the default)</li>
* <li>------------------------------------------------------------------------</li>
* <li>For event and get:</li>
* <li>------------------------------------------------------------------------</li>
* <li>pollInterval:
* The default poll interval</li>
* <li>-------------------------------------------------------------------------</li>
* <li>For loader:</li>
* <li>-------------------------------------------------------------------------</li>
* <li>base:
* The base dir</li>
* <li>secureBase:
* The secure base dir (not implemented)</li>
* <li>comboBase:
* The YUI combo service base dir. Ex: http://yui.yahooapis.com/combo?</li>
* <li>root:
* The root path to prepend to module names for the combo service. Ex: 2.5.2/build/</li>
* <li>filter:
*
* A filter to apply to result urls. This filter will modify the default
* path for all modules. The default path for the YUI library is the
* minified version of the files (e.g., event-min.js). The filter property
* can be a predefined filter or a custom filter. The valid predefined
* filters are:
* <dl>
* <dt>DEBUG</dt>
* <dd>Selects the debug versions of the library (e.g., event-debug.js).
* This option will automatically include the logger widget</dd>
* <dt>RAW</dt>
* <dd>Selects the non-minified version of the library (e.g., event.js).</dd>
* </dl>
* You can also define a custom filter, which must be an object literal
* containing a search expression and a replace string:
* <pre>
* myFilter: {
* 'searchExp': "-min\\.js",
* 'replaceStr': "-debug.js"
* }
* </pre>
*
* </li>
* <li>combine:
* Use the YUI combo service to reduce the number of http connections required to load your dependencies</li>
* <li>ignore:
* A list of modules that should never be dynamically loaded</li>
* <li>force:
* A list of modules that should always be loaded when required, even if already present on the page</li>
* <li>insertBefore:
* Node or id for a node that should be used as the insertion point for new nodes</li>
* <li>charset:
* charset for dynamic nodes</li>
* <li>timeout:
* number of milliseconds before a timeout occurs when dynamically loading nodes. in not set, there is no timeout</li>
* <li>context:
* execution context for all callbacks</li>
* <li>onSuccess:
* callback for the 'success' event</li>
* <li>onFailure:
* callback for the 'failure' event</li>
* <li>onTimeout:
* callback for the 'timeout' event</li>
* <li>onProgress:
* callback executed each time a script or css file is loaded</li>
* <li>modules:
* A list of module definitions. See Loader.addModule for the supported module metadata</li>
* </ul>
*/
/*global YUI*/
YUI = function(o) {
var Y = this;
// Allow var yui = YUI() instead of var yui = new YUI()
if (Y == window) {
return new YUI(o);
} else {
// set up the core environment
Y._init(o);
// bind the specified additional modules for this instance
Y._setup();
}
};
}
// The prototype contains the functions that are required to allow the external
// modules to be registered and for the instance to be initialized.
/**
* Initialize this YUI instance
* @param o config options
* @private
*/
_init: function(o) {
o = o || {};
// find targeted window and @TODO create facades
o.win = w;
// add a reference to o for anything that needs it
// before _setup is called.
this.config = o;
this.Env = {
// @todo expand the new module metadata
mods: {},
_idx: 0,
_pre: 'yuid',
_used: {},
_attached: {},
_yidx: 0,
_uidx: 0
};
_instances[this.id] = this;
}
this.constructor = YUI;
},
/**
* Finishes the instance setup. Attaches whatever modules were defined
* when the yui modules was registered.
* @method _setup
* @private
*/
_setup: function(o) {
this.use("yui");
// @TODO eval the need to copy the config
},
/**
* Executes a method on a YUI instance with
* the specified id if the specified method is whitelisted.
* @method applyTo
* @param id {string} the YUI instance id
* @param method {string} the name of the method to exectute.
* Ex: 'Object.keys'
* @param args {Array} the arguments to apply to the method
* @return {object} the return value from the applied method or null
*/
if (!(method in _APPLY_TO_WHITE_LIST)) {
return null;
}
if (instance) {
m = m[nest[i]];
if (!m) {
}
}
}
return null;
},
/**
* Register a module
* @method add
* @param name {string} module name
* @param namespace {string} name space for the module
* @param fn {Function} entry point into the module that
* is used to bind module to the YUI instance
* @param version {string} version string
* @return {YUI} the YUI instance
*
* requires - features that should be present before loading
* optional - optional features that should be present if load optional defined
* use - features that should be attached automatically
* skinnable -
* rollup
* omit - features that should not be loaded if this module is present
*/
// this.log('Adding a new component ' + name);
// @todo expand this to include version mapping
// @todo allow requires/supersedes
// @todo may want to restore the build property
// @todo fire moduleAvailable event
var m = {
};
return this; // chain support
},
_attach: function(r, fromLoader) {
if (req) {
}
if (m.fn) {
m.fn(this);
}
if (use) {
}
}
}
},
/**
* Bind a module to a YUI instance
* @param modules* {string} 1-n modules to bind (uses arguments array)
* @param *callback {function} callback function executed when
* the instance has the required functionality. If included, it
* must be the last parameter.
*
* @TODO
* Implement versioning? loader can load different versions?
* Should sub-modules/plugins be normal modules, or do
* we add syntax for specifying these?
*
* YUI().use('dragdrop')
* YUI().use('dragdrop:2.4.0'); // specific version
* YUI().use('dragdrop:2.4.0-'); // at least this version
* YUI().use('dragdrop:2.4.0-2.9999.9999'); // version range
* YUI().use('*'); // use all available modules
* YUI().use('lang+dump+substitute'); // use lang and some plugins
* YUI().use('lang+*'); // use lang and all known plugins
*
*
* @return {YUI} the YUI instance
*/
use: function() {
var Y = this,
firstArg = a[0],
dynamic = false,
// Y.log(Y.id + ': use called: ' + a + ' :: ' + callback);
// The last argument supplied to use can be a load complete callback
if (typeof callback === 'function') {
a.pop();
} else {
callback = null;
}
// YUI().use('*'); // bind everything available
if (firstArg === "*") {
a = [];
for (var k in mods) {
if (mods.hasOwnProperty(k)) {
a.push(k);
}
}
}
// Y.log('loader before: ' + a.join(','));
// use loader to optimize and sort the requirements if it
// is available.
if (Y.Loader) {
dynamic = true;
loader.ignoreRegistered = true;
}
// Y.log('loader after: ' + a.join(','));
// only attach a module once
// Y.log(name + ' already used');
return;
}
if (m) {
// Y.log('found ' + name);
} else {
}
// make sure requirements are attached
if (req) {
f(req);
} else {
f(req[j]);
}
}
}
// add this module to full list of things to attach
// Y.log('using ' + name);
};
// process each requirement and any additional requirements
// the module metadata specifies
f(a[i]);
}
// Y.log('all reqs: ' + r + ' --- missing: ' + missing);
var onComplete = function(fromLoader) {
// Y.log('Use complete');
cb(Y, fromLoader);
}
if (Y.fire) {
}
};
// dynamic load
} else {
Y._attach(r);
onComplete();
}
return Y; // chain support var yui = YUI().use('dragdrop');
},
/**
* Returns the namespace specified and creates it if it doesn't exist
* <pre>
* YUI.namespace("property.package");
* YUI.namespace("YUI.property.package");
* </pre>
* Either of the above would create YUI.property, then
* YUI.property.package
*
* Be careful when naming packages. Reserved words may work in some browsers
* and not others. For instance, the following will fail in Safari:
* <pre>
* YUI.namespace("really.long.nested.namespace");
* </pre>
* This fails because "long" is a future reserved word in ECMAScript
*
* @method namespace
* @param {string*} arguments 1-n namespaces to create
* @return {object} A reference to the last namespace object created
*/
namespace: function() {
var a=arguments, o=null, i, j, d;
d = a[i].split(".");
o = this;
o[d[j]] = o[d[j]] || {};
o = o[d[j]];
}
}
return o;
},
// this is replaced if the log module is included
log: function() {
},
/**
* Report an error. The reporting mechanism is controled by
* the 'throwFail' configuration attribute. If throwFail is
* not specified, the message is written to the logger, otherwise
* a JS error is thrown
* @method fail
* @param msg {string} the failure message
* @param e {Error} Optional JS error that was caught. If supplied
* and throwFail is specified, this error will be re-thrown.
* @return {YUI} this YUI instance
*/
var instance = this;
}
return this;
},
/**
* Generate an id that is unique among all YUI instances
* @method guid
* @param pre {string} optional guid prefix
* @return {string} the guid
*/
},
/**
* Stamps an object with a guid. If the object already
* has one, a new one is not created
* @method stamp
* @param o The object to stamp
* @return {string} The object's guid
*/
stamp: function(o) {
if (!o) {
return o;
}
if (!uid) {
}
return uid;
}
};
// Give the YUI global the same properties as an instance.
// This makes it so that the YUI global can be used like the YAHOO
// global was used prior to 3.x. More importantly, the YUI global
// provides global metadata, so env needs to be configured.
// @TODO review
// inheritance utilities are not available yet
for (i in p) {
if (true) { // hasOwnProperty not available yet and not needed
Y[i] = p[i];
}
}
// set up the environment
Y._init();
})();