yui-base.js revision 82a93c6ac1980f2a1542e6ded41952510be8bb46
// Allow instantiation without the new operator if (!(Y
instanceof YUI)) {
// set up the core environment // bind the specified additional modules for this instance 'io.xdrResponse':
1,
// can call. this should 'SWF.eventHandler':
1 },
// be done at build time // this can throw an uncaught exception in FF // Stamp the documentElement (HTML) with a class of "yui-loaded" to // enable styles that need to key off of JS being enabled. VERSION =
'3.0.0';
// dev time hack for cdn test }
else if (
name ==
'win') {
* Initialize this YUI instance mods: {},
// flat module map // this is to set up the path to the loader. The file // filter for loader should match the yui include. // extract correct path for mixed combo urls // configuration defaults /^(.*\?)(.*\&)(.*)
yui\/
yui[\.\-].*
js(\?.*)?$/);
* Finishes the instance setup. Attaches whatever modules were defined * when the yui modules was registered. extras = Y.
config.
core || [
'get',
'intl-base',
'loader',
'yui-log',
'yui-later',
'yui-throttle'];
* 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');
* Registers a module with the YUI global. The easiest way to create a * first-class YUI module is to use the YUI component build tool. * The build system will produce the YUI.add wrapper for you module, along * with any configuration info required for the module. * @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 must be present before this module can be attached. * optional: optional features that should be present if loadOptional is * defined. Note: modules are not often loaded this way in YUI 3, * but this field is still useful to inform the user that certain * features in the component will require additional dependencies. * use: features that are included within this module which need to be * be attached automatically when this module is attached. This * supports the YUI 3 rollup system -- a module with submodules * defined will need to have the submodules listed in the 'use' * config. The YUI component build tool does this for you. * @return {YUI} the YUI instance * Executes the function associated with each required * module, binding the module to the YUI instance. * Attaches one or more modules to the YUI instance. When this * is executed, the requirements are analyzed, and one of * several things can happen: * - All requirements are available on the page -- The modules * are attached to the instance. If supplied, the use callback * is executed synchronously. * - Modules are missing, the Get utility is not available OR * the 'bootstrap' config is false -- A warning is issued about * the missing modules and all available modules are attached. * - Modules are missing, the Loader is not available but the Get * utility is and boostrap is not false -- The loader is bootstrapped * before doing the following.... * - Modules are missing and the Loader is available -- The loader * expands the dependency tree and fetches missing modules. When * the loader is finshed the callback supplied to use is executed * @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. * // loads and attaches drag and drop and its dependencies * YUI().use('dd', function(Y) {}); * // attaches all modules that are available on the page * YUI().use('*', function(Y) {}); * // intrinsic YUI gallery support (since 3.1.0) * YUI().use('gallery-yql', function(Y) {}); * // intrinsic YUI 2in3 support (since 3.1.0) * YUI().use('yui2-datatable', function(Y) {}); * @return {YUI} the YUI instance // add this module to full list of things to attach // only attach a module once // CSS files don't register themselves, see if it has been loaded if (
req) {
// make sure requirements are attached if (
use) {
// make sure we grab the submodule dependencies too // The last argument supplied to use can be a load complete callback // YUI().use('*'); // bind everything available // use loader to expand dependencies and sort the // requirements if it is available. // loader.allowRollup = false; // process each requirement and any additional requirements // the module metadata specifies * 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 * 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 // IE generates its own unique ID for dom nodes // The uniqueID property of a document node returns a new ID uid = (
typeof o ===
'string') ? o : o.
_yuid;
// inheritance utilities are not available yet // set up the environment // setTimeout(function() { YUI._attach(['yui-base']); }, 0); // add a window load event at load time so we can capture // the case where it fires before dynamic loading is // Support the CommonJS method for exporting our single global * 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.error 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). * A list of languages in order of preference. This list is matched against * the list of available languages in modules that the YUI instance uses to * determine the best possible localization of language sensitive modules. * Languages are represented using BCP 47 language tags, such as "en-GB" for * English as used in the United Kingdom, or "zh-Hans-CN" for simplified * Chinese as used in China. The list can be provided as a comma-separated * The default date format * @deprecated use configuration in DataType.Date.format() instead * @deprecated use config.lang instead * 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 path 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", * The 'skin' config let's you configure application level skin * customizations. It contains the following attributes which * can be specified to override the defaults: * // The default skin, which is automatically applied if not * // overriden by a component-specific skin definition. * // Change this in to apply a different skin globally * // This is combined with the loader base property to get * // the default root directory for a skin. * // Any component-specific overrides can be specified here, * // making it possible to load different skins for different * // components. It is possible to load more than one skin * // for a given component as well. * slider: ['capsule', 'round'] * 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. Turning this off will * disable combo handling for YUI and all module groups configured * @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 hash 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. This is a hash, the key is the module * name, and the value is an object literal specifying the metdata * for the module. * See Loader.addModule for the supported module * metadata fields. Also @see groups, which provides a way to * configure the base and combo spec for a * requires: ['node'], * requires: ['mymod1'], * A hash of module group definitions. It for each group you * can specify a list of modules and the base path and * combo spec to use when dynamically loading the modules. @see * @see modules for the details about the modules part of the * // specify whether or not this group has a combo service * // the base path for non-combo paths * // the path to the combo service * // a fragment to prepend to the path attribute when * // when building combo urls * // the module definitions * requires: ['yui2_yde'] * 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. * The default gallery version to build gallery module urls * The default YUI 2 version to build yui2 module urls. This is for * intrinsic YUI 2 support via the 2in3 project. Also @see the '2in3' * config for pulling different revisions of the wrapped YUI 2 * The 2in3 project is a deployment of the various versions of YUI 2 * deployed as first-class YUI 3 modules. Eventually, the wrapper * for the modules will change (but the underlying YUI 2 code will * be the same), and you can select a particular version of * the wrapper modules via this config. * Alternative console log function for use in environments without * a supported native console. * A callback to execute when Y.error is called. It receives the * error message and an javascript error object if Y.error was * executed because a javascript error was caught. 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. * 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. * 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. FIFO support * @return {MIXED} the next item in the queue * Get the last in the queue. LIFO support * @return {MIXED} the last 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. * 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 (
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 (
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 // return Object.prototype.hasOwnProperty.call(o, k); * 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 * 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. * @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 * Executes a function on each item. The function * receives the value, the key, and the object * as parameters (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. * Returns true if the object has no properties of its own * @return {boolean} true if the object is empty * 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. * Detects Apple iPad's OS version * Detects Apple iPhone's OS version * Detects Apples iPod's OS version * General truthy check for iPad, iPhone or iPod * Detects Googles Android OS version * 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