yui-base-debug.js revision 43692b3f865f1b1c970aedb2b96392482bd1fe3e
279N/A * The YUI module contains the components required for building the YUI seed file. 279N/A * This includes the script loading mechanism, a simple queue, and the core utilities for the library. 279N/A// @TODO: this needs to be created at build time from module metadata 279N/A// reduce to one or the other 3339N/A * The YUI global namespace object. If YUI is already defined, the 3339N/A * existing YUI object will not be overwritten so that defined 447N/A * namespaces are preserved. 924N/A * @param o* Up to five optional configuration objects. This object is stored 279N/A * in YUI.config. See config for the list of supported properties. 5495N/A // @TODO Advice was to make a function, disallow direct instantiation. 3353N/A // Allow instantiation without the new operator 4835N/A // set up the core environment 6021N/A // bind the specified additional modules for this instance // The prototype contains the functions that are required to allow the external // modules to be registered and for the instance to be initialized. if (
mods && i ==
'modules') {
* Initialize this YUI instance var v =
'@VERSION@', Y =
this,
filter;
// @todo expand the new module metadata // configuration defaults // base: (Y === YUI) ? Y.Env.cdn : function() { //console.log('src) ' + src); // this is to set up the path to the loader. The file filter for loader should match // extract correct path for mixed combo urls * Finishes the instance setup. Attaches whatever modules were defined * when the yui modules was registered. * Executes a method on a YUI instance with * the specified id if the specified method is whitelisted. * @param id {string} the YUI instance id * @param method {string} the name of the method to exectute. * @param args {Array} the arguments to apply to the method * @return {object} the return value from the applied method or null this.
log(
method +
': applyTo not allowed',
'warn',
'yui');
this.
log(
'applyTo not found: ' +
method,
'warn',
'yui');
* @param name {string} module name * @param fn {Function} entry point into the module that * is used to bind module to the YUI instance * @param version {string} version string * @param details optional config data: * requires - features that should be present before loading * optional - optional features that should be present if load optional defined * use - features that should be attached automatically * omit - features that should not be loaded if this module is present * @return {YUI} the YUI instance // this.log('Adding a new component ' + name); // @todo expand this to include version mapping // @todo may want to restore the build property // @todo fire moduleAvailable event return this;
// chain support // console.log(name + '::' + m); // this.log('attaching ' + name, 'info', 'yui'); * 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. * Implement versioning? loader can load different versions? * we add syntax for specifying these? * 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 // only attach a module once // Y.log(name + ' already used', 'info', 'yui'); // Y.log('USING ' + name, 'info', 'yui'); // CSS files don't register themselves, see if it has been loaded // Y.log('module not found: ' + name, 'info', 'yui'); // Y.log('module not found BUT HAS BEEN LOADED: ' + name, 'info', 'yui'); // make sure requirements are attached // Y.log('using module\'s requirements: ' + name, 'info', 'yui'); // add this module to full list of things to attach // Y.log('adding to requires list: ' + name); // Y.log(Y.id + ': use called: ' + a + ' :: ' + callback); // The last argument supplied to use can be a load complete callback // Y.log('Use complete'); // process queued use requests as long until done // or dynamic load happens again. // YUI().use('*'); // bind everything available // Y.log('loader before: ' + a.join(',')); // use loader to expand dependencies and sort the // requirements if it is available. // loader.calculate(null, (css && css == 'force') ? null : 'js'); // Y.log('loader after: ' + a.join(',')); // process each requirement and any additional requirements // the module metadata specifies Y.
log(
'Module requirements: ' + a,
'info',
'yui');
Y.
log(
'Modules missing: ' +
missing,
'info',
'yui');
Y.
log(
'Using loader to fetch missing dependencies.',
'info',
'yui');
// loader.require(missing); Y.
message(
'Unable or not configured to fetch missing modules: ' +
missing,
'info',
'yui');
Y.
log(
'Attaching available dependencies.',
'info',
'yui');
return Y;
// chain support var yui = YUI().use('dragdrop'); * Returns the namespace specified and creates it if it doesn't exist * YUI.namespace("property.package"); * YUI.namespace("YAHOO.property.package"); * Either of the above would create YUI.property, then * YUI.property.package (YAHOO is scrubbed out, this is * to remain compatible with YUI2) * Be careful when naming packages. Reserved words may work in some browsers * and not others. For instance, the following will fail in Safari: * YUI.namespace("really.long.nested.namespace"); * This fails because "long" is a future reserved word in ECMAScript * @param {string*} arguments 1-n namespaces to create * @return {object} A reference to the last namespace object created for (i=
0; i<a.
length; i=i+
1) {
d = (
"" + a[i]).
split(
".");
for (j=(d[
0] ==
"YAHOO") ?
1 :
0; j<d.
length; j=j+
1) {
// this is replaced if the log module is included * 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 * @param msg {string} the error message * @param e {Error} Optional JS error that was caught. If supplied * and throwFail is specified, this error will be re-thrown. * @return {YUI} this YUI instance this.
message(
msg,
"error");
// don't scrub this one * Generate an id that is unique among all YUI instances * @param pre {string} optional guid prefix * @return {string} the guid * Returns a guid associated with an object. If the object * does not have one, a new one is created unless readOnly * @param o The object to stamp * @param readOnly {boolean} if true, a valid guid will only * be returned if the object has one assigned to it. * @return {string} The object's guid or null var uid = (
typeof o ===
'string') ? o : o.
_yuid;
// 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. // inheritance utilities are not available yet if (
1) {
// intenionally ignoring hasOwnProperty check // set up the environment // add a window load event at load time so we can capture // the case where it fires before dynamic loading is * The config object contains all of the configuration options for * the YUI instance. This object is supplied by the implementer * when instantiating a YUI instance. Some properties have default * values if they are not supplied by the implementer. * Allows the YUI seed file to fetch the loader component and library * metadata to dynamically load additional dependencies. * Log to the browser console if debug is on and the browser has a * @property useBrowserConsole * A hash of log sources that should be logged. If specified, only log messages from these sources will be logged. * A hash of log sources that should be not be logged. If specified, all sources are logged if not on this list. * Set to true if the yui seed file was dynamically loaded in * order to bootstrap components relying on the window load event * and the 'domready' custom event. * If throwFail is set, Y.fail will generate or re-throw a JS Error. Otherwise the failure is logged. * The window/frame that this instance should operate in. * @default the window hosting YUI * The document associated with the 'win' configuration. * @default the document hosting YUI * A list of modules that defines the YUI core (overrides the default). * The default date format * The default interval when polling in milliseconds. * The number of dynamic nodes to insert by default before * automatically removing them. This applies to script nodes * because remove the node will not make the evaluated script * unavailable. Dynamic CSS is not auto purged, because removing * a linked style sheet will also remove the style definitions. * @property purgethreshold * The default interval when polling in milliseconds. * @property windowResizeDelay * Base directory for dynamic loading * The secure base dir (not implemented) * The root path to prepend to module names for the combo service. Ex: 3.0.0b1/build/ * 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 * <dd>Selects the debug versions of the library (e.g., event-debug.js). * This option will automatically include the Logger widget</dd> * <dd>Selects the non-minified version of the library (e.g., event.js).</dd> * You can also define a custom filter, which must be an object literal * containing a search expression and a replace string: * 'searchExp': "-min\\.js", * Hash of per-component filter specification. If specified for a given component, * this overrides the filter config * Use the YUI combo service to reduce the number of http connections * required to load your dependencies. * @default true if 'base' is not supplied, false if it is. * A list of modules that should never be dynamically loaded * A list of modules that should always be loaded when required, even if already * Node or id for a node that should be used as the insertion point for new nodes * charset for dynamic nodes * @deprecated use jsAttributes cssAttributes * Object literal containing attributes to add to dynamically loaded script nodes. * Object literal containing attributes to add to dynamically loaded link nodes. * @property cssAttributes * Number of milliseconds before a timeout occurs when dynamically * loading nodes. If not set, there is no timeout. * Callback for the 'CSSComplete' event. When dynamically loading YUI * components with CSS, this property fires when the CSS is finished * loading but script loading is still ongoing. This provides an * opportunity to enhance the presentation of a loading page a little * bit before the entire loading process is done. * A list of module definitions to add to the list of YUI components. * These components can then be dynamically loaded side by side with * YUI via the use() method.See Loader.addModule for the supported * The loader 'path' attribute to the loader itself. This is combined * with the 'base' attribute to dynamically load the loader component * when boostrapping with the get utility alone. * Specifies whether or not YUI().use(...) will attempt to load CSS * resources at all. Any truthy value will cause CSS dependencies * to load when fetching script. The special value 'force' will * cause CSS dependencies to be loaded even if no script is needed. YUI.
add(
'yui-base',
function(Y) {
* The YUI module contains the components required for building the YUI seed file. * This includes the script loading mechanism, a simple queue, and the core utilities for the library. * A simple FIFO queue. Items are added to the Queue with add(1..n items) and * @param item* {MIXED} 0..n items to seed the queue * The collection of enqueued items * Get the next item in the queue. * @return {MIXED} the next item in the queue * Add 0..n items to the end of the queue * @param item* {MIXED} 0..n items * Returns the current number of queued items * The YUI module contains the components required for building the YUI seed file. * This includes the script loading mechanism, a simple queue, and the core utilities for the library. * Provides the language utilites and extensions used by the library '[object RegExp]' :
REGEX,
'[object Array]' :
ARRAY,
* Determines whether or not the provided item is an array. * Returns false for array-like collections such as the * function arguments collection or HTMLElement collection * will return false. You can use @see Array.test if you * @param o The object to test * @return {boolean} true if o is an array * Determines whether or not the provided item is a boolean * @param o The object to test * @return {boolean} true if o is a boolean * Determines whether or not the provided item is a function * Note: Internet Explorer thinks certain functions are objects: * var obj = document.createElement("object"); * Y.Lang.isFunction(obj.getAttribute) // reports false in IE * var input = document.createElement("input"); // append to body * Y.Lang.isFunction(input.focus) // reports false in IE * You will have to implement additional tests if these functions * @param o The object to test * @return {boolean} true if o is a function * Determines whether or not the supplied item is a date instance * @param o The object to test * @return {boolean} true if o is a date // return o instanceof Date; * Determines whether or not the provided item is null * @param o The object to test * @return {boolean} true if o is null * Determines whether or not the provided item is a legal number * @param o The object to test * @return {boolean} true if o is a number * Determines whether or not the provided item is of type object * @param o The object to test * @param failfn {boolean} fail if the input is a function * @return {boolean} true if o is an object * Determines whether or not the provided item is a string * @param o The object to test * @return {boolean} true if o is a string * Determines whether or not the provided item is undefined * @param o The object to test * @return {boolean} true if o is undefined * Returns a string without any leading or trailing whitespace. If * the input is not a string, the input will be returned untouched. * @param s {string} the string to trim * @return {string} the trimmed string * A convenience method for detecting a legitimate non-null value. * @param o The item to test * Returns a string representing the type of the item passed in. * typeof HTMLElementCollection returns function in Safari, but * Y.type() reports object, which could be a good thing -- * but it actually caused the logic in Y.Lang.isObject to fail. * @param o the item to test * @return {string} the detected type * The YUI module contains the components required for building the YUI seed file. * This includes the script loading mechanism, a simple queue, and the core utilities for the library. * Adds the following array utilities to the YUI instance. Additional * array helpers can be found in the collection component. * Y.Array(o) returns an array: * - Arrays are return unmodified unless the start position is specified. * - "Array-like" collections (@see Array.test) are converted to arrays * - For everything else, a new array is created with the input as the sole item * - The start position is used if the input is or is like an array to return * a subset of the collection. * @TODO this will not automatically convert elements that are also collections * such as forms and selects. Passing true as the third param will * @param o the item to arrayify * @param i {int} if an array or array-like, this is the start index * @param arraylike {boolean} if true, it forces the array-like fork. This * can be used to avoid multiple Array.test calls. * @return {Array} the resulting array // IE errors when trying to slice HTMLElement collections * Evaluates the input to determine if it is an array, array-like, or * something else. This is used to handle the arguments collection * available within functions, and HTMLElement collections * @todo current implementation (intenionally) will not implicitly * handle html elements that are array-like (forms, selects, etc). * @return {int} a number indicating the results: * 0: Not an array or an array-like collection * 2: array-like collection. // indexed, but no tagName (element) or alert (window), or functions without apply/call (Safari HTMLElementCollection bug) * Executes the supplied function on each item in the array. * @param a {Array} the array to iterate * @param f {Function} the function to execute on each item. The * function receives three arguments: the value, the index, the full array. * @param o Optional context object * @return {YUI} the YUI instance var l = (a && a.
length) ||
0, i;
for (i =
0; i < l; i=i+
1) {
f.
call(o || Y, a[i], i, a);
* Returns an object using the first array as keys, and * the second as values. If the second array is not * provided the value is set to true for each. * @param k {Array} keyset * @param v {Array} optional valueset * @return {object} the hash o[k[i]] = (
vl &&
vl > i) ? v[i] :
true;
* Returns the index of the first item in the array * that contains the specified value, -1 if the * @param a {Array} the array to search * @param val the value to search for * @return {int} the index of the item that contains the value or -1 for (
var i=
0; i<a.
length; i=i+
1) {
* Numeric sort convenience function. * Y.ArrayAssert.itemsAreEqual([1, 2, 3], [3, 1, 2].sort(Y.Array.numericSort)); * Executes the supplied function on each item in the array. * Returning true from the processing function will stop the * processing of the remaining * @param a {Array} the array to iterate * @param f {Function} the function to execute on each item. The function * receives three arguments: the value, the index, the full array. * @param o Optional context object * @return {boolean} true if the function returns true on * any of the items in the array if (f.
call(o, a[i], i, a)) {
* The YUI module contains the components required for building the YUI seed file. * This includes the script loading mechanism, a simple queue, and the core utilities for the library. * IE will not enumerate native functions in a derived object even if the * function was overridden. This is a workaround for specific functions * we care about on the Object prototype. * @param {Function} r the object to receive the augmentation * @param {Function} s the object that supplies the properties to augment * Returns a new object containing all of the properties of * all the supplied objects. The properties from later objects * will overwrite those in earlier objects. Passing in a * single object will create a shallow copy of it. For a deep * @param arguments {Object*} the objects to merge * @return {object} the new merged object * Applies the supplier's properties to the receiver. By default * all prototype and static propertes on the supplier are applied * to the corresponding spot on the receiver. By default all * properties are applied, and a property that is already on the * reciever will not be overwritten. The default behavior can * be modified by supplying the appropriate parameters. * @TODO add constants for the modes * @param {Function} r the object to receive the augmentation * @param {Function} s the object that supplies the properties to augment * @param ov {boolean} if true, properties already on the receiver * will be overwritten if found on the supplier. * @param wl {string[]} a whitelist. If supplied, only properties in * this list will be applied to the receiver. * @param {int} mode what should be copies, and to where * default(0): object to object * 1: prototype to prototype (old augment) * 2: prototype to prototype and object props (new augment) * @return {object} the augmented object case 1:
// proto to proto case 2:
// object to object and proto to proto case 3:
// proto to static case 4:
// static to proto default:
// object to object is what happens below // Maybe don't even need this wl && wl.length check anymore?? for (i =
0, l =
wl.
length; i < l; ++i) {
}
else if (!
arr && (
ov || !(p
in r))) {
// if (s.hasOwnProperty(i) && !(i in FROZEN)) { // check white list if it was supplied // if the receiver has this property, it is an object, // and merge is specified, merge the two objects. Y.
mix(r[i], s[i],
ov,
wl,
0,
true);
// recursive // otherwise apply the property only if overwrite // is specified or the receiver doesn't have one. }
else if (!
arr && (
ov || !(i
in r))) {
// if merge is specified and the receiver is an array, * Returns a wrapper for a function which caches the * return value of that function, keyed off of the combined * @param source {function} the function to memoize * @param cache an optional cache seed * @param refetch if supplied, this value is tested against the cached * value. If the values are equal, the wrapped function is executed again. * @return {Function} the wrapped function * The YUI module contains the components required for building the YUI seed file. * This includes the script loading mechanism, a simple queue, and the core utilities for the library. * Adds the following Object utilities to the YUI instance * Y.Object(o) returns a new object based upon the supplied object. * @TODO Use native Object.create() when available * @param o the supplier object * @return {Object} the new object * Extracts the keys, values, or size from an object * @param what what to extract (0: keys, 1: values, 2: size) * @return {boolean|Array} the extracted info * Returns an array containing the object's keys * @TODO use native Object.keys() if available * @return {string[]} the keys * Returns an array containing the object's values * @TODO use native Object.values() if available * @return {Array} the values * Returns the size of an object * @TODO use native Object.size() if available * Returns true if the object contains a given key * @param k the key to query * @return {boolean} true if the object contains the key // return (o.hasOwnProperty(k)); * Returns true if the object contains a given value * @param v the value to query * @return {boolean} true if the object contains the value * Determines whether or not the property was added * to the object instance. Returns false if the property is not present * in the object, or was inherited from the prototype. * @deprecated Safari 1.x support has been removed, so this is simply a * wrapper for the native implementation. Use the native implementation * @param o {any} The object being testing * @param p {string} the property to look for * @return {boolean} true if the object has the property on the instance O.
owns =
function(o, k) {
* Executes a function on each item. The function * receives the value, the key, and the object * as paramters (in that order). * @param o the object to iterate * @param f {Function} the function to execute on each item. The function * receives three arguments: the value, the the key, the full object. * @param c the execution context * @param proto {boolean} include proto * @return {YUI} the YUI instance * Executes a function on each item, but halts if the * function returns true. The function * receives the value, the key, and the object * as paramters (in that order). * @param o the object to iterate * @param f {Function} the function to execute on each item. The function * receives three arguments: the value, the the key, the full object. * @param c the execution context * @param proto {boolean} include proto * @return {boolean} true if any execution of the function returns true, false otherwise if (f.
call(s, o[i], i, o)) {
* Retrieves the sub value at the provided path, * from the value object provided. * @param o The object from which to extract the property value * @param path {Array} A path array, specifying the object traversal path * from which to obtain the sub value. * @return {Any} The value stored in the path, undefined if not found, * undefined if the source is not an object. Returns the source object * if an empty path is provided. * Sets the sub-attribute value at the provided path on the * value object. Returns the modified value object, or * undefined if the path is invalid. * @param o The object on which to set the sub value. * @param path {Array} A path array, specifying the object traversal path * at which to set the sub value. * @param val {Any} The new value for the sub-attribute. * @return {Object} The modified object, with the new sub value set, or * undefined, if the path was invalid. * The YUI module contains the components required for building the YUI seed file. * This includes the script loading mechanism, a simple queue, and the core utilities for the library. * YUI user agent detection. * Do not fork for a browser if it can be avoided. Use feature detection when * you can. Use the user agent as a last resort. UA stores a version * number for the browser engine, 0 otherwise. This value may or may not map * to the version number of the browser using the engine. The value is * presented as a float so that it can easily be used for boolean evaluation * as well as for looking for a particular range of versions. Because of this, * some of the granularity of the version info may be lost (e.g., Gecko 1.8.0.9 return (c++ ==
1) ?
'' :
'.';
* Internet Explorer version number or 0. Example: 6 * Opera version number or 0. Example: 9.2 * Gecko engine revision number. Will evaluate to 1 if Gecko * is detected but the revision could not be found. Other browsers * will be 0. Example: 1.8 * Firefox 1.0.0.4: 1.7.8 <-- Reports 1.7 * Firefox 1.5.0.9: 1.8.0.9 <-- 1.8 * Firefox 2.0.0.3: 1.8.1.3 <-- 1.81 * AppleWebKit version. KHTML browsers that are not WebKit browsers * will evaluate to 1, other browsers 0. Example: 418.9 * Safari 1.3.2 (312.6): 312.8.1 <-- Reports 312.8 -- currently the * latest available for Mac OSX 10.3. * Safari 2.0.2: 416 <-- hasOwnProperty introduced * Safari 2.0.4: 418 <-- preventDefault fixed * Safari 2.0.4 (419.3): 418.9.1 <-- One version of Safari may run * different versions of webkit * Safari 2.0.4 (419.3): 419 <-- Tiger installations that have been * updated, but not updated * Webkit 212 nightly: 522+ <-- Safari 3.0 precursor (with native SVG * and many major issues fixed). * Safari 3.0.4 (523.12) 523.12 <-- First Tiger release - automatic update * from 2.x via the 10.4.11 OS patch * Webkit nightly 1/2008:525+ <-- Supports DOMContentLoaded event. * yahoo.com user agent hack removed. * Chrome will be detected as webkit, but this property will also * be populated with the Chrome version number * The mobile property will be set to a string containing any relevant * user agent information when a modern mobile browser is detected. * Currently limited to Safari on the iPhone/iPod Touch, Nokia N-series * devices with the WebKit-based browser, and Opera Mini. * Adobe AIR version number or 0. Only populated if webkit is detected. * Google Caja version number or 0. * Set to true if the page appears to be in SSL * The operating system. Currently only detecting windows or macintosh // Modern KHTML browsers should qualify as Safari X-Grade // Modern WebKit browsers are at least X-Grade o.
mobile =
"Apple";
// iPhone or iPod Touch o.
mobile = m[
0];
// Nokia N-series, Android, webOS, ex: NokiaN95 o.
air = m[
0];
// Adobe AIR 1.0 or better if (!o.
webkit) {
// not webkit // @todo check Opera/8.01 (J2ME/MIDP; Opera Mini/2.0.4509/1316; fi; U; ssr) o.
mobile = m[
0];
// ex: Opera Mini/2.0.4509/1316 }
else {
// not opera or webkit }
else {
// not opera, webkit, or ie o.
gecko=
1;
// Gecko detected, look for revision * The YUI module contains the components required for building the YUI seed file. * This includes the script loading mechanism, a simple queue, and the core utilities for the library. // apply the minimal required functionality Y.
log(Y.
id +
' initialized',
'info',
'yui');
extras = [
'get',
'loader',
'yui-log',
'yui-later'];