--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.0.0b1/build/loader/loader.js Mon Nov 23 15:14:29 2009 +0100
@@ -0,0 +1,2099 @@
+/*
+Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 3.0.0b1
+build: 1163
+*/
+YUI.add('loader', function(Y) {
+
+(function() {
+/**
+ * Loader dynamically loads script and css files. It includes the dependency
+ * info for the version of the library in use, and will automatically pull in
+ * dependencies for the modules requested. It supports rollup files and will
+ * automatically use these when appropriate in order to minimize the number of
+ * http connections required to load all of the dependencies. It can load the
+ * files from the Yahoo! CDN, and it can utilize the combo service provided on
+ * this network to reduce the number of http connections required to download
+ * YUI files.
+ *
+ * @module yui
+ * @submodule loader
+ */
+
+/**
+ * Loader dynamically loads script and css files. It includes the dependency
+ * info for the version of the library in use, and will automatically pull in
+ * dependencies for the modules requested. It supports rollup files and will
+ * automatically use these when appropriate in order to minimize the number of
+ * http connections required to load all of the dependencies. It can load the
+ * files from the Yahoo! CDN, and it can utilize the combo service provided on
+ * this network to reduce the number of http connections required to download
+ * YUI files.
+ * @class Loader
+ * @constructor
+ * @param o an optional set of configuration options. Valid options:
+ * <ul>
+ * <li>base:
+ * The base dir</li>
+ * <li>secureBase:
+ * The secure base dir (not implemented)</li>
+ * <li>comboBase:
+ * The YUI combo service base dir. Ex: http://yui.yahooapis.com/combo?</li>
+ * <li>root:
+ * The root path to prepend to module names for the combo service. Ex: 2.5.2/build/</li>
+ * <li>filter:
+ *
+ * A filter to apply to result urls. This filter will modify the default
+ * path for all modules. The default path for the YUI library is the
+ * minified version of the files (e.g., event-min.js). The filter property
+ * can be a predefined filter or a custom filter. The valid predefined
+ * filters are:
+ * <dl>
+ * <dt>DEBUG</dt>
+ * <dd>Selects the debug versions of the library (e.g., event-debug.js).
+ * This option will automatically include the Logger widget</dd>
+ * <dt>RAW</dt>
+ * <dd>Selects the non-minified version of the library (e.g., event.js).</dd>
+ * </dl>
+ * You can also define a custom filter, which must be an object literal
+ * containing a search expression and a replace string:
+ * <pre>
+ * myFilter: {
+ * 'searchExp': "-min\\.js",
+ * 'replaceStr': "-debug.js"
+ * }
+ * </pre>
+ *
+ * </li>
+ * <li>filters: per-component filter specification. If specified for a given component, this overrides the filter config</li>
+ * <li>combine:
+ * Use the YUI combo service to reduce the number of http connections required to load your dependencies</li>
+ * <li>ignore:
+ * A list of modules that should never be dynamically loaded</li>
+ * <li>force:
+ * A list of modules that should always be loaded when required, even if already present on the page</li>
+ * <li>insertBefore:
+ * Node or id for a node that should be used as the insertion point for new nodes</li>
+ * <li>charset:
+ * charset for dynamic nodes (deprecated, use jsAttributes or cssAttributes)</li>
+ * <li>jsAttributes: object literal containing attributes to add to script nodes</li>
+ * <li>cssAttributes: object literal containing attributes to add to link nodes</li>
+ * <li>timeout:
+ * number of milliseconds before a timeout occurs when dynamically loading nodes. in not set, there is no timeout</li>
+ * <li>context:
+ * execution context for all callbacks</li>
+ * <li>onSuccess:
+ * callback for the 'success' event</li>
+ * <li>onFailure: callback for the 'failure' event</li>
+ * <li>onCSS: callback for the 'CSSComplete' event. When loading YUI components with CSS
+ * the CSS is loaded first, then the script. This provides a moment you can tie into to improve
+ * the presentation of the page while the script is loading.</li>
+ * <li>onTimeout:
+ * callback for the 'timeout' event</li>
+ * <li>onProgress:
+ * callback executed each time a script or css file is loaded</li>
+ * <li>modules:
+ * A list of module definitions. See Loader.addModule for the supported module metadata</li>
+ * </ul>
+ */
+
+// @TODO backed out the custom event changes so that the event system
+// isn't required in the seed build. If needed, we may want to
+// add them back if the event system is detected.
+
+
+/*
+ * Global loader queue
+ * @property _loaderQueue
+ * @type Queue
+ * @private
+ */
+YUI.Env._loaderQueue = YUI.Env._loaderQueue || new Y.Queue();
+
+var GLOBAL_ENV = YUI.Env,
+ GLOBAL_LOADED,
+ BASE = 'base',
+ CSS = 'css',
+ JS = 'js',
+ CSSRESET = 'cssreset',
+ CSSFONTS = 'cssfonts',
+ CSSGRIDS = 'cssgrids',
+ CSSBASE = 'cssbase',
+ CSS_AFTER = [CSSRESET, CSSFONTS, CSSGRIDS,
+ 'cssreset-context', 'cssfonts-context', 'cssgrids-context'],
+ YUI_CSS = ['reset', 'fonts', 'grids', BASE],
+ VERSION = Y.version,
+ ROOT = VERSION + '/build/',
+ CONTEXT = '-context',
+
+
+ ANIMBASE = 'anim-base',
+ DDDRAG = 'dd-drag',
+ DOM = 'dom',
+ DATASCHEMABASE = 'dataschema-base',
+ DATASOURCELOCAL = 'datasource-local',
+ DOMBASE = 'dom-base',
+ DOMSTYLE = 'dom-style',
+ DUMP = 'dump',
+ GET = 'get',
+ EVENT = 'event',
+ EVENTCUSTOM = 'event-custom',
+ IOBASE = 'io-base',
+ NODE = 'node',
+ NODEBASE = 'node-base',
+ OOP = 'oop',
+ SELECTORCSS2 = 'selector-css2',
+ SUBSTITUTE = 'substitute',
+ WIDGET = 'widget',
+ WIDGETPOSITION = 'widget-position',
+ YUIBASE = 'yui-base',
+
+ PLUGIN = 'plugin',
+
+ META = {
+
+ version: VERSION,
+
+ root: ROOT,
+
+ base: 'http://yui.yahooapis.com/' + ROOT,
+
+ comboBase: 'http://yui.yahooapis.com/combo?',
+
+ skin: {
+ defaultSkin: 'sam',
+ base: 'assets/skins/',
+ path: 'skin.css',
+ after: CSS_AFTER
+ //rollup: 3
+ },
+
+ modules: {
+
+ dom: {
+ requires: [OOP],
+ submodules: {
+
+ 'dom-base': {
+ requires: [OOP]
+ },
+
+ 'dom-style': {
+ requires: [DOMBASE]
+ },
+
+ 'dom-screen': {
+ requires: [DOMBASE, DOMSTYLE]
+ },
+
+ 'selector-native': {
+ requires: [DOMBASE]
+ },
+
+ 'selector-css2': {
+ requires: ['selector-native']
+ },
+
+ 'selector': {
+ requires: [DOMBASE]
+ }
+
+ },
+
+ plugins: {
+ 'selector-css3': {
+ requires: [SELECTORCSS2]
+ }
+ }
+ },
+
+ node: {
+ requires: [DOM, BASE],
+ expound: EVENT,
+
+ submodules: {
+ 'node-base': {
+ requires: [DOMBASE, BASE, SELECTORCSS2]
+ },
+
+ 'node-style': {
+ requires: [DOMSTYLE, NODEBASE]
+ },
+
+ 'node-screen': {
+ requires: ['dom-screen', NODEBASE]
+ }
+ },
+
+ plugins: {
+ 'node-event-simulate': {
+ requires: [NODEBASE, 'event-simulate']
+ }
+ }
+ },
+
+ anim: {
+ requires: [BASE, NODE],
+ submodules: {
+
+ 'anim-base': {
+ requires: [BASE, 'node-style']
+ },
+
+ 'anim-color': {
+ requires: [ANIMBASE]
+ },
+
+ 'anim-curve': {
+ requires: ['anim-xy']
+ },
+
+ 'anim-easing': {
+ requires: [ANIMBASE]
+ },
+
+ 'anim-scroll': {
+ requires: [ANIMBASE]
+ },
+
+ 'anim-xy': {
+ requires: [ANIMBASE, 'node-screen']
+ },
+
+ 'anim-node-plugin': {
+ requires: [NODE, ANIMBASE]
+ }
+ }
+ },
+
+ attribute: {
+ requires: [EVENTCUSTOM]
+ },
+
+ base: {
+ submodules: {
+
+ 'base-base': {
+ requires: ['attribute']
+ },
+
+ 'base-build': {
+ requires: ['base-base']
+ }
+ }
+ },
+
+ cache: {
+ requires: [PLUGIN]
+ },
+
+ compat: {
+ requires: [NODE, DUMP, SUBSTITUTE]
+ },
+
+ classnamemanager: {
+ requires: [YUIBASE]
+ },
+
+ collection: {
+ requires: [OOP]
+ },
+
+ console: {
+ requires: [WIDGET, SUBSTITUTE],
+ skinnable: true,
+ plugins: {
+ 'console-filters': {
+ requires: [PLUGIN],
+ skinnable: true
+ }
+ }
+ },
+
+ cookie: {
+ requires: [YUIBASE]
+ },
+
+ dataschema:{
+ submodules: {
+ 'dataschema-base': {
+ requires: [BASE]
+ },
+ 'dataschema-array': {
+ requires: [DATASCHEMABASE]
+ },
+ 'dataschema-json': {
+ requires: [DATASCHEMABASE, 'json']
+ },
+ 'dataschema-text': {
+ requires: [DATASCHEMABASE]
+ },
+ 'dataschema-xml': {
+ requires: [DATASCHEMABASE]
+ }
+ }
+ },
+
+ datasource:{
+ submodules: {
+ 'datasource-local': {
+ requires: [BASE]
+ },
+ 'datasource-arrayschema': {
+ requires: [DATASOURCELOCAL, PLUGIN, 'dataschema-array']
+ },
+ 'datasource-cache': {
+ requires: [DATASOURCELOCAL, 'cache']
+ },
+ 'datasource-function': {
+ requires: [DATASOURCELOCAL]
+ },
+ 'datasource-jsonschema': {
+ requires: [DATASOURCELOCAL, PLUGIN, 'dataschema-json']
+ },
+ 'datasource-polling': {
+ requires: [DATASOURCELOCAL]
+ },
+ 'datasource-get': {
+ requires: [DATASOURCELOCAL, GET]
+ },
+ 'datasource-textschema': {
+ requires: [DATASOURCELOCAL, PLUGIN, 'dataschema-text']
+ },
+ 'datasource-io': {
+ requires: [DATASOURCELOCAL, IOBASE]
+ },
+ 'datasource-xmlschema': {
+ requires: [DATASOURCELOCAL, PLUGIN, 'dataschema-xml']
+ }
+ }
+ },
+
+ datatype:{
+ submodules: {
+ 'datatype-date': {
+ requires: [YUIBASE]
+ },
+ 'datatype-number': {
+ requires: [YUIBASE]
+ },
+ 'datatype-xml': {
+ requires: [YUIBASE]
+ }
+ }
+ },
+
+ dd:{
+ submodules: {
+ 'dd-ddm-base': {
+ requires: [NODE, BASE]
+ },
+ 'dd-ddm':{
+ requires: ['dd-ddm-base']
+ },
+ 'dd-ddm-drop':{
+ requires: ['dd-ddm']
+ },
+ 'dd-drag':{
+ requires: ['dd-ddm-base']
+ },
+ 'dd-drop':{
+ requires: ['dd-ddm-drop']
+ },
+ 'dd-proxy':{
+ requires: [DDDRAG]
+ },
+ 'dd-constrain':{
+ requires: [DDDRAG]
+ },
+ 'dd-scroll':{
+ requires: [DDDRAG]
+ },
+ 'dd-plugin':{
+ requires: [DDDRAG],
+ optional: ['dd-constrain', 'dd-proxy']
+ },
+ 'dd-drop-plugin':{
+ requires: ['dd-drop']
+ }
+ }
+ },
+
+ dump: {
+ requires: [YUIBASE]
+ },
+
+ event: {
+ requires: [EVENTCUSTOM, NODE]
+ },
+
+ 'event-custom': {
+ requires: [OOP]
+ },
+
+ 'event-simulate': {
+ requires: [EVENT]
+ },
+
+ 'node-focusmanager': {
+ requires: [NODE, PLUGIN]
+ },
+
+ get: {
+ requires: [YUIBASE]
+ },
+
+ history: {
+ requires: [NODE]
+ },
+
+ imageloader: {
+ requires: [NODE]
+ },
+
+ io:{
+ submodules: {
+
+ 'io-base': {
+ requires: [EVENTCUSTOM]
+ },
+
+ 'io-xdr': {
+ requires: [IOBASE]
+ },
+
+ 'io-form': {
+ requires: [IOBASE, NODE]
+ },
+
+ 'io-upload-iframe': {
+ requires: [IOBASE, NODE]
+ },
+
+ 'io-queue': {
+ requires: [IOBASE, 'queue-promote']
+ }
+ }
+ },
+
+ json: {
+ submodules: {
+ 'json-parse': {
+ requires: [YUIBASE]
+ },
+
+ 'json-stringify': {
+ requires: [YUIBASE]
+ }
+ }
+ },
+
+ loader: {
+ requires: [GET]
+ },
+
+ 'node-menunav': {
+ requires: [NODE, 'classnamemanager', PLUGIN, 'node-focusmanager'],
+ skinnable: true
+ },
+
+ oop: {
+ requires: [YUIBASE]
+ },
+
+ overlay: {
+ requires: [WIDGET, WIDGETPOSITION, 'widget-position-ext', 'widget-stack', 'widget-stdmod'],
+ skinnable: true
+ },
+
+ plugin: {
+ requires: [BASE]
+ },
+
+ profiler: {
+ requires: [YUIBASE]
+ },
+
+ queue: {
+ submodules: {
+ 'queue-base': {
+ requires: [YUIBASE]
+ },
+ 'queue-run': {
+ requires: ['queue-base', EVENTCUSTOM]
+ }
+ },
+ plugins: {
+ 'queue-promote': { }
+ }
+ },
+
+ slider: {
+ requires: [WIDGET, 'dd-constrain'],
+ skinnable: true
+ },
+
+ stylesheet: {
+ requires: [YUIBASE]
+ },
+
+ substitute: {
+ optional: [DUMP]
+ },
+
+ widget: {
+ requires: [BASE, NODE, 'classnamemanager'],
+ plugins: {
+ 'widget-position': { },
+ 'widget-position-ext': {
+ requires: [WIDGETPOSITION]
+ },
+ 'widget-stack': {
+ skinnable: true
+ },
+ 'widget-stdmod': { }
+ },
+ skinnable: true
+ },
+
+ yui: {
+ supersedes: [YUIBASE, GET, 'loader', 'queue-base']
+ },
+
+ 'yui-base': { },
+
+ test: {
+ requires: [SUBSTITUTE, NODE, 'json', 'event-simulate']
+ }
+
+ }
+},
+
+_path = function(dir, file, type) {
+ return dir + '/' + file + '-min.' + (type || CSS);
+},
+
+_queue = YUI.Env._loaderQueue,
+
+mods = META.modules, i, bname, mname, contextname,
+L = Y.Lang,
+PROV = "_provides",
+SUPER = "_supersedes";
+
+// Create the metadata for both the regular and context-aware
+// versions of the YUI CSS foundation.
+for (i=0; i<YUI_CSS.length; i=i+1) {
+ bname = YUI_CSS[i];
+ mname = CSS + bname;
+
+ mods[mname] = {
+ type: CSS,
+ path: _path(mname, bname)
+ };
+
+ // define -context module
+ contextname = mname + CONTEXT;
+ bname = bname + CONTEXT;
+
+ mods[contextname] = {
+ type: CSS,
+ path: _path(mname, bname)
+ };
+
+ if (mname == CSSGRIDS) {
+ mods[mname].requires = [CSSFONTS];
+ mods[mname].optional = [CSSRESET];
+ mods[contextname].requires = [CSSFONTS + CONTEXT];
+ mods[contextname].optional = [CSSRESET + CONTEXT];
+ } else if (mname == CSSBASE) {
+ mods[mname].after = CSS_AFTER;
+ mods[contextname].after = CSS_AFTER;
+ }
+}
+
+Y.Env.meta = META;
+
+GLOBAL_LOADED = GLOBAL_ENV._loaded;
+
+Y.Loader = function(o) {
+
+ /**
+ * Internal callback to handle multiple internal insert() calls
+ * so that css is inserted prior to js
+ * @property _internalCallback
+ * @private
+ */
+ this._internalCallback = null;
+
+ /**
+ * Use the YUI environment listener to detect script load. This
+ * is only switched on for Safari 2.x and below.
+ * @property _useYahooListener
+ * @private
+ */
+ this._useYahooListener = false;
+
+ /**
+ * Callback that will be executed when the loader is finished
+ * with an insert
+ * @method onSuccess
+ * @type function
+ */
+ this.onSuccess = null;
+
+ /**
+ * Callback that will be executed if there is a failure
+ * @method onFailure
+ * @type function
+ */
+ this.onFailure = null;
+
+ /**
+ * Callback for the 'CSSComplete' event. When loading YUI components with CSS
+ * the CSS is loaded first, then the script. This provides a moment you can tie into to improve
+ * the presentation of the page while the script is loading.
+ * @method onCSS
+ * @type function
+ */
+ this.onCSS = null;
+
+ /**
+ * Callback executed each time a script or css file is loaded
+ * @method onProgress
+ * @type function
+ */
+ this.onProgress = null;
+
+ /**
+ * Callback that will be executed if a timeout occurs
+ * @method onTimeout
+ * @type function
+ */
+ this.onTimeout = null;
+
+ /**
+ * The execution context for all callbacks
+ * @property context
+ * @default {YUI} the YUI instance
+ */
+ this.context = Y;
+
+ /**
+ * Data that is passed to all callbacks
+ * @property data
+ */
+ this.data = null;
+
+ /**
+ * Node reference or id where new nodes should be inserted before
+ * @property insertBefore
+ * @type string|HTMLElement
+ */
+ this.insertBefore = null;
+
+ /**
+ * The charset attribute for inserted nodes
+ * @property charset
+ * @type string
+ * @deprecated, use cssAttributes or jsAttributes
+ */
+ this.charset = null;
+
+ /**
+ * An object literal containing attributes to add to link nodes
+ * @property cssAttributes
+ * @type object
+ */
+ this.cssAttributes = null;
+
+ /**
+ * An object literal containing attributes to add to script nodes
+ * @property jsAttributes
+ * @type object
+ */
+ this.jsAttributes = null;
+
+ /**
+ * The base directory.
+ * @property base
+ * @type string
+ * @default http://yui.yahooapis.com/[YUI VERSION]/build/
+ */
+ this.base = Y.Env.meta.base;
+
+ /**
+ * Base path for the combo service
+ * @property comboBase
+ * @type string
+ * @default http://yui.yahooapis.com/combo?
+ */
+ this.comboBase = Y.Env.meta.comboBase;
+
+ /**
+ * If configured, YUI JS resources will use the combo
+ * handler
+ * @property combine
+ * @type boolean
+ * @default true if a base dir isn't in the config
+ */
+ this.combine = (!(BASE in o));
+
+ /**
+ * Ignore modules registered on the YUI global
+ * @property ignoreRegistered
+ * @default false
+ */
+ this.ignoreRegistered = false;
+
+ /**
+ * Root path to prepend to module path for the combo
+ * service
+ * @property root
+ * @type string
+ * @default [YUI VERSION]/build/
+ */
+ this.root = Y.Env.meta.root;
+
+ /**
+ * Timeout value in milliseconds. If set, this value will be used by
+ * the get utility. the timeout event will fire if
+ * a timeout occurs.
+ * @property timeout
+ * @type int
+ */
+ this.timeout = 0;
+
+ /**
+ * A list of modules that should not be loaded, even if
+ * they turn up in the dependency tree
+ * @property ignore
+ * @type string[]
+ */
+ this.ignore = null;
+
+ /**
+ * A list of modules that should always be loaded, even
+ * if they have already been inserted into the page.
+ * @property force
+ * @type string[]
+ */
+ this.force = null;
+
+ this.forceMap = {};
+
+ /**
+ * Should we allow rollups
+ * @property allowRollup
+ * @type boolean
+ * @default true
+ */
+ this.allowRollup = true;
+
+ /**
+ * A filter to apply to result urls. This filter will modify the default
+ * path for all modules. The default path for the YUI library is the
+ * minified version of the files (e.g., event-min.js). The filter property
+ * can be a predefined filter or a custom filter. The valid predefined
+ * filters are:
+ * <dl>
+ * <dt>DEBUG</dt>
+ * <dd>Selects the debug versions of the library (e.g., event-debug.js).
+ * This option will automatically include the Logger widget</dd>
+ * <dt>RAW</dt>
+ * <dd>Selects the non-minified version of the library (e.g., event.js).</dd>
+ * </dl>
+ * You can also define a custom filter, which must be an object literal
+ * containing a search expression and a replace string:
+ * <pre>
+ * myFilter: {
+ * 'searchExp': "-min\\.js",
+ * 'replaceStr': "-debug.js"
+ * }
+ * </pre>
+ * @property filter
+ * @type string|{searchExp: string, replaceStr: string}
+ */
+ this.filter = null;
+
+ /**
+ * per-component filter specification. If specified for a given component, this
+ * overrides the filter config.
+ * @property filters
+ * @type object
+ */
+ this.filters = {};
+
+ /**
+ * The list of requested modules
+ * @property required
+ * @type {string: boolean}
+ */
+ this.required = {};
+
+ /**
+ * The library metadata
+ * @property moduleInfo
+ */
+ // this.moduleInfo = Y.merge(Y.Env.meta.moduleInfo);
+ this.moduleInfo = {};
+
+ /**
+ * Provides the information used to skin the skinnable components.
+ * The following skin definition would result in 'skin1' and 'skin2'
+ * being loaded for calendar (if calendar was requested), and
+ * 'sam' for all other skinnable components:
+ *
+ * <code>
+ * skin: {
+ *
+ * // 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
+ * defaultSkin: 'sam',
+ *
+ * // This is combined with the loader base property to get
+ * // the default root directory for a skin. ex:
+ * // http://yui.yahooapis.com/2.3.0/build/assets/skins/sam/
+ * base: 'assets/skins/',
+ *
+ * // The name of the rollup css file for the skin
+ * path: 'skin.css',
+ *
+ * // The number of skinnable components requested that are
+ * // required before using the rollup file rather than the
+ * // individual component css files
+ * rollup: 3,
+ *
+ * // 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.
+ * overrides: {
+ * calendar: ['skin1', 'skin2']
+ * }
+ * }
+ * </code>
+ * @property skin
+ */
+ this.skin = Y.merge(Y.Env.meta.skin);
+
+ var defaults = Y.Env.meta.modules, i;
+
+ for (i in defaults) {
+ if (defaults.hasOwnProperty(i)) {
+ this._internal = true;
+ this.addModule(defaults[i], i);
+ this._internal = false;
+ }
+ }
+
+ /**
+ * List of rollup files found in the library metadata
+ * @property rollups
+ */
+ this.rollups = null;
+
+ /**
+ * Whether or not to load optional dependencies for
+ * the requested modules
+ * @property loadOptional
+ * @type boolean
+ * @default false
+ */
+ this.loadOptional = false;
+
+ /**
+ * All of the derived dependencies in sorted order, which
+ * will be populated when either calculate() or insert()
+ * is called
+ * @property sorted
+ * @type string[]
+ */
+ this.sorted = [];
+
+ /**
+ * Set when beginning to compute the dependency tree.
+ * Composed of what YUI reports to be loaded combined
+ * with what has been loaded by any instance on the page
+ * with the version number specified in the metadata.
+ * @propery loaded
+ * @type {string: boolean}
+ */
+ this.loaded = GLOBAL_LOADED[VERSION];
+
+ /**
+ * A list of modules to attach to the YUI instance when complete.
+ * If not supplied, the sorted list of dependencies are applied.
+ * @property attaching
+ */
+ this.attaching = null;
+
+ /**
+ * Flag to indicate the dependency tree needs to be recomputed
+ * if insert is called again.
+ * @property dirty
+ * @type boolean
+ * @default true
+ */
+ this.dirty = true;
+
+ /**
+ * List of modules inserted by the utility
+ * @property inserted
+ * @type {string: boolean}
+ */
+ this.inserted = {};
+
+ /**
+ * List of skipped modules during insert() because the module
+ * was not defined
+ * @property skipped
+ */
+ this.skipped = {};
+
+
+ // Y.on('yui:load', this.loadNext, this);
+
+ this._config(o);
+
+};
+
+Y.Loader.prototype = {
+
+ FILTER_DEFS: {
+ RAW: {
+ 'searchExp': "-min\\.js",
+ 'replaceStr': ".js"
+ },
+ DEBUG: {
+ 'searchExp': "-min\\.js",
+ 'replaceStr': "-debug.js"
+ }
+ },
+
+ SKIN_PREFIX: "skin-",
+
+ _config: function(o) {
+
+ var i, j, val, f;
+
+ // apply config values
+ if (o) {
+ for (i in o) {
+ if (o.hasOwnProperty(i)) {
+ val = o[i];
+ if (i == 'require') {
+ this.require(val);
+ } else if (i == 'modules') {
+
+ // add a hash of module definitions
+ for (j in val) {
+ if (val.hasOwnProperty(j)) {
+ this.addModule(val[j], j);
+ }
+ }
+
+ } else {
+ this[i] = val;
+ }
+ }
+ }
+ }
+
+ // fix filter
+ f = this.filter;
+
+ if (L.isString(f)) {
+ f = f.toUpperCase();
+ this.filterName = f;
+ this.filter = this.FILTER_DEFS[f];
+ }
+
+ },
+
+ /**
+ * Returns the skin module name for the specified skin name. If a
+ * module name is supplied, the returned skin module name is
+ * specific to the module passed in.
+ * @method formatSkin
+ * @param skin {string} the name of the skin
+ * @param mod {string} optional: the name of a module to skin
+ * @return {string} the full skin module name
+ */
+ formatSkin: function(skin, mod) {
+ var s = this.SKIN_PREFIX + skin;
+ if (mod) {
+ s = s + "-" + mod;
+ }
+
+ return s;
+ },
+
+ /*
+ * Reverses <code>formatSkin</code>, providing the skin name and
+ * module name if the string matches the pattern for skins.
+ * @method parseSkin
+ * @param mod {string} the module name to parse
+ * @return {skin: string, module: string} the parsed skin name
+ * and module name, or null if the supplied string does not match
+ * the skin pattern
+ *
+ * This isn't being used at the moment
+ *
+ */
+ // parseSkin: function(mod) {
+ //
+ // if (mod.indexOf(this.SKIN_PREFIX) === 0) {
+ // var a = mod.split("-");
+ // return {skin: a[1], module: a[2]};
+ // }
+ // return null;
+ // },
+
+ /**
+ * Adds the skin def to the module info
+ * @method _addSkin
+ * @param skin {string} the name of the skin
+ * @param mod {string} the name of the module
+ * @param parent {string} parent module if this is a skin of a
+ * submodule or plugin
+ * @return {string} the module name for the skin
+ * @private
+ */
+ _addSkin: function(skin, mod, parent) {
+
+ var name = this.formatSkin(skin),
+ info = this.moduleInfo,
+ sinf = this.skin,
+ ext = info[mod] && info[mod].ext,
+ mdef, pkg;
+
+ /*
+ // Add a module definition for the skin rollup css
+ if (!info[name]) {
+ this.addModule({
+ 'name': name,
+ 'type': 'css',
+ 'path': sinf.base + skin + '/' + sinf.path,
+ //'supersedes': '*',
+ 'after': sinf.after,
+ 'rollup': sinf.rollup,
+ 'ext': ext
+ });
+ }
+ */
+
+ // Add a module definition for the module-specific skin css
+ if (mod) {
+ name = this.formatSkin(skin, mod);
+ if (!info[name]) {
+ mdef = info[mod];
+ pkg = mdef.pkg || mod;
+ this.addModule({
+ 'name': name,
+ 'type': 'css',
+ 'after': sinf.after,
+ 'path': (parent || pkg) + '/' + sinf.base + skin + '/' + mod + '.css',
+ 'ext': ext
+ });
+ }
+ }
+
+ return name;
+ },
+
+ /** Add a new module to the component metadata.
+ * <dl>
+ * <dt>name:</dt> <dd>required, the component name</dd>
+ * <dt>type:</dt> <dd>required, the component type (js or css)</dd>
+ * <dt>path:</dt> <dd>required, the path to the script from "base"</dd>
+ * <dt>requires:</dt> <dd>array of modules required by this component</dd>
+ * <dt>optional:</dt> <dd>array of optional modules for this component</dd>
+ * <dt>supersedes:</dt> <dd>array of the modules this component replaces</dd>
+ * <dt>after:</dt> <dd>array of modules the components which, if present, should be sorted above this one</dd>
+ * <dt>rollup:</dt> <dd>the number of superseded modules required for automatic rollup</dd>
+ * <dt>fullpath:</dt> <dd>If fullpath is specified, this is used instead of the configured base + path</dd>
+ * <dt>skinnable:</dt> <dd>flag to determine if skin assets should automatically be pulled in</dd>
+ * <dt>submodules:</dt> <dd>a has of submodules</dd>
+ * </dl>
+ * @method addModule
+ * @param o An object containing the module data
+ * @param name the module name (optional), required if not in the module data
+ * @return {boolean} true if the module was added, false if
+ * the object passed in did not provide all required attributes
+ */
+ addModule: function(o, name) {
+
+ name = name || o.name;
+ o.name = name;
+
+ if (!o || !o.name) {
+ return false;
+ }
+
+ if (!o.type) {
+ o.type = JS;
+ }
+
+ if (!o.path && !o.fullpath) {
+ // o.path = name + "/" + name + "-min." + o.type;
+ o.path = _path(name, name, o.type);
+ }
+
+ o.ext = ('ext' in o) ? o.ext : (this._internal) ? false : true;
+ o.requires = o.requires || [];
+
+
+ this.moduleInfo[name] = o;
+
+ // Handle submodule logic
+ var subs = o.submodules, i, l, sup, s, smod, plugins, plug;
+ if (subs) {
+ sup = [];
+ l = 0;
+
+ for (i in subs) {
+ if (subs.hasOwnProperty(i)) {
+ s = subs[i];
+ s.path = _path(name, i, o.type);
+ this.addModule(s, i);
+ sup.push(i);
+
+ if (o.skinnable) {
+ smod = this._addSkin(this.skin.defaultSkin, i, name);
+ sup.push(smod.name);
+ }
+
+ l++;
+ }
+ }
+
+ o.supersedes = sup;
+ o.rollup = Math.min(l-1, 4);
+ }
+
+ plugins = o.plugins;
+ if (plugins) {
+ for (i in plugins) {
+ if (plugins.hasOwnProperty(i)) {
+ plug = plugins[i];
+ plug.path = _path(name, i, o.type);
+ plug.requires = plug.requires || [];
+ plug.requires.push(name);
+ this.addModule(plug, i);
+ if (o.skinnable) {
+ this._addSkin(this.skin.defaultSkin, i, name);
+ }
+ }
+ }
+ }
+
+ this.dirty = true;
+
+ return o;
+ },
+
+ /**
+ * Add a requirement for one or more module
+ * @method require
+ * @param what {string[] | string*} the modules to load
+ */
+ require: function(what) {
+ var a = (typeof what === "string") ? arguments : what;
+ this.dirty = true;
+ Y.mix(this.required, Y.Array.hash(a));
+ },
+
+ /**
+ * Returns an object containing properties for all modules required
+ * in order to load the requested module
+ * @method getRequires
+ * @param mod The module definition from moduleInfo
+ */
+ getRequires: function(mod) {
+
+ if (!mod) {
+ return [];
+ }
+
+ if (!this.dirty && mod.expanded) {
+ return mod.expanded;
+ }
+
+ var i, d=[], r=mod.requires, o=mod.optional,
+ info=this.moduleInfo, m, j, add;
+
+ for (i=0; i<r.length; i=i+1) {
+ d.push(r[i]);
+ m = this.getModule(r[i]);
+ add = this.getRequires(m);
+ for (j=0;j<add.length;j=j+1) {
+ d.push(add[j]);
+ }
+ }
+
+ // get the requirements from superseded modules, if any
+ r=mod.supersedes;
+ if (r) {
+ for (i=0; i<r.length; i=i+1) {
+ d.push(r[i]);
+ m = this.getModule(r[i]);
+ add = this.getRequires(m);
+ for (j=0;j<add.length;j=j+1) {
+ d.push(add[j]);
+ }
+ }
+ }
+
+ if (o && this.loadOptional) {
+ for (i=0; i<o.length; i=i+1) {
+ d.push(o[i]);
+ add = this.getRequires(info[o[i]]);
+ for (j=0;j<add.length;j=j+1) {
+ d.push(add[j]);
+ }
+ }
+ }
+
+ mod.expanded = Y.Object.keys(Y.Array.hash(d));
+
+
+ return mod.expanded;
+ },
+
+
+ /**
+ * Returns an object literal of the modules the supplied module satisfies
+ * @method getProvides
+ * @param name{string} The name of the module
+ * @param notMe {string} don't add this module name, only include superseded modules
+ * @return what this module provides
+ */
+ getProvides: function(name, notMe) {
+ var addMe = !(notMe), ckey = (addMe) ? PROV : SUPER,
+ m = this.getModule(name), o = {},
+ s, done, me, i,
+
+ // use worker to break cycles
+ add = function(mm) {
+ if (!done[mm]) {
+ done[mm] = true;
+ // we always want the return value normal behavior
+ // (provides) for superseded modules.
+ Y.mix(o, me.getProvides(mm));
+ }
+
+ // else {
+ // }
+ };
+
+ if (!m) {
+ return o;
+ }
+
+ if (m[ckey]) {
+ return m[ckey];
+ }
+
+ s = m.supersedes;
+ done = {};
+ me = this;
+
+
+ // calculate superseded modules
+ if (s) {
+ for (i=0; i<s.length; i=i+1) {
+ add(s[i]);
+ }
+ }
+
+ // supersedes cache
+ m[SUPER] = o;
+ // provides cache
+ m[PROV] = Y.merge(o);
+ m[PROV][name] = true;
+
+
+ return m[ckey];
+ },
+
+
+ /**
+ * Calculates the dependency tree, the result is stored in the sorted
+ * property
+ * @method calculate
+ * @param o optional options object
+ */
+ calculate: function(o) {
+ if (o || this.dirty) {
+ this._config(o);
+ this._setup();
+ this._explode();
+ if (this.allowRollup && !this.combine) {
+ this._rollup();
+ }
+ this._reduce();
+ this._sort();
+
+
+ this.dirty = false;
+ }
+ },
+
+ /**
+ * Investigates the current YUI configuration on the page. By default,
+ * modules already detected will not be loaded again unless a force
+ * option is encountered. Called by calculate()
+ * @method _setup
+ * @private
+ */
+ _setup: function() {
+
+ var info = this.moduleInfo, name, i, j, m, o, l, smod;
+
+ // Create skin modules
+ for (name in info) {
+ if (info.hasOwnProperty(name)) {
+ m = info[name];
+ if (m && m.skinnable) {
+ o = this.skin.overrides;
+ if (o && o[name]) {
+ for (i=0; i<o[name].length; i=i+1) {
+ smod = this._addSkin(o[name][i], name);
+ }
+ } else {
+ smod = this._addSkin(this.skin.defaultSkin, name);
+ }
+
+ m.requires.push(smod);
+ }
+ }
+ }
+
+ l = Y.merge(this.inserted); // shallow clone
+
+ // available modules
+ if (!this.ignoreRegistered) {
+ Y.mix(l, GLOBAL_ENV.mods);
+ }
+
+
+ // add the ignore list to the list of loaded packages
+ if (this.ignore) {
+ // OU.appendArray(l, this.ignore);
+ Y.mix(l, Y.Array.hash(this.ignore));
+ }
+
+ // expand the list to include superseded modules
+ for (j in l) {
+ if (l.hasOwnProperty(j)) {
+ Y.mix(l, this.getProvides(j));
+ }
+ }
+
+ // remove modules on the force list from the loaded list
+ if (this.force) {
+ for (i=0; i<this.force.length; i=i+1) {
+ if (this.force[i] in l) {
+ delete l[this.force[i]];
+ }
+ }
+ }
+
+
+ Y.mix(this.loaded, l);
+
+ // this.loaded = l;
+
+ },
+
+
+ /**
+ * Inspects the required modules list looking for additional
+ * dependencies. Expands the required list to include all
+ * required modules. Called by calculate()
+ * @method _explode
+ * @private
+ */
+ _explode: function() {
+
+ var r=this.required, i, mod, req, me = this, f = function(name) {
+
+ mod = me.getModule(name);
+
+ var expound = mod && mod.expound;
+
+ if (mod) {
+
+ if (expound) {
+ r[expound] = me.getModule(expound);
+ req = me.getRequires(r[expound]);
+ Y.mix(r, Y.Array.hash(req));
+ }
+
+ req = me.getRequires(mod);
+
+ Y.mix(r, Y.Array.hash(req));
+ }
+ };
+
+
+ for (i in r) {
+ if (r.hasOwnProperty(i)) {
+ f(i);
+ }
+ }
+ },
+
+ getModule: function(name) {
+
+ var m = this.moduleInfo[name];
+
+ // create the default module
+ // if (!m) {
+ // m = this.addModule({ext: false}, name);
+ // }
+
+ return m;
+ },
+
+ /**
+ * Look for rollup packages to determine if all of the modules a
+ * rollup supersedes are required. If so, include the rollup to
+ * help reduce the total number of connections required. Called
+ * by calculate()
+ * @method _rollup
+ * @private
+ */
+ _rollup: function() {
+ var i, j, m, s, rollups={}, r=this.required, roll,
+ info = this.moduleInfo, rolled, c;
+
+ // find and cache rollup modules
+ if (this.dirty || !this.rollups) {
+ for (i in info) {
+ if (info.hasOwnProperty(i)) {
+ m = this.getModule(i);
+ // if (m && m.rollup && m.supersedes) {
+ if (m && m.rollup) {
+ rollups[i] = m;
+ }
+ }
+ }
+
+ this.rollups = rollups;
+ this.forceMap = (this.force) ? Y.Array.hash(this.force) : {};
+ }
+
+ // make as many passes as needed to pick up rollup rollups
+ for (;;) {
+ rolled = false;
+
+ // go through the rollup candidates
+ for (i in rollups) {
+
+ if (rollups.hasOwnProperty(i)) {
+
+ // there can be only one, unless forced
+ if (!r[i] && ((!this.loaded[i]) || this.forceMap[i])) {
+ m = this.getModule(i);
+ s = m.supersedes || [];
+ roll = false;
+
+ // @TODO remove continue
+ if (!m.rollup) {
+ continue;
+ }
+
+ c = 0;
+
+ // check the threshold
+ for (j=0;j<s.length;j=j+1) {
+
+
+ // if the superseded module is loaded, we can't load the rollup
+ // unless it has been forced
+ if (this.loaded[s[j]] && !this.forceMap[s[j]]) {
+ roll = false;
+ break;
+ // increment the counter if this module is required. if we are
+ // beyond the rollup threshold, we will use the rollup module
+ } else if (r[s[j]]) {
+ c++;
+ roll = (c >= m.rollup);
+ if (roll) {
+ break;
+ }
+ }
+ }
+
+ if (roll) {
+ // add the rollup
+ r[i] = true;
+ rolled = true;
+
+ // expand the rollup's dependencies
+ this.getRequires(m);
+ }
+ }
+ }
+ }
+
+ // if we made it here w/o rolling up something, we are done
+ if (!rolled) {
+ break;
+ }
+ }
+ },
+
+ /**
+ * Remove superceded modules and loaded modules. Called by
+ * calculate() after we have the mega list of all dependencies
+ * @method _reduce
+ * @private
+ */
+ _reduce: function() {
+
+ var i, j, s, m, r=this.required;
+ for (i in r) {
+
+ if (r.hasOwnProperty(i)) {
+
+ // remove if already loaded
+ if (this.loaded[i] && (!this.forceMap[i]) && !this.ignoreRegistered) {
+ delete r[i];
+
+ // remove anything this module supersedes
+ } else {
+
+ m = this.getModule(i);
+ s = m && m.supersedes;
+ if (s) {
+ for (j=0; j<s.length; j=j+1) {
+ if (s[j] in r) {
+ delete r[s[j]];
+ }
+ }
+ }
+ }
+ }
+ }
+ },
+
+ _attach: function() {
+
+ // this is the full list of items the YUI needs attached,
+ // which is needed if some dependencies are already on
+ // the page without their dependencies.
+ if (this.attaching) {
+ Y._attach(this.attaching);
+ } else {
+ Y._attach(this.sorted);
+ }
+
+ // this._pushEvents();
+
+ },
+
+ _finish: function() {
+ _queue.running = false;
+ this._continue();
+ },
+
+ _onSuccess: function() {
+
+
+ this._attach();
+
+ var skipped = this.skipped, i, f;
+
+ for (i in skipped) {
+ if (skipped.hasOwnProperty(i)) {
+ delete this.inserted[i];
+ }
+ }
+
+ this.skipped = {};
+
+ f = this.onSuccess;
+
+ if (f) {
+ f.call(this.context, {
+ msg: 'success',
+ data: this.data,
+ success: true
+ });
+ }
+
+ this._finish();
+
+ },
+
+ _onFailure: function(o) {
+
+
+ this._attach();
+
+ var f = this.onFailure;
+ if (f) {
+ f.call(this.context, {
+ msg: 'failure: ' + o.msg,
+ data: this.data,
+ success: false
+ });
+ }
+
+ this._finish();
+ },
+
+ _onTimeout: function() {
+
+
+ this._attach();
+
+ var f = this.onTimeout;
+ if (f) {
+ f.call(this.context, {
+ msg: 'timeout',
+ data: this.data,
+ success: false
+ });
+ }
+
+ this._finish();
+ },
+
+ /**
+ * Sorts the dependency tree. The last step of calculate()
+ * @method _sort
+ * @private
+ */
+ _sort: function() {
+ // create an indexed list
+ var s=Y.Object.keys(this.required), info=this.moduleInfo, loaded=this.loaded,
+ p, l, a, b, j, k, moved,
+
+ // returns true if b is not loaded, and is required
+ // directly or by means of modules it supersedes.
+ requires = function(aa, bb) {
+
+ var mm = info[aa], ii, rr, after, other, ss;
+
+ if (loaded[bb] || !mm) {
+ return false;
+ }
+
+ rr = mm.expanded;
+ after = mm.after;
+ other = info[bb];
+
+ // check if this module requires the other directly
+ if (rr && Y.Array.indexOf(rr, bb) > -1) {
+ return true;
+ }
+
+ // check if this module should be sorted after the other
+ if (after && Y.Array.indexOf(after, bb) > -1) {
+ return true;
+ }
+
+ // check if this module requires one the other supersedes
+ ss = info[bb] && info[bb].supersedes;
+ if (ss) {
+ for (ii=0; ii<ss.length; ii=ii+1) {
+ if (requires(aa, ss[ii])) {
+ return true;
+ }
+ }
+ }
+
+ // external css files should be sorted below yui css
+ if (mm.ext && mm.type == CSS && !other.ext && other.type == CSS) {
+ return true;
+ }
+
+ return false;
+ };
+
+ // pointer to the first unsorted item
+ p = 0;
+
+ // keep going until we make a pass without moving anything
+ for (;;) {
+
+ l = s.length;
+ moved = false;
+
+ // start the loop after items that are already sorted
+ for (j=p; j<l; j=j+1) {
+
+ // check the next module on the list to see if its
+ // dependencies have been met
+ a = s[j];
+
+ // check everything below current item and move if we
+ // find a requirement for the current item
+ for (k=j+1; k<l; k=k+1) {
+ if (requires(a, s[k])) {
+
+ // extract the dependency so we can move it up
+ b = s.splice(k, 1);
+
+ // insert the dependency above the item that
+ // requires it
+ s.splice(j, 0, b[0]);
+
+ moved = true;
+ break;
+ }
+ }
+
+ // jump out of loop if we moved something
+ if (moved) {
+ break;
+ // this item is sorted, move our pointer and keep going
+ } else {
+ p = p + 1;
+ }
+ }
+
+ // when we make it here and moved is false, we are
+ // finished sorting
+ if (!moved) {
+ break;
+ }
+
+ }
+
+ this.sorted = s;
+ },
+
+ _insert: function(source, o, type) {
+
+
+ // restore the state at the time of the request
+ if (source) {
+ this._config(source);
+ }
+
+ // build the dependency list
+ this.calculate(o);
+
+ if (!type) {
+
+ var self = this;
+
+ this._internalCallback = function() {
+ var f = self.onCSS;
+ if (f) {
+ f.call(self.context, Y);
+ }
+ self._internalCallback = null;
+ self._insert(null, null, JS);
+ };
+
+ // _queue.running = false;
+ this._insert(null, null, CSS);
+
+ return;
+ }
+
+
+ // set a flag to indicate the load has started
+ this._loading = true;
+
+ // flag to indicate we are done with the combo service
+ // and any additional files will need to be loaded
+ // individually
+ this._combineComplete = {};
+
+ // keep the loadType (js, css or undefined) cached
+ this.loadType = type;
+
+ // start the load
+ this.loadNext();
+
+ },
+
+ _continue: function() {
+ if (!(_queue.running) && _queue.size() > 0) {
+ _queue.running = true;
+ _queue.next()();
+ }
+ },
+
+ /**
+ * inserts the requested modules and their dependencies.
+ * <code>type</code> can be "js" or "css". Both script and
+ * css are inserted if type is not provided.
+ * @method insert
+ * @param o optional options object
+ * @param type {string} the type of dependency to insert
+ */
+ insert: function(o, type) {
+
+ var self = this, copy;
+
+
+
+ copy = Y.merge(this, true);
+ delete copy.require;
+ delete copy.dirty;
+
+ _queue.add(function() {
+ self._insert(copy, o, type);
+ });
+
+ this._continue();
+
+ },
+
+ /**
+ * Executed every time a module is loaded, and if we are in a load
+ * cycle, we attempt to load the next script. Public so that it
+ * is possible to call this if using a method other than
+ * Y.register to determine when scripts are fully loaded
+ * @method loadNext
+ * @param mname {string} optional the name of the module that has
+ * been loaded (which is usually why it is time to load the next
+ * one)
+ */
+ loadNext: function(mname) {
+
+ // It is possible that this function is executed due to something
+ // else one the page loading a YUI module. Only react when we
+ // are actively loading something
+ if (!this._loading) {
+ return;
+ }
+
+ var s, len, i, m, url, self=this, type=this.loadType, fn, msg, attr,
+ callback=function(o) {
+ this._combineComplete[type] = true;
+
+
+ var c=this._combining, len=c.length, i;
+
+ for (i=0; i<len; i=i+1) {
+ this.inserted[c[i]] = true;
+ }
+
+ this.loadNext(o.data);
+ },
+ onsuccess=function(o) {
+ self.loadNext(o.data);
+ };
+
+ // @TODO this will need to handle the two phase insert when
+ // CSS support is added
+ if (this.combine && (!this._combineComplete[type])) {
+
+ this._combining = [];
+ s=this.sorted;
+ len=s.length;
+ url=this.comboBase;
+
+ for (i=0; i<len; i=i+1) {
+ m = this.getModule(s[i]);
+ // Do not try to combine non-yui JS
+ if (m && m.type === this.loadType && !m.ext) {
+ url += this.root + m.path;
+ if (i < len-1) {
+ url += '&';
+ }
+
+ this._combining.push(s[i]);
+ }
+ }
+
+ if (this._combining.length) {
+
+
+ // if (m.type === CSS) {
+ if (this.loadType === CSS) {
+ fn = Y.Get.css;
+ attr = this.cssAttributes;
+ } else {
+ fn = Y.Get.script;
+ attr = this.jsAttributes;
+ }
+
+ // @TODO get rid of the redundant Get code
+ fn(this._filter(url), {
+ data: this._loading,
+ onSuccess: callback,
+ onFailure: this._onFailure,
+ onTimeout: this._onTimeout,
+ insertBefore: this.insertBefore,
+ charset: this.charset,
+ attributes: attr,
+ timeout: this.timeout,
+ autopurge: false,
+ context: self
+ });
+
+ return;
+
+ } else {
+ this._combineComplete[type] = true;
+ }
+ }
+
+ if (mname) {
+
+ // if the module that was just loaded isn't what we were expecting,
+ // continue to wait
+ if (mname !== this._loading) {
+ return;
+ }
+
+
+ // The global handler that is called when each module is loaded
+ // will pass that module name to this function. Storing this
+ // data to avoid loading the same module multiple times
+ this.inserted[mname] = true;
+ this.loaded[mname] = true;
+
+ if (this.onProgress) {
+ this.onProgress.call(this.context, {
+ name: mname,
+ data: this.data
+ });
+ }
+
+
+ }
+
+ s=this.sorted;
+ len=s.length;
+
+ for (i=0; i<len; i=i+1) {
+
+ // this.inserted keeps track of what the loader has loaded.
+ // move on if this item is done.
+ if (s[i] in this.inserted) {
+ continue;
+ }
+
+ // Because rollups will cause multiple load notifications
+ // from Y, loadNext may be called multiple times for
+ // the same module when loading a rollup. We can safely
+ // skip the subsequent requests
+ if (s[i] === this._loading) {
+ return;
+ }
+
+ // log("inserting " + s[i]);
+ m = this.getModule(s[i]);
+
+ if (!m) {
+
+ msg = "Undefined module " + s[i] + " skipped";
+ this.inserted[s[i]] = true;
+ this.skipped[s[i]] = true;
+ continue;
+
+ }
+
+
+ // The load type is stored to offer the possibility to load
+ // the css separately from the script.
+ if (!type || type === m.type) {
+ this._loading = s[i];
+
+ if (m.type === CSS) {
+ fn = Y.Get.css;
+ attr = this.cssAttributes;
+ } else {
+ fn = Y.Get.script;
+ attr = this.jsAttributes;
+ }
+
+ url = (m.fullpath) ? this._filter(m.fullpath, s[i]) : this._url(m.path, s[i]);
+
+ fn(url, {
+ data: s[i],
+ onSuccess: onsuccess,
+ insertBefore: this.insertBefore,
+ charset: this.charset,
+ attributes: attr,
+ onFailure: this._onFailure,
+ onTimeout: this._onTimeout,
+ timeout: this.timeout,
+ autopurge: false,
+ context: self
+ });
+
+ return;
+ }
+ }
+
+ // we are finished
+ this._loading = null;
+
+ fn = this._internalCallback;
+
+ // internal callback for loading css first
+ if (fn) {
+ this._internalCallback = null;
+ fn.call(this);
+
+ // } else if (this.onSuccess) {
+ } else {
+ // call Y.use passing this instance. Y will use the sorted
+ // dependency list.
+ this._onSuccess();
+ }
+
+ },
+
+ /**
+ * Apply filter defined for this instance to a url/path
+ * method _filter
+ * @param u {string} the string to filter
+ * @param name {string} the name of the module, if we are processing
+ * a single module as opposed to a combined url
+ * @return {string} the filtered string
+ * @private
+ */
+ _filter: function(u, name) {
+
+ var f = this.filter,
+ hasFilter = name && (name in this.filters),
+ modFilter = hasFilter && this.filters[name];
+
+ if (u) {
+
+ if (hasFilter) {
+ f = (L.isString(modFilter)) ? this.FILTER_DEFS[modFilter.toUpperCase()] || null : modFilter;
+ }
+
+ if (f) {
+ u = u.replace(new RegExp(f.searchExp, 'g'), f.replaceStr);
+ }
+ }
+
+ return u;
+
+ },
+
+ /**
+ * Generates the full url for a module
+ * method _url
+ * @param path {string} the path fragment
+ * @return {string} the full url
+ * @private
+ */
+ _url: function(path, name) {
+ return this._filter((this.base || "") + path, name);
+ }
+
+};
+
+})();
+
+
+
+}, '3.0.0b1' ,{requires:['queue-base']});