mirror of
https://github.com/moodle/moodle.git
synced 2025-07-25 16:21:47 +02:00
1409 lines
43 KiB
JavaScript
Executable File
1409 lines
43 KiB
JavaScript
Executable File
/*
|
|
Copyright (c) 2007, Yahoo! Inc. All rights reserved.
|
|
Code licensed under the BSD License:
|
|
http://developer.yahoo.net/yui/license.txt
|
|
version: 2.3.0
|
|
*/
|
|
/**
|
|
* Provides dynamic loading for the YUI library. It includes the dependency
|
|
* info for the library, and will automatically pull in dependencies for
|
|
* the modules requested. It supports rollup files (such as utilities.js
|
|
* and yahoo-dom-event.js), and will automatically use these when
|
|
* appropriate in order to minimize the number of http connections
|
|
* required to load all of the dependencies.
|
|
*
|
|
* @module yuiloader
|
|
* @namespace YAHOO.util
|
|
*/
|
|
|
|
/**
|
|
* YUILoader provides dynamic loading for YUI.
|
|
* @class YAHOO.util.YUILoader
|
|
* @todo
|
|
* version management, automatic sandboxing
|
|
*/
|
|
(function() {
|
|
|
|
// Define YAHOO_config if it doesn't exist. Only relevant if YAHOO is not
|
|
// already on the page
|
|
if (typeof YAHOO_config === "undefined") {
|
|
YAHOO_config = {};
|
|
}
|
|
|
|
// YUI is locally scoped, only pieces of it will be referenced in YAHOO
|
|
// after YAHOO has been loaded.
|
|
var YUI = {
|
|
|
|
/*
|
|
* The library metadata for the current release The is the default
|
|
* value for YAHOO.util.YUILoader.moduleInfo
|
|
* @property YUIInfo
|
|
* @static
|
|
*/
|
|
info: {
|
|
|
|
'base': 'http://yui.yahooapis.com/2.3.0/build/',
|
|
|
|
'skin': {
|
|
'defaultSkin': 'sam',
|
|
'base': 'assets/skins/',
|
|
'path': 'skin.css',
|
|
'rollup': 3
|
|
},
|
|
|
|
'moduleInfo': {
|
|
|
|
'animation': {
|
|
'type': 'js',
|
|
'path': 'animation/animation-min.js',
|
|
'requires': ['dom', 'event']
|
|
},
|
|
|
|
'autocomplete': {
|
|
'type': 'js',
|
|
'path': 'autocomplete/autocomplete-min.js',
|
|
'requires': ['dom', 'event'],
|
|
'optional': ['connection', 'animation'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'button': {
|
|
'type': 'js',
|
|
'path': 'button/button-beta-min.js',
|
|
'requires': ['element'],
|
|
'optional': ['menu'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'calendar': {
|
|
'type': 'js',
|
|
'path': 'calendar/calendar-min.js',
|
|
'requires': ['event', 'dom'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'colorpicker': {
|
|
'type': 'js',
|
|
'path': 'colorpicker/colorpicker-beta-min.js',
|
|
'requires': ['slider', 'element'],
|
|
'optional': ['animation'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'connection': {
|
|
'type': 'js',
|
|
'path': 'connection/connection-min.js',
|
|
'requires': ['event']
|
|
},
|
|
|
|
'container': {
|
|
'type': 'js',
|
|
'path': 'container/container-min.js',
|
|
'requires': ['dom', 'event'],
|
|
// button is optional, but creates a circular dep
|
|
//'optional': ['dragdrop', 'animation', 'button'],
|
|
'optional': ['dragdrop', 'animation'],
|
|
'supersedes': ['containercore'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'containercore': {
|
|
'type': 'js',
|
|
'path': 'container/container_core-min.js',
|
|
'requires': ['dom', 'event']
|
|
},
|
|
|
|
'datasource': {
|
|
'type': 'js',
|
|
'path': 'datasource/datasource-beta-min.js',
|
|
'requires': ['event'],
|
|
'optional': ['connection']
|
|
},
|
|
|
|
'datatable': {
|
|
'type': 'js',
|
|
'path': 'datatable/datatable-beta-min.js',
|
|
'requires': ['element', 'datasource'],
|
|
'optional': ['calendar', 'dragdrop'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'dom': {
|
|
'type': 'js',
|
|
'path': 'dom/dom-min.js',
|
|
'requires': ['yahoo']
|
|
},
|
|
|
|
'dragdrop': {
|
|
'type': 'js',
|
|
'path': 'dragdrop/dragdrop-min.js',
|
|
'requires': ['dom', 'event']
|
|
},
|
|
|
|
'editor': {
|
|
'type': 'js',
|
|
'path': 'editor/editor-beta-min.js',
|
|
'requires': ['menu', 'container', 'element', 'button'],
|
|
'optional': ['animation', 'dragdrop'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'element': {
|
|
'type': 'js',
|
|
'path': 'element/element-beta-min.js',
|
|
'requires': ['dom', 'event']
|
|
},
|
|
|
|
'event': {
|
|
'type': 'js',
|
|
'path': 'event/event-min.js',
|
|
'requires': ['yahoo']
|
|
},
|
|
|
|
'fonts': {
|
|
'type': 'css',
|
|
'path': 'fonts/fonts-min.css'
|
|
},
|
|
|
|
'grids': {
|
|
'type': 'css',
|
|
'path': 'grids/grids-min.css',
|
|
'requires': ['fonts'],
|
|
'optional': ['reset']
|
|
},
|
|
|
|
'history': {
|
|
'type': 'js',
|
|
'path': 'history/history-beta-min.js',
|
|
'requires': ['event']
|
|
},
|
|
|
|
'imageloader': {
|
|
'type': 'js',
|
|
'path': 'imageloader/imageloader-experimental-min.js',
|
|
'requires': ['event', 'dom']
|
|
},
|
|
|
|
'logger': {
|
|
'type': 'js',
|
|
'path': 'logger/logger-min.js',
|
|
'requires': ['event', 'dom'],
|
|
'optional': ['dragdrop'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'menu': {
|
|
'type': 'js',
|
|
'path': 'menu/menu-min.js',
|
|
'requires': ['containercore'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'reset': {
|
|
'type': 'css',
|
|
'path': 'reset/reset-min.css'
|
|
},
|
|
|
|
'reset-fonts-grids': {
|
|
'type': 'css',
|
|
'path': 'reset-fonts-grids/reset-fonts-grids.css',
|
|
'supersedes': ['reset', 'fonts', 'grids']
|
|
},
|
|
|
|
'slider': {
|
|
'type': 'js',
|
|
'path': 'slider/slider-min.js',
|
|
'requires': ['dragdrop'],
|
|
'optional': ['animation']
|
|
},
|
|
|
|
'tabview': {
|
|
'type': 'js',
|
|
'path': 'tabview/tabview-min.js',
|
|
'requires': ['element'],
|
|
'optional': ['connection'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'treeview': {
|
|
'type': 'js',
|
|
'path': 'treeview/treeview-min.js',
|
|
'requires': ['event'],
|
|
'skinnable': true
|
|
},
|
|
|
|
'utilities': {
|
|
'type': 'js',
|
|
'path': 'utilities/utilities.js',
|
|
'supersedes': ['yahoo', 'event', 'dragdrop', 'animation', 'dom', 'connection', 'element', 'yahoo-dom-event'],
|
|
'rollup': 6
|
|
},
|
|
|
|
'yahoo': {
|
|
'type': 'js',
|
|
'path': 'yahoo/yahoo-min.js'
|
|
},
|
|
|
|
'yahoo-dom-event': {
|
|
'type': 'js',
|
|
'path': 'yahoo-dom-event/yahoo-dom-event.js',
|
|
'supersedes': ['yahoo', 'event', 'dom'],
|
|
'rollup': 3
|
|
},
|
|
|
|
'yuiloader': {
|
|
'type': 'js',
|
|
'path': 'yuiloader/yuiloader-beta-min.js'
|
|
},
|
|
|
|
'yuitest': {
|
|
'type': 'js',
|
|
'path': 'yuitest/yuitest-beta-min.js',
|
|
'requires': ['logger'],
|
|
'skinnable': true
|
|
}
|
|
}
|
|
}
|
|
,
|
|
|
|
// Simple utils since we can't count on YAHOO.lang being available.
|
|
ObjectUtil: {
|
|
appendArray: function(o, a) {
|
|
if (a) {
|
|
for (var i=0; i<a.length; i=i+1) {
|
|
o[a[i]] = true;
|
|
}
|
|
}
|
|
},
|
|
|
|
clone: function(o) {
|
|
var c = {};
|
|
for (var i in o) {
|
|
c[i] = o[i];
|
|
}
|
|
return c;
|
|
},
|
|
|
|
merge: function() {
|
|
var o={}, a=arguments, i, j;
|
|
for (i=0; i<a.length; i=i+1) {
|
|
|
|
for (j in a[i]) {
|
|
o[j] = a[i][j];
|
|
}
|
|
}
|
|
return o;
|
|
},
|
|
|
|
keys: function(o, ordered) {
|
|
var a=[], i;
|
|
for (i in o) {
|
|
a.push(i);
|
|
}
|
|
|
|
return a;
|
|
}
|
|
},
|
|
|
|
ArrayUtil: {
|
|
|
|
appendArray: function(a1, a2) {
|
|
Array.prototype.push.apply(a1, a2);
|
|
/*
|
|
for (var i=0; i<a2.length; i=i+1) {
|
|
a1.push(a2[i]);
|
|
}
|
|
*/
|
|
},
|
|
|
|
indexOf: function(a, val) {
|
|
for (var i=0; i<a.length; i=i+1) {
|
|
if (a[i] === val) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
},
|
|
|
|
toObject: function(a) {
|
|
var o = {};
|
|
for (var i=0; i<a.length; i=i+1) {
|
|
o[a[i]] = true;
|
|
}
|
|
|
|
return o;
|
|
},
|
|
|
|
/*
|
|
* Returns a unique array. Does not maintain order, which is fine
|
|
* for this application, and performs better than it would if it
|
|
* did.
|
|
*/
|
|
uniq: function(a) {
|
|
return YUI.ObjectUtil.keys(YUI.ArrayUtil.toObject(a));
|
|
}
|
|
},
|
|
|
|
|
|
// loader instances
|
|
loaders: [],
|
|
|
|
finishInit: function(yahooref) {
|
|
|
|
// YAHOO has been loaded either in this window or passed
|
|
// from the sandbox routine. Set up local references
|
|
// to the loader and module metadata in the YAHOO object
|
|
// in question so additional modules can be loaded.
|
|
|
|
yahooref = yahooref || YAHOO;
|
|
|
|
yahooref.env.YUIInfo=YUI.info;
|
|
yahooref.util.YUILoader=YUI.YUILoader;
|
|
|
|
},
|
|
|
|
/*
|
|
* Global handler for the module loaded event exposed by
|
|
* YAHOO
|
|
*/
|
|
onModuleLoaded: function(minfo) {
|
|
|
|
var mname = minfo.name, m;
|
|
|
|
for (var i=0; i<YUI.loaders.length; i=i+1) {
|
|
YUI.loaders[i].loadNext(mname);
|
|
}
|
|
|
|
//console.log(YAHOO.lang.dump(minfo));
|
|
|
|
},
|
|
|
|
/*
|
|
* Sets up the module metadata
|
|
*/
|
|
init: function() {
|
|
|
|
var c = YAHOO_config, o = c.load,
|
|
y_loaded = (typeof YAHOO !== "undefined" && YAHOO.env);
|
|
|
|
|
|
// add our listener to the existing YAHOO.env.listeners stack
|
|
if (y_loaded) {
|
|
|
|
YAHOO.env.listeners.push(YUI.onModuleLoaded);
|
|
|
|
// define a listener in YAHOO_config that YAHOO will pick up
|
|
// when it is loaded.
|
|
} else {
|
|
|
|
if (c.listener) {
|
|
YUI.cachedCallback = c.listener;
|
|
}
|
|
|
|
c.listener = function(minfo) {
|
|
YUI.onModuleLoaded(minfo);
|
|
if (YUI.cachedCallback) {
|
|
YUI.cachedCallback(minfo);
|
|
}
|
|
};
|
|
}
|
|
|
|
// Fetch the required modules immediately if specified
|
|
// in YAHOO_config. Otherwise detect YAHOO and fetch
|
|
// it if it doesn't exist so we have a place to put
|
|
// the loader. The problem with this is that it will
|
|
// prevent rollups from working
|
|
if (o || !y_loaded) {
|
|
|
|
o = o || {};
|
|
|
|
var loader = new YUI.YUILoader(o);
|
|
loader.onLoadComplete = function() {
|
|
|
|
YUI.finishInit();
|
|
|
|
if (o.onLoadComplete) {
|
|
|
|
loader._pushEvents();
|
|
o.onLoadComplete(loader);
|
|
}
|
|
|
|
|
|
};
|
|
|
|
// If no load was requested, we must load YAHOO
|
|
// so we have a place to put the loader
|
|
if (!y_loaded) {
|
|
loader.require("yahoo");
|
|
}
|
|
|
|
loader.insert(null, o);
|
|
} else {
|
|
YUI.finishInit();
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
YUI.YUILoader = function(o) {
|
|
|
|
// Inform the library that it is being injected
|
|
YAHOO_config.injecting = true;
|
|
|
|
o = o || {};
|
|
|
|
/**
|
|
* Internal callback to handle multiple internal insert() calls
|
|
* so that css is inserted prior to js
|
|
* @property _internalCallback
|
|
* @private
|
|
*/
|
|
this._internalCallback = null;
|
|
|
|
/**
|
|
* Callback that will be executed when the loader is finished
|
|
* with an insert
|
|
* @method onLoadComplete
|
|
* @type function
|
|
*/
|
|
this.onLoadComplete = null;
|
|
|
|
/**
|
|
* The base directory.
|
|
* @property base
|
|
* @type string
|
|
* @default build
|
|
*/
|
|
this.base = ("base" in o) ? o.base : YUI.info.base;
|
|
|
|
/**
|
|
* Should we allow rollups
|
|
* @property allowRollup
|
|
* @type boolean
|
|
* @default true
|
|
*/
|
|
this.allowRollup = ("allowRollup" in o) ? o.allowRollup : true;
|
|
|
|
/**
|
|
* Filter to apply to result url
|
|
* @property filter
|
|
* @type string|object
|
|
*/
|
|
this.filter = o.filter;
|
|
|
|
/**
|
|
* Create a sandbox rather than inserting into lib into.
|
|
* the current context. Not currently supported
|
|
* property sandbox
|
|
* @type boolean
|
|
* @default false
|
|
*/
|
|
this.sandbox = o.sandbox;
|
|
|
|
/**
|
|
* The list of requested modules
|
|
* @property required
|
|
* @type {string: boolean}
|
|
*/
|
|
this.required = {};
|
|
|
|
/**
|
|
* The library metadata
|
|
* @property moduleInfo
|
|
*/
|
|
this.moduleInfo = o.moduleInfo || YUI.info.moduleInfo;
|
|
|
|
/**
|
|
* 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 = o.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 YAHOO reports to be loaded combined
|
|
* with what has been loaded by the tool
|
|
* @propery loaded
|
|
* @type {string: boolean}
|
|
*/
|
|
this.loaded = {};
|
|
|
|
/**
|
|
* 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 = {};
|
|
|
|
|
|
/**
|
|
* 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 = o.skin || YUI.ObjectUtil.clone(YUI.info.skin);
|
|
|
|
|
|
if (o.require) {
|
|
this.require(o.require);
|
|
}
|
|
|
|
YUI.loaders.push(this);
|
|
};
|
|
|
|
YUI.YUILoader.prototype = {
|
|
|
|
FILTERS: {
|
|
RAW: {
|
|
'searchExp': "-min\\.js",
|
|
'replaceStr': ".js"
|
|
},
|
|
DEBUG: {
|
|
'searchExp': "-min\\.js",
|
|
'replaceStr': "-debug.js"
|
|
}
|
|
},
|
|
|
|
SKIN_PREFIX: "skin-",
|
|
|
|
/** Add a new module to the component metadata. The javascript
|
|
* component must also use YAHOO.register to notify the loader
|
|
* when it has been loaded, or a verifier function must be
|
|
* provided
|
|
* <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>the modules required by this component</dd>
|
|
* <dt>optional:</dt> <dd>the optional modules for this component</dd>
|
|
* <dt>supersedes:</dt> <dd>the modules this component replaces</dd>
|
|
* <dt>rollup:</dt> <dd>the number of superseded modules required for automatic rollup</dd>
|
|
* <dt>verifier:</dt> <dd>a function that is executed to determine when the module is fully loaded</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>
|
|
* </dl>
|
|
* @method addModule
|
|
* @param o An object containing 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) {
|
|
|
|
if (!o || !o.name || !o.type || (!o.path && !o.fullpath)) {
|
|
return false;
|
|
}
|
|
|
|
this.moduleInfo[o.name] = o;
|
|
this.dirty = true;
|
|
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* 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;
|
|
|
|
for (var i=0; i<a.length; i=i+1) {
|
|
this.required[a[i]] = true;
|
|
var s = this.parseSkin(a[i]);
|
|
if (s) {
|
|
this._addSkin(s.skin, s.module);
|
|
}
|
|
}
|
|
YUI.ObjectUtil.appendArray(this.required, a);
|
|
},
|
|
|
|
|
|
/**
|
|
* Adds the skin def to the module info
|
|
* @method _addSkin
|
|
* @private
|
|
*/
|
|
_addSkin: function(skin, mod) {
|
|
|
|
// Add a module definition for the skin rollup css
|
|
var name = this.formatSkin(skin);
|
|
if (!this.moduleInfo[name]) {
|
|
this.addModule({
|
|
'name': name,
|
|
'type': 'css',
|
|
'path': this.skin.base + skin + "/" + this.skin.path,
|
|
//'supersedes': '*',
|
|
'rollup': this.skin.rollup
|
|
});
|
|
}
|
|
|
|
// Add a module definition for the module-specific skin css
|
|
if (mod) {
|
|
name = this.formatSkin(skin, mod);
|
|
if (!this.moduleInfo[name]) {
|
|
this.addModule({
|
|
'name': name,
|
|
'type': 'css',
|
|
//'path': this.skin.base + skin + "/" + mod + ".css"
|
|
'path': mod + '/' + this.skin.base + skin + "/" + mod + ".css"
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* 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 (!this.dirty && mod.expanded) {
|
|
return mod.expanded;
|
|
}
|
|
|
|
mod.requires=mod.requires || [];
|
|
var i, d=[], r=mod.requires, o=mod.optional, s=mod.supersedes, info=this.moduleInfo;
|
|
for (i=0; i<r.length; i=i+1) {
|
|
d.push(r[i]);
|
|
YUI.ArrayUtil.appendArray(d, this.getRequires(info[r[i]]));
|
|
}
|
|
|
|
if (o && this.loadOptional) {
|
|
for (i=0; i<o.length; i=i+1) {
|
|
d.push(o[i]);
|
|
YUI.ArrayUtil.appendArray(d, this.getRequires(info[o[i]]));
|
|
}
|
|
}
|
|
|
|
mod.expanded = YUI.ArrayUtil.uniq(d);
|
|
|
|
return mod.expanded;
|
|
},
|
|
|
|
/**
|
|
* Returns an object literal of the modules the supplied module satisfies
|
|
* @method getProvides
|
|
* @param mod The module definition from moduleInfo
|
|
* @return what this module provides
|
|
*/
|
|
getProvides: function(name) {
|
|
var mod = this.moduleInfo[name];
|
|
|
|
var o = {};
|
|
o[name] = true;
|
|
s = mod && mod.supersedes;
|
|
|
|
YUI.ObjectUtil.appendArray(o, s);
|
|
|
|
// console.log(this.sorted + ", " + name + " provides " + YUI.ObjectUtil.keys(o));
|
|
|
|
return o;
|
|
},
|
|
|
|
/**
|
|
* Calculates the dependency tree, the result is stored in the sorted
|
|
* property
|
|
* @method calculate
|
|
* @param o optional options object
|
|
*/
|
|
calculate: function(o) {
|
|
if (this.dirty) {
|
|
|
|
this._setup(o);
|
|
this._explode();
|
|
this._skin();
|
|
if (this.allowRollup) {
|
|
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
|
|
* @param o optional options object
|
|
* @private
|
|
*/
|
|
_setup: function(o) {
|
|
|
|
o = o || {};
|
|
this.loaded = YUI.ObjectUtil.clone(this.inserted);
|
|
|
|
if (!this.sandbox && typeof YAHOO !== "undefined" && YAHOO.env) {
|
|
this.loaded = YUI.ObjectUtil.merge(this.loaded, YAHOO.env.modules);
|
|
}
|
|
|
|
// add the ignore list to the list of loaded packages
|
|
if (o.ignore) {
|
|
YUI.ObjectUtil.appendArray(this.loaded, o.ignore);
|
|
}
|
|
|
|
// remove modules on the force list from the loaded list
|
|
if (o.force) {
|
|
for (var i=0; i<o.force.length; i=i+1) {
|
|
if (o.force[i] in this.loaded) {
|
|
delete this.loaded[o.force[i]];
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* 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;
|
|
|
|
for (i in r) {
|
|
mod = this.moduleInfo[i];
|
|
if (mod) {
|
|
|
|
var req = this.getRequires(mod);
|
|
|
|
if (req) {
|
|
YUI.ObjectUtil.appendArray(r, req);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Sets up the requirements for the skin assets if any of the
|
|
* requested modules are skinnable
|
|
* @method _skin
|
|
* @private
|
|
*/
|
|
_skin: function() {
|
|
|
|
var r=this.required, i, mod;
|
|
|
|
for (i in r) {
|
|
mod = this.moduleInfo[i];
|
|
if (mod && mod.skinnable) {
|
|
var o=this.skin.override, j;
|
|
if (o && o[i]) {
|
|
for (j=0; j<o[i].length; j=j+1) {
|
|
this.require(this.formatSkin(o[i][j], i));
|
|
}
|
|
} else {
|
|
this.require(this.formatSkin(this.skin.defaultSkin, i));
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
parseSkin: function(mod) {
|
|
|
|
if (mod.indexOf(this.SKIN_PREFIX) === 0) {
|
|
var a = mod.split("-");
|
|
return {skin: a[1], module: a[2]};
|
|
}
|
|
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* 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;
|
|
|
|
// find and cache rollup modules
|
|
if (this.dirty || !this.rollups) {
|
|
for (i in this.moduleInfo) {
|
|
m = this.moduleInfo[i];
|
|
//if (m && m.rollup && m.supersedes) {
|
|
if (m && m.rollup) {
|
|
rollups[i] = m;
|
|
}
|
|
}
|
|
|
|
this.rollups = rollups;
|
|
}
|
|
|
|
// make as many passes as needed to pick up rollup rollups
|
|
for (;;) {
|
|
var rolled = false;
|
|
|
|
// go through the rollup candidates
|
|
for (i in rollups) {
|
|
|
|
// there can be only one
|
|
if (!r[i] && !this.loaded[i]) {
|
|
m =this.moduleInfo[i]; s = m.supersedes; roll=true;
|
|
|
|
if (!m.rollup) {
|
|
continue;
|
|
}
|
|
|
|
|
|
var skin = this.parseSkin(i), c = 0;
|
|
if (skin) {
|
|
|
|
for (j in r) {
|
|
if (i !== j && this.parseSkin(j)) {
|
|
c++;
|
|
roll = (c >= m.rollup);
|
|
if (roll) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
// require all modules to trigger a rollup (using the
|
|
// threshold value has not proved worthwhile)
|
|
for (j=0;j<s.length;j=j+1) {
|
|
|
|
// if the superseded module is loaded, we can't load the rollup
|
|
if (this.loaded[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) {
|
|
|
|
// remove if already loaded
|
|
if (i in this.loaded) {
|
|
delete r[i];
|
|
|
|
// remove anything this module supersedes
|
|
} else {
|
|
|
|
var skinDef = this.parseSkin(i);
|
|
|
|
if (skinDef) {
|
|
//console.log("skin found in reduce: " + skinDef.skin + ", " + skinDef.module);
|
|
// the skin rollup will not have a module name
|
|
if (!skinDef.module) {
|
|
var skin_pre = this.SKIN_PREFIX + skinDef.skin;
|
|
//console.log("skin_pre: " + skin_pre);
|
|
for (j in r) {
|
|
if (j !== i && j.indexOf(skin_pre) > -1) {
|
|
//console.log ("removing component skin: " + j);
|
|
delete r[j];
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
|
|
m = this.moduleInfo[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]];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Sorts the dependency tree. The last step of calculate()
|
|
* @method _sort
|
|
* @private
|
|
*/
|
|
_sort: function() {
|
|
// create an indexed list
|
|
var s=[], info=this.moduleInfo, loaded=this.loaded;
|
|
|
|
// returns true if b is not loaded, and is required
|
|
// directly or by means of modules it supersedes.
|
|
var requires = function(aa, bb) {
|
|
if (loaded[bb]) {
|
|
return false;
|
|
}
|
|
|
|
var ii, mm=info[aa], rr=mm && mm.expanded;
|
|
|
|
if (rr && YUI.ArrayUtil.indexOf(rr, bb) > -1) {
|
|
return true;
|
|
}
|
|
|
|
var ss=info[bb] && info[bb].supersedes;
|
|
if (ss) {
|
|
for (ii=0; ii<ss.length; ii=i+1) {
|
|
if (requires(aa, ss[ii])) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
// get the required items out of the obj into an array so we
|
|
// can sort
|
|
for (var i in this.required) {
|
|
s.push(i);
|
|
}
|
|
|
|
// pointer to the first unsorted item
|
|
var p=0;
|
|
|
|
// keep going until we make a pass without moving anything
|
|
for (;;) {
|
|
|
|
var l=s.length, a, b, j, k, 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;
|
|
},
|
|
|
|
/**
|
|
* 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 callback {Function} a function to execute when the load
|
|
* is complete.
|
|
* @param o optional options object
|
|
* @param type {string} the type of dependency to insert
|
|
*/
|
|
insert: function(callback, o, type) {
|
|
|
|
//if (!this.onLoadComplete) {
|
|
//this.onLoadComplete = callback;
|
|
//}
|
|
|
|
if (!type) {
|
|
var self = this;
|
|
this._internalCallback = function() {
|
|
self._internalCallback = null;
|
|
self.insert(callback, o, "js");
|
|
};
|
|
this.insert(null, o, "css");
|
|
return;
|
|
}
|
|
|
|
o = o || {};
|
|
|
|
// store the callback for when we are done
|
|
this.onLoadComplete = callback || this.onLoadComplete;
|
|
|
|
// store the optional filter
|
|
var f = o && o.filter || null;
|
|
|
|
if (typeof f === "string") {
|
|
f = f.toUpperCase();
|
|
|
|
// the logger must be available in order to use the debug
|
|
// versions of the library
|
|
if (f === "DEBUG") {
|
|
this.require("logger");
|
|
}
|
|
}
|
|
|
|
this.filter = this.FILTERS[f] || f || this.FILTERS[this.filter] || this.filter;
|
|
|
|
// store the options... not currently in use
|
|
this.insertOptions = o;
|
|
|
|
// build the dependency list
|
|
this.calculate(o);
|
|
|
|
// set a flag to indicate the load has started
|
|
this.loading = true;
|
|
|
|
// keep the loadType (js, css or undefined) cached
|
|
this.loadType = type;
|
|
|
|
// start the load
|
|
this.loadNext();
|
|
|
|
},
|
|
|
|
/**
|
|
* 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
|
|
* YAHOO.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) {
|
|
|
|
// console.log("loadNext executing, just loaded " + mname);
|
|
|
|
// 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
|
|
if (mname) {
|
|
this.inserted[mname] = true;
|
|
//var o = this.getProvides(mname);
|
|
//this.inserted = YUI.ObjectUtil.merge(this.inserted, o);
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
// if the module that was just loaded isn't what we were expecting,
|
|
// continue to wait
|
|
if (mname && mname !== this.loading) {
|
|
return;
|
|
}
|
|
|
|
var s=this.sorted, len=s.length, i, m, url;
|
|
|
|
for (i=0; i<len; i=i+1) {
|
|
|
|
// This.inserted keeps track of what the loader has loaded
|
|
if (s[i] in this.inserted) {
|
|
// console.log(s[i] + " alread loaded ");
|
|
continue;
|
|
}
|
|
|
|
// Because rollups will cause multiple load notifications
|
|
// from YAHOO, 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) {
|
|
// console.log("still loading " + s[i] + ", waiting");
|
|
return;
|
|
}
|
|
|
|
// log("inserting " + s[i]);
|
|
|
|
m = this.moduleInfo[s[i]];
|
|
|
|
// The load type is stored to offer the possibility to load
|
|
// the css separately from the script.
|
|
if (!this.loadType || this.loadType === m.type) {
|
|
this.loading = s[i];
|
|
|
|
// Insert the css node and continue. It is possible
|
|
// that the css file will load out of order ... this
|
|
// may be a problem that needs to be addressed, but
|
|
// unlike the script files, there is no notification
|
|
// mechanism in place for the css files.
|
|
if (m.type === "css") {
|
|
|
|
url = m.fullpath || this._url(m.path);
|
|
|
|
this.insertCss(url);
|
|
this.inserted[s[i]] = true;
|
|
|
|
// Scripts must be loaded in order, so we wait for the
|
|
// notification from YAHOO or a verifier function to
|
|
// process the next script
|
|
} else {
|
|
|
|
url = m.fullpath || this._url(m.path);
|
|
this.insertScript(url);
|
|
|
|
// if a verifier was included for this module, execute
|
|
// it, passing the name of the module, and a callback
|
|
// that must be exectued when the verifier is done.
|
|
if (m.verifier) {
|
|
var self = this, name=s[i];
|
|
m.verifier(name, function() {
|
|
self.loadNext(name);
|
|
});
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// we are finished
|
|
this.loading = null;
|
|
|
|
|
|
// internal callback for loading css first
|
|
if (this._internalCallback) {
|
|
var f = this._internalCallback;
|
|
this._internalCallback = null;
|
|
f(this);
|
|
} else if (this.onLoadComplete) {
|
|
this._pushEvents();
|
|
this.onLoadComplete(this);
|
|
}
|
|
|
|
},
|
|
|
|
/**
|
|
* In IE, the onAvailable/onDOMReady events need help when Event is
|
|
* loaded dynamically
|
|
* @method _pushEvents
|
|
* @private
|
|
*/
|
|
_pushEvents: function() {
|
|
if (typeof YAHOO !== "undefined" && YAHOO.util && YAHOO.util.Event) {
|
|
YAHOO.util.Event._load();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Generates the full url for a module
|
|
* method _url
|
|
* @param path {string} the path fragment
|
|
* @return {string} the full url
|
|
* @private
|
|
*/
|
|
_url: function(path) {
|
|
|
|
var u = this.base || "", f=this.filter;
|
|
u = u + path;
|
|
|
|
if (f) {
|
|
// console.log("filter: " + f + ", " + f.searchExp +
|
|
// ", " + f.replaceStr);
|
|
u = u.replace(new RegExp(f.searchExp), f.replaceStr);
|
|
}
|
|
|
|
// console.log(u);
|
|
|
|
return u;
|
|
},
|
|
|
|
/**
|
|
* Inserts a script node
|
|
* @method insertScript
|
|
* @param url {string} the full url for the script
|
|
* @param win {Window} optional window to target
|
|
*/
|
|
insertScript: function(url, win) {
|
|
|
|
//console.log("inserting script " + url);
|
|
var w = win || window, d=w.document, n=d.createElement("script"),
|
|
h = d.getElementsByTagName("head")[0];
|
|
|
|
n.src = url;
|
|
n.type = "text/javascript";
|
|
h.appendChild(n);
|
|
},
|
|
|
|
/**
|
|
* Inserts a css link node
|
|
* @method insertCss
|
|
* @param url {string} the full url for the script
|
|
* @param win {Window} optional window to target
|
|
*/
|
|
insertCss: function(url, win) {
|
|
// console.log("inserting css " + url);
|
|
var w = win || window, d=w.document, n=d.createElement("link"),
|
|
h = d.getElementsByTagName("head")[0];
|
|
|
|
n.href = url;
|
|
n.type = "text/css";
|
|
n.rel = "stylesheet";
|
|
h.appendChild(n);
|
|
},
|
|
|
|
/*
|
|
* Interns the script for the requested modules. The callback is
|
|
* provided a reference to the sandboxed YAHOO object. This only
|
|
* applies to the script: css can not be sandboxed. Not implemented.
|
|
* @method sandbox
|
|
* @param callback {Function} the callback to exectued when the load is
|
|
* complete.
|
|
* @notimplemented
|
|
*/
|
|
sandbox: function(callback) {
|
|
// this.calculate({
|
|
//sandbox: true
|
|
//});
|
|
}
|
|
};
|
|
|
|
YUI.init();
|
|
|
|
})();
|