yui-debug.js revision 4390434761f176b0f8d7a71c00a6e0141aa1752c
// 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 * 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'];
* Provides a mechanism to fetch remote resources and * insert them into a document. * Fetches and inserts one or more script or link nodes into the document * hash of queues to manage multiple requests * queue index used to generate transaction ids * interal property used to prevent multiple simultaneous purge * Generates an HTML element, this is not appended to a document * @param type {string} the type of element * @param attr {string} the attributes * @param win {Window} optional window to create the element in * @return {HTMLElement} the generated node * @param url {string} the url for the css file * @param win {Window} optional window to create the node in * @param attributes optional attributes collection to apply to the new node * @return {HTMLElement} the generated node * Generates a script node * @param url {string} the url for the script file * @param win {Window} optional window to create the node in * @param attributes optional attributes collection to apply to the new node * @return {HTMLElement} the generated node * Returns the data payload for callback functions * The transaction is finished * @param id {string} the id of the request * The request failed, execute fail handler with whatever * was accomplished. There isn't a failure case at the * moment unless you count aborted transactions * @param id {string} the id of the request Y.
log(
"get failure: " +
msg,
"warn",
"get");
// execute failure callback * The request is complete, so executing the requester's callback * @param id {string} the id of the request Y.
log(
"Finishing transaction " +
id,
"info",
"get");
msg =
"transaction " +
id +
" was aborted";
// execute success callback * @param id {string} the id of the request Y.
log(
"Timeout " +
id,
"info",
"get");
_end(
id,
'timeout',
'timeout');
* Loads the next item for a given request * @param id {string} the id of the request * @param loaded {string} the url that was just loaded, if any Y.
log(
"_next: " +
id +
", loaded: " + (
loaded ||
"nothing"),
"info",
"get");
// Y.log('cancel timer'); msg =
"transaction " +
id +
" was aborted";
// This is the first pass: make sure the url is an array // if the url is undefined, this is probably a trailing comma problem in IE Y.
log(
'skipping empty url');
Y.
log(
"attempting to load " +
url,
"info",
"get");
// Y.log('create timer'); // q.timer = L.later(q.timeout, q, _timeout, id); if (q.
type ===
"script") {
// track this node's load progress // add the node to the queue so we can return it to the user supplied callback // add it to the head or insert it before 'insertBefore' Y.
log(
"Appending node: " +
url,
"info",
"get");
// FireFox does not support the onload event for link nodes, so there is // no way to make the css requests synchronous. This means that the css // rules in multiple files could be applied out of order in this browser // if a later request returns before an earlier one. Safari too. * Removes processed queues and corresponding nodes * Saves the state for the request and begins loading * @param type {string} the type of node to insert * @param url {string} the url to load * @param opts the hash of options for this request (
type ===
"script") ?
true :
false;
// L.later(0, q, _next, id); * Detects when a node has been loaded. In the case of * script nodes, this does not guarantee that contained * script is ready to use. * @param type {string} the type of node to track * @param n {HTMLElement} the node to track * @param id {string} the id of the request * @param url {string} the url that is being loaded * @param win {Window} the targeted window * @param qlength the number of remaining items in the queue, * @param trackfn {Function} function to execute when finished // IE supports the readystatechange event for script and css nodes // Opera only for script nodes. Opera support onload for script // nodes, but this doesn't fire when there is a load failure. // The onreadystatechange appears to be a better way to respond // to both success and failure. if (
"loaded" ===
rs ||
"complete" ===
rs) {
Y.
log(
id +
" onreadstatechange " +
url,
"info",
"get");
// webkit prior to 3.x is no longer supported // Safari 3.x supports the load event for script nodes (DOM2) Y.
log(
id +
" DOM2 onload " +
url,
"info",
"get");
// FireFox and Opera support onload (but not DOM2 in FF) handlers for // script nodes. Opera, but not FF, supports the onload event for link Y.
log(
id +
" onload " +
url,
"info",
"get");
* Removes the nodes for the specified queue // This is a hostile delete // operation attempting to improve // memory performance. As such, the // hasOwnProperty check is intentionally * The number of request required before an automatic purge. * Can be configured via the 'purgethreshold' config * Called by the the helper for detecting script load in Safari * @param id {string} the transaction id Y.
log(
id +
" finalized ",
"info",
"get");
// L.later(0, null, _finish, id); * @param o {string|object} Either the tId or the object returned from Y.
log(
"Aborting " +
id,
"info",
"get");
* Fetches and inserts one or more script nodes into the head * of the current document or the document in a specified window. * @param url {string|string[]} the url or urls to the script(s) * @param opts {object} Options: * callback to execute when the script(s) are finished loading * The callback receives an object back with the following * <dd>the window the script(s) were inserted into</dd> * <dd>the data object passed in when the request was made</dd> * <dd>An array containing references to the nodes that were * <dd>A function that, when executed, will remove the nodes * that were inserted</dd> * callback to execute when a timeout occurs. * The callback receives an object back with the following * <dd>the window the script(s) were inserted into</dd> * <dd>the data object passed in when the request was made</dd> * <dd>An array containing references to the nodes that were * <dd>A function that, when executed, will remove the nodes * that were inserted</dd> * <dd>a function that executes when the transaction finishes, regardless of the exit path</dd> * callback to execute when the script load operation fails * The callback receives an object back with the following * <dd>the window the script(s) were inserted into</dd> * <dd>the data object passed in when the request was made</dd> * <dd>An array containing references to the nodes that were * inserted successfully</dd> * <dd>A function that, when executed, will remove any nodes * that were inserted</dd> * <dd>the execution context for the callbacks</dd> * <dd>a window other than the one the utility occupies</dd> * setting to true will let the utilities cleanup routine purge * <dt>purgethreshold</dt> * The number of transaction before autopurge should be initiated * data that is supplied to the callback when the script(s) are * <dd>node or node id that will become the new node's nextSibling</dd> * <dd>Node charset, default utf-8 (deprecated, use the attributes config)</dd> * <dd>An object literal containing additional attributes to add to the link tags</dd> * <dd>Number of milliseconds to wait before aborting and firing the timeout event</dd> * Y.Get.script( * onSuccess: function(o) { * this.log("won't cause error because Y is the context"); * Y.log(o.data); // foo * Y.log(o.nodes.length === 2) // true * // o.purge(); // optionally remove the script nodes immediately * }, * onFailure: function(o) { * Y.log("transaction failed"); * }, * onTimeout: function(o) { * Y.log("transaction timed out"); * }, * data: "foo", * timeout: 10000, // 10 second timeout * context: Y, // make the YUI instance * // win: otherframe // target another window/frame * autopurge: true // allow the utility to choose when to remove the nodes * purgetheshold: 1 // purge previous transaction before next transaction * @return {tId: string} an object containing info about the transaction * Fetches and inserts one or more css link nodes into the * head of the current document or the document in a specified * @param url {string} the url or urls to the css file(s) * callback to execute when the css file(s) are finished loading * The callback receives an object back with the following * <dd>the window the link nodes(s) were inserted into</dd> * <dd>the data object passed in when the request was made</dd> * <dd>An array containing references to the nodes that were * <dd>A function that, when executed, will remove the nodes * that were inserted</dd> * <dd>the execution context for the callbacks</dd> * <dd>a window other than the one the utility occupies</dd> * data that is supplied to the callbacks when the nodes(s) are * <dd>node or node id that will become the new node's nextSibling</dd> * <dd>Node charset, default utf-8 (deprecated, use the attributes config)</dd> * <dd>An object literal containing additional attributes to add to the link tags</dd> * insertBefore: 'custom-styles' // nodes will be inserted before the specified node * @return {tId: string} an object containing info about the transaction YUI.
add(
'yui-log',
function(Y) {
* Provides console log capability and exposes a custom event for * console implementations. * If the 'debug' config is true, a 'yui:log' event will be * dispatched, which the Console widget and anything else * can consume. If the 'useBrowserConsole' config is true, it will * write to the browser console if available. YUI-specific log * messages will only be present in the -debug versions of the * JS files. The build system is supposed to remove log statements * from the raw and minified versions of the files. * @param {String} msg The message to log. * @param {String} cat The log category for the message. Default * categories are "info", "warn", "error", time". * Custom categories can be used as well. (opt) * @param {String} src The source of the the message (opt) * @param {boolean} silent If true, the log event won't fire * @return {YUI} YUI instance // suppress log message if the config is off or the event stack // or the event call stack contains a consumer of the yui:log event * Write a system message. This message will be preserved in the * minified and raw versions of the YUI files, unlike log statements. * @param {String} msg The message to log. * @param {String} cat The log category for the message. Default * categories are "info", "warn", "error", time". * Custom categories can be used as well. (opt) * @param {String} src The source of the the message (opt) * @param {boolean} silent If true, the log event won't fire * @return {YUI} YUI instance },
'@VERSION@' ,{
requires:[
'yui-base']});
YUI.
add(
'yui-later',
function(Y) {
* Executes the supplied function in the context of the supplied * object 'when' milliseconds later. Executes the function a * single time unless periodic is set to true. * @param when {int} the number of milliseconds to wait until the fn * @param o the context object. * @param fn {Function|String} the function to execute or the name of * the method in the 'o' object to execute. * @param data [Array] data that is provided to the function. This accepts * either a single item or an array. If an array is provided, the * function is executed with one parameter for each array item. If * you need to pass a single array parameter, it needs to be wrapped in * @param periodic {boolean} if true, executes continuously at supplied * interval until canceled. * @return {object} a timer object. Call the cancel() method on this object to var m=
fn, d=Y.
Array(
data), f, r;
Y.
log(
"method undefined");
},
'@VERSION@' ,{
requires:[
'yui-base']});
YUI.
add(
'yui',
function(Y){},
'@VERSION@' ,{
use:[
'yui-base',
'get',
'yui-log',
'yui-later']});