/*

YUI 3.10.3 (build 2fb5187)

Copyright 2013 Yahoo! Inc. All rights reserved.

Licensed under the BSD License.

http://yuilibrary.com/license/

*/

YUI.add('get', function (Y, NAME) {

/*jslint boss:true, expr:true, laxbreak: true */

/**

Provides dynamic loading of remote JavaScript and CSS resources.

@module get

@class Get

@static

**/

var Lang = Y.Lang,

    CUSTOM_ATTRS, // defined lazily in Y.Get.Transaction._createNode()

    Get, Transaction;

Y.Get = Get = {

    // -- Public Properties ----------------------------------------------------

    /**

    Default options for CSS requests. Options specified here will override

    global defaults for CSS requests.

    See the `options` property for all available options.

    @property cssOptions

    @type Object

    @static

    @since 3.5.0

    **/

    cssOptions: {

        attributes: {

            rel: 'stylesheet'

        },

        doc         : Y.config.linkDoc || Y.config.doc,

        pollInterval: 50

    },

    /**

    Default options for JS requests. Options specified here will override global

    defaults for JS requests.

    See the `options` property for all available options.

    @property jsOptions

    @type Object

    @static

    @since 3.5.0

    **/

    jsOptions: {

        autopurge: true,

        doc      : Y.config.scriptDoc || Y.config.doc

    },

    /**

    Default options to use for all requests.

    Note that while all available options are documented here for ease of

    discovery, some options (like callback functions) only make sense at the

    transaction level.

    Callback functions specified via the options object or the `options`

    parameter of the `css()`, `js()`, or `load()` methods will receive the

    transaction object as a parameter. See `Y.Get.Transaction` for details on

    the properties and methods available on transactions.

    @static

    @since 3.5.0

    @property {Object} options

    @property {Boolean} [options.async=false] Whether or not to load scripts

        asynchronously, meaning they're requested in parallel and execution

        order is not guaranteed. Has no effect on CSS, since CSS is always

        loaded asynchronously.

    @property {Object} [options.attributes] HTML attribute name/value pairs that

        should be added to inserted nodes. By default, the `charset` attribute

        will be set to "utf-8" and nodes will be given an auto-generated `id`

        attribute, but you can override these with your own values if desired.

    @property {Boolean} [options.autopurge] Whether or not to automatically

        purge inserted nodes after the purge threshold is reached. This is

        `true` by default for JavaScript, but `false` for CSS since purging a

        CSS node will also remove any styling applied by the referenced file.

    @property {Object} [options.context] `this` object to use when calling

        callback functions. Defaults to the transaction object.

    @property {Mixed} [options.data] Arbitrary data object to pass to "on*"

        callbacks.

    @property {Document} [options.doc] Document into which nodes should be

        inserted. By default, the current document is used.

    @property {HTMLElement|String} [options.insertBefore] HTML element or id

        string of an element before which all generated nodes should be

        inserted. If not specified, Get will automatically determine the best

        place to insert nodes for maximum compatibility.

    @property {Function} [options.onEnd] Callback to execute after a transaction

        is complete, regardless of whether it succeeded or failed.

    @property {Function} [options.onFailure] Callback to execute after a

        transaction fails, times out, or is aborted.

    @property {Function} [options.onProgress] Callback to execute after each

        individual request in a transaction either succeeds or fails.

    @property {Function} [options.onSuccess] Callback to execute after a

        transaction completes successfully with no errors. Note that in browsers

        that don't support the `error` event on CSS `<link>` nodes, a failed CSS

        request may still be reported as a success because in these browsers

        it can be difficult or impossible to distinguish between success and

        failure for CSS resources.

    @property {Function} [options.onTimeout] Callback to execute after a

        transaction times out.

    @property {Number} [options.pollInterval=50] Polling interval (in

        milliseconds) for detecting CSS load completion in browsers that don't

        support the `load` event on `<link>` nodes. This isn't used for

        JavaScript.

    @property {Number} [options.purgethreshold=20] Number of nodes to insert

        before triggering an automatic purge when `autopurge` is `true`.

    @property {Number} [options.timeout] Number of milliseconds to wait before

        aborting a transaction. When a timeout occurs, the `onTimeout` callback

        is called, followed by `onFailure` and finally `onEnd`. By default,

        there is no timeout.

    @property {String} [options.type] Resource type ("css" or "js"). This option

        is set automatically by the `css()` and `js()` functions and will be

        ignored there, but may be useful when using the `load()` function. If

        not specified, the type will be inferred from the URL, defaulting to

        "js" if the URL doesn't contain a recognizable file extension.

    **/

    options: {

        attributes: {

            charset: 'utf-8'

        },

        purgethreshold: 20

    },

    // -- Protected Properties -------------------------------------------------

    /**

    Regex that matches a CSS URL. Used to guess the file type when it's not

    specified.

    @property REGEX_CSS

    @type RegExp

    @final

    @protected

    @static

    @since 3.5.0

    **/

    REGEX_CSS: /\.css(?:[?;].*)?$/i,

    /**

    Regex that matches a JS URL. Used to guess the file type when it's not

    specified.

    @property REGEX_JS

    @type RegExp

    @final

    @protected

    @static

    @since 3.5.0

    **/

    REGEX_JS : /\.js(?:[?;].*)?$/i,

    /**

    Contains information about the current environment, such as what script and

    link injection features it supports.

    This object is created and populated the first time the `_getEnv()` method

    is called.

    @property _env

    @type Object

    @protected

    @static

    @since 3.5.0

    **/

    /**

    Mapping of document _yuid strings to <head> or <base> node references so we

    don't have to look the node up each time we want to insert a request node.

    @property _insertCache

    @type Object

    @protected

    @static

    @since 3.5.0

    **/

    _insertCache: {},

    /**

    Information about the currently pending transaction, if any.

    This is actually an object with two properties: `callback`, containing the

    optional callback passed to `css()`, `load()`, or `js()`; and `transaction`,

    containing the actual transaction instance.

    @property _pending

    @type Object

    @protected

    @static

    @since 3.5.0

    **/

    _pending: null,

    /**

    HTML nodes eligible to be purged next time autopurge is triggered.

    @property _purgeNodes

    @type HTMLElement[]

    @protected

    @static

    @since 3.5.0

    **/

    _purgeNodes: [],

    /**

    Queued transactions and associated callbacks.

    @property _queue

    @type Object[]

    @protected

    @static

    @since 3.5.0

    **/

    _queue: [],

    // -- Public Methods -------------------------------------------------------

    /**

    Aborts the specified transaction.

    This will cause the transaction's `onFailure` callback to be called and

    will prevent any new script and link nodes from being added to the document,

    but any resources that have already been requested will continue loading

    (there's no safe way to prevent this, unfortunately).

    *Note:* This method is deprecated as of 3.5.0, and will be removed in a

    future version of YUI. Use the transaction-level `abort()` method instead.

    @method abort

    @param {Get.Transaction} transaction Transaction to abort.

    @deprecated Use the `abort()` method on the transaction instead.

    @static

    **/

    abort: function (transaction) {

        var i, id, item, len, pending;

        if (!transaction.abort) {

            id          = transaction;

            pending     = this._pending;

            transaction = null;

            if (pending && pending.transaction.id === id) {

                transaction   = pending.transaction;

                this._pending = null;

            } else {

                for (i = 0, len = this._queue.length; i < len; ++i) {

                    item = this._queue[i].transaction;

                    if (item.id === id) {

                        transaction = item;

                        this._queue.splice(i, 1);

                        break;

                    }

                }

            }

        }

        transaction && transaction.abort();

    },

    /**

    Loads one or more CSS files.

    The _urls_ parameter may be provided as a URL string, a request object,

    or an array of URL strings and/or request objects.

    A request object is just an object that contains a `url` property and zero

    or more options that should apply specifically to that request.

    Request-specific options take priority over transaction-level options and

    default options.

    URLs may be relative or absolute, and do not have to have the same origin

    as the current page.

    The `options` parameter may be omitted completely and a callback passed in

    its place, if desired.

    @example

        // Load a single CSS file and log a message on completion.

        Y.Get.css('foo.css', function (err) {

            if (err) {

            } else {

            }

        });

        // Load multiple CSS files and log a message when all have finished

        // loading.

        var urls = ['foo.css', 'http://example.com/bar.css', 'baz/quux.css'];

        Y.Get.css(urls, function (err) {

            if (err) {

            } else {

            }

        });

        // Specify transaction-level options, which will apply to all requests

        // within the transaction.

        Y.Get.css(urls, {

            attributes: {'class': 'my-css'},

            timeout   : 5000

        });

        // Specify per-request options, which override transaction-level and

        // default options.

        Y.Get.css([

            {url: 'foo.css', attributes: {id: 'foo'}},

            {url: 'bar.css', attributes: {id: 'bar', charset: 'iso-8859-1'}}

        ]);

    @method css

    @param {String|Object|Array} urls URL string, request object, or array

        of URLs and/or request objects to load.

    @param {Object} [options] Options for this transaction. See the

        `Y.Get.options` property for a complete list of available options.

    @param {Function} [callback] Callback function to be called on completion.

        This is a general callback and will be called before any more granular

        callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`

        object.

        @param {Array|null} callback.err Array of errors that occurred during

            the transaction, or `null` on success.

        @param {Get.Transaction} callback.transaction Transaction object.

    @return {Get.Transaction} Transaction object.

    @static

    **/

    css: function (urls, options, callback) {

        return this._load('css', urls, options, callback);

    },

    /**

    Loads one or more JavaScript resources.

    The _urls_ parameter may be provided as a URL string, a request object,

    or an array of URL strings and/or request objects.

    A request object is just an object that contains a `url` property and zero

    or more options that should apply specifically to that request.

    Request-specific options take priority over transaction-level options and

    default options.

    URLs may be relative or absolute, and do not have to have the same origin

    as the current page.

    The `options` parameter may be omitted completely and a callback passed in

    its place, if desired.

    Scripts will be executed in the order they're specified unless the `async`

    option is `true`, in which case they'll be loaded in parallel and executed

    in whatever order they finish loading.

    @example

        // Load a single JS file and log a message on completion.

        Y.Get.js('foo.js', function (err) {

            if (err) {

            } else {

            }

        });

        // Load multiple JS files, execute them in order, and log a message when

        // all have finished loading.

        var urls = ['foo.js', 'http://example.com/bar.js', 'baz/quux.js'];

        Y.Get.js(urls, function (err) {

            if (err) {

            } else {

            }

        });

        // Specify transaction-level options, which will apply to all requests

        // within the transaction.

        Y.Get.js(urls, {

            attributes: {'class': 'my-js'},

            timeout   : 5000

        });

        // Specify per-request options, which override transaction-level and

        // default options.

        Y.Get.js([

            {url: 'foo.js', attributes: {id: 'foo'}},

            {url: 'bar.js', attributes: {id: 'bar', charset: 'iso-8859-1'}}

        ]);

    @method js

    @param {String|Object|Array} urls URL string, request object, or array

        of URLs and/or request objects to load.

    @param {Object} [options] Options for this transaction. See the

        `Y.Get.options` property for a complete list of available options.

    @param {Function} [callback] Callback function to be called on completion.

        This is a general callback and will be called before any more granular

        callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`

        object.

        @param {Array|null} callback.err Array of errors that occurred during

            the transaction, or `null` on success.

        @param {Get.Transaction} callback.transaction Transaction object.

    @return {Get.Transaction} Transaction object.

    @since 3.5.0

    @static

    **/

    js: function (urls, options, callback) {

        return this._load('js', urls, options, callback);

    },

    /**

    Loads one or more CSS and/or JavaScript resources in the same transaction.

    Use this method when you want to load both CSS and JavaScript in a single

    transaction and be notified when all requested URLs have finished loading,

    regardless of type.

    Behavior and options are the same as for the `css()` and `js()` methods. If

    a resource type isn't specified in per-request options or transaction-level

    options, Get will guess the file type based on the URL's extension (`.css`

    or `.js`, with or without a following query string). If the file type can't

    be guessed from the URL, a warning will be logged and Get will assume the

    URL is a JavaScript resource.

    @example

        // Load both CSS and JS files in a single transaction, and log a message

        // when all files have finished loading.

        Y.Get.load(['foo.css', 'bar.js', 'baz.css'], function (err) {

            if (err) {

            } else {

            }

        });

    @method load

    @param {String|Object|Array} urls URL string, request object, or array

        of URLs and/or request objects to load.

    @param {Object} [options] Options for this transaction. See the

        `Y.Get.options` property for a complete list of available options.

    @param {Function} [callback] Callback function to be called on completion.

        This is a general callback and will be called before any more granular

        callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`

        object.

        @param {Array|null} err Array of errors that occurred during the

            transaction, or `null` on success.