Skip to content

Instantly share code, notes, and snippets.

@harlanji

harlanji/project.html

Created August 2, 2010 21:00
Show Gist options
  • Save harlanji/505298 to your computer and use it in GitHub Desktop.
Save harlanji/505298 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
another-util.js
// assembled module (order does not matter)
require.pause();
// maven layer
var groupId = "com.example";
var artifactId = "helper-util";
var version = "1.0.0";
var artifact = groupId + ":" + artifactId + ":" + version
// requirejs layer
var module = groupId + "/" + artifactId + "/another-util";
require.def( module,
function() {
return {
time: function() {
return new Date().toString();
}
};
}
);
require.resume();
Raw
legacy-util.js
// This file is evaluated immediately as it is loaded. this implicitly means
// that it should be available to whatever required it. however if it makes any
// async requests these can not be guarenteed to be loaded. but if that is the
// case then it should have its own mechanism to perform an action when they
// are completed that should be accessible by the depending module.
//alert("legacy loaded");
$legacy = {
// depend upon some library being loaded. this could easily extend to
// stuff on the window variable directly (another legacy script).
sayHello: function(anotherUtil) {
alert( "Greetings fair sir, it is now "+anotherUtil.time() );
},
doAsyncAction: function(fn) {
setTimeout(fn, 1000);
},
}
Raw
project.html
<!DOCTYPE html>
<html>
<head>
<title>My Sample Project</title>
<script src="scripts/require.js"></script>
<!-- This require() call will load project.js -->
<script>require(["project"]);</script>
</head>
<body>
<h1>My Sample Project</h1>
</body>
</html>
Raw
project.js
require(
{
paths: {
// "helper-util" : "com.example/helper-util",
},
},
[
"require",
"com.example/helper-util/util",
"com.example/helper-util/legacy-util",
// "helper-util/util",
// "helper-util/legacy-util",
], function(require, helperUtil, legacy) {
//This function is called when scripts/helper/util.js is loaded.
require.ready(function() {
//This function is called when the page is loaded (the DOMContentLoaded
//event) and when all required scripts are loaded.
//Do nested require() calls in here if you want to load code
//after page load.
helperUtil.sayHello();
require(["com.example/helper-util/another-util"], function(anotherUtil) {
$legacy.doAsyncAction(function() {
$legacy.sayHello( anotherUtil );
});
});
});
});
Raw
require.js
/**
* @license RequireJS Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
* Available via the MIT, GPL or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
//laxbreak is true to allow build pragmas to change some statements.
/*jslint plusplus: false, laxbreak: true */
/*global window: false, document: false, navigator: false,
setTimeout: false, traceDeps: true, clearInterval: false, self: false,
setInterval: false, importScripts: false */
var require;
(function () {
//Change this version number for each release.
var version = "0.12.0",
empty = {}, s,
i, defContextName = "_", contextLoads = [],
scripts, script, rePkg, src, m, cfg, setReadyState,
readyRegExp = /^(complete|loaded)$/,
isBrowser = !!(typeof window !== "undefined" && navigator && document),
isWebWorker = !isBrowser && typeof importScripts !== "undefined",
ostring = Object.prototype.toString, scrollIntervalId, req, baseElement;
function isFunction(it) {
return ostring.call(it) === "[object Function]";
}
//Check for an existing version of require. If so, then exit out. Only allow
//one version of require to be active in a page. However, allow for a require
//config object, just exit quickly if require is an actual function.
if (typeof require !== "undefined") {
if (isFunction(require)) {
return;
} else {
//assume it is a config object.
cfg = require;
}
}
function makeContextFunc(name, contextName, force) {
return function () {
//A version of a require function that uses the current context.
//If last arg is a string, then it is a context.
//If last arg is not a string, then add context to it.
var args = [].concat(Array.prototype.slice.call(arguments, 0));
if (force || typeof arguments[arguments.length - 1] !== "string") {
args.push(contextName);
}
return (name ? require[name] : require).apply(null, args);
};
}
/**
* Calls a method on a plugin. The obj object should have two property,
* name: the name of the method to call on the plugin
* args: the arguments to pass to the plugin method.
*/
function callPlugin(prefix, context, obj) {
//Call the plugin, or load it.
var plugin = s.plugins.defined[prefix], waiting;
if (plugin) {
plugin[obj.name].apply(null, obj.args);
} else {
//Put the call in the waiting call BEFORE requiring the module,
//since the require could be synchronous in some environments,
//like builds
waiting = s.plugins.waiting[prefix] || (s.plugins.waiting[prefix] = []);
waiting.push(obj);
//Load the module
context.defined.require(["require/" + prefix]);
}
}
/**
* Main entry point.
*
* If the only argument to require is a string, then the module that
* is represented by that string is fetched for the appropriate context.
*
* If the first argument is an array, then it will be treated as an array
* of dependency string names to fetch. An optional function callback can
* be specified to execute when all of those dependencies are available.
*/
require = function (deps, callback, contextName) {
if (typeof deps === "string" && !isFunction(callback)) {
//Just return the module wanted. In this scenario, the
//second arg (if passed) is just the contextName.
return require.get(deps, callback);
}
//Do more work, either
return require.def.apply(require, arguments);
};
//Alias for caja compliance internally -
//specifically: "Dynamically computed names should use require.async()"
//even though this spec isn't really decided on.
req = require;
/**
* The function that handles definitions of modules. Differs from
* require() in that a string for the module should be the first argument,
* and the function to execute after dependencies are loaded should
* return a value to define the module corresponding to the first argument's
* name.
*/
require.def = function (name, deps, callback, contextName) {
var config = null, context, newContext, contextRequire, loaded,
canSetContext, prop, newLength, outDeps,
mods, pluginPrefix, paths, index, i;
//Normalize the arguments.
if (typeof name === "string") {
//Defining a module. First, pull off any plugin prefix.
index = name.indexOf("!");
if (index !== -1) {
pluginPrefix = name.substring(0, index);
name = name.substring(index + 1, name.length);
}
//Check if there are no dependencies, and adjust args.
if (!require.isArray(deps)) {
contextName = callback;
callback = deps;
deps = [];
}
contextName = contextName || s.ctxName;
//If module already defined for context, or already waiting to be
//evaluated, leave.
context = s.contexts[contextName];
if (context && (context.defined[name] || context.waiting[name])) {
return require;
}
} else if (require.isArray(name)) {
//Just some code that has dependencies. Adjust args accordingly.
contextName = callback;
callback = deps;
deps = name;
name = null;
} else if (require.isFunction(name)) {
//Just a function that does not define a module and
//does not have dependencies. Useful if just want to wait
//for whatever modules are in flight and execute some code after
//those modules load.
callback = name;
contextName = deps;
name = null;
deps = [];
} else {
//name is a config object.
config = name;
name = null;
//Adjust args if no dependencies.
if (require.isFunction(deps)) {
contextName = callback;
callback = deps;
deps = [];
}
contextName = contextName || config.context;
}
contextName = contextName || s.ctxName;
if (contextName !== s.ctxName) {
//If nothing is waiting on being loaded in the current context,
//then switch s.ctxName to current contextName.
loaded = (s.contexts[s.ctxName] && s.contexts[s.ctxName].loaded);
canSetContext = true;
if (loaded) {
for (prop in loaded) {
if (!(prop in empty)) {
if (!loaded[prop]) {
canSetContext = false;
break;
}
}
}
}
if (canSetContext) {
s.ctxName = contextName;
}
}
//Grab the context, or create a new one for the given context name.
context = s.contexts[contextName];
if (!context) {
newContext = {
contextName: contextName,
config: {
waitSeconds: 7,
baseUrl: s.baseUrl || "./",
paths: {}
},
waiting: [],
specified: {
"require": true,
"exports": true,
"module": true
},
loaded: {
"require": true
},
urlFetched: {},
defined: {},
modifiers: {}
};
//Define require for this context.
newContext.defined.require = contextRequire = makeContextFunc(null, contextName);
require.mixin(contextRequire, {
modify: makeContextFunc("modify", contextName),
def: makeContextFunc("def", contextName),
get: makeContextFunc("get", contextName, true),
nameToUrl: makeContextFunc("nameToUrl", contextName, true),
ready: require.ready,
context: newContext,
config: newContext.config,
isBrowser: s.isBrowser
});
if (s.plugins.newContext) {
s.plugins.newContext(newContext);
}
context = s.contexts[contextName] = newContext;
}
//If have a config object, update the context's config object with
//the config values.
if (config) {
//Make sure the baseUrl ends in a slash.
if (config.baseUrl) {
if (config.baseUrl.charAt(config.baseUrl.length - 1) !== "/") {
config.baseUrl += "/";
}
}
//Save off the paths since they require special processing,
//they are additive.
paths = context.config.paths;
//Mix in the config values, favoring the new values over
//existing ones in context.config.
require.mixin(context.config, config, true);
//Adjust paths if necessary.
if (config.paths) {
for (prop in config.paths) {
if (!(prop in empty)) {
paths[prop] = config.paths[prop];
}
}
context.config.paths = paths;
}
//If priority loading is in effect, trigger the loads now
if (config.priority) {
//Create a separate config property that can be
//easily tested for config priority completion.
//Do this instead of wiping out the config.priority
//in case it needs to be inspected for debug purposes later.
req(config.priority);
context.config.priorityWait = config.priority;
}
//If a deps array or a config callback is specified, then call
//require with those args. This is useful when require is defined as a
//config object before require.js is loaded.
if (config.deps || config.callback) {
req(config.deps || [], config.callback);
}
//Set up ready callback, if asked. Useful when require is defined as a
//config object before require.js is loaded.
if (config.ready) {
require.ready(config.ready);
}
//If it is just a config block, nothing else,
//then return.
if (!deps) {
return require;
}
}
//Normalize dependency strings: need to determine if they have
//prefixes and to also normalize any relative paths. Replace the deps
//array of strings with an array of objects.
if (deps) {
outDeps = deps;
deps = [];
for (i = 0; i < outDeps.length; i++) {
deps[i] = require.splitPrefix(outDeps[i], name);
}
}
//Store the module for later evaluation
newLength = context.waiting.push({
name: name,
deps: deps,
callback: callback
});
if (name) {
//Store index of insertion for quick lookup
context.waiting[name] = newLength - 1;
//Mark the module as specified so no need to fetch it again.
//Important to set specified here for the
//pause/resume case where there are multiple modules in a file.
context.specified[name] = true;
//Load any modifiers for the module.
mods = context.modifiers[name];
if (mods) {
req(mods, contextName);
}
}
//If the callback is not an actual function, it means it already
//has the definition of the module as a literal value.
if (name && callback && !require.isFunction(callback)) {
context.defined[name] = callback;
}
//If a pluginPrefix is available, call the plugin, or load it.
if (pluginPrefix) {
callPlugin(pluginPrefix, context, {
name: "require",
args: [name, deps, callback, context]
});
}
//See if all is loaded. If paused, then do not check the dependencies
//of the module yet.
if (s.paused || context.config.priorityWait) {
(s.paused || (s.paused = [])).push([pluginPrefix, name, deps, context]);
} else {
require.checkDeps(pluginPrefix, name, deps, context);
require.checkLoaded(contextName);
}
//Set loaded here for modules that are also loaded
//as part of a layer, where onScriptLoad is not fired
//for those cases. Do this after the inline define and
//dependency tracing is done.
if (name) {
context.loaded[name] = true;
}
return require;
};
/**
* Simple function to mix in properties from source into target,
* but only if target does not already have a property of the same name.
*/
require.mixin = function (target, source, force) {
for (var prop in source) {
if (!(prop in empty) && (!(prop in target) || force)) {
target[prop] = source[prop];
}
}
return require;
};
require.version = version;
//Set up page state.
s = require.s = {
ctxName: defContextName,
contexts: {},
plugins: {
defined: {},
callbacks: {},
waiting: {}
},
//Stores a list of URLs that should not get async script tag treatment.
skipAsync: {},
isBrowser: isBrowser,
isPageLoaded: !isBrowser,
readyCalls: [],
doc: isBrowser ? document : null
};
require.isBrowser = s.isBrowser;
if (isBrowser) {
s.head = document.getElementsByTagName("head")[0];
//If BASE tag is in play, using appendChild is a problem for IE6.
//When that browser dies, this can be removed. Details in this jQuery bug:
//http://dev.jquery.com/ticket/2709
baseElement = document.getElementsByTagName("base")[0];
if (baseElement) {
s.head = baseElement.parentNode;
}
}
/**
* Sets up a plugin callback name. Want to make it easy to test if a plugin
* needs to be called for a certain lifecycle event by testing for
* if (s.plugins.onLifeCyleEvent) so only define the lifecycle event
* if there is a real plugin that registers for it.
*/
function makePluginCallback(name, returnOnTrue) {
var cbs = s.plugins.callbacks[name] = [];
s.plugins[name] = function () {
for (var i = 0, cb; (cb = cbs[i]); i++) {
if (cb.apply(null, arguments) === true && returnOnTrue) {
return true;
}
}
return false;
};
}
/**
* Registers a new plugin for require.
*/
require.plugin = function (obj) {
var i, prop, call, prefix = obj.prefix, cbs = s.plugins.callbacks,
waiting = s.plugins.waiting[prefix], generics,
defined = s.plugins.defined, contexts = s.contexts, context;
//Do not allow redefinition of a plugin, there may be internal
//state in the plugin that could be lost.
if (defined[prefix]) {
return require;
}
//Save the plugin.
defined[prefix] = obj;
//Set up plugin callbacks for methods that need to be generic to
//require, for lifecycle cases where it does not care about a particular
//plugin, but just that some plugin work needs to be done.
generics = ["newContext", "isWaiting", "orderDeps"];
for (i = 0; (prop = generics[i]); i++) {
if (!s.plugins[prop]) {
makePluginCallback(prop, prop === "isWaiting");
}
cbs[prop].push(obj[prop]);
}
//Call newContext for any contexts that were already created.
if (obj.newContext) {
for (prop in contexts) {
if (!(prop in empty)) {
context = contexts[prop];
obj.newContext(context);
}
}
}
//If there are waiting requests for a plugin, execute them now.
if (waiting) {
for (i = 0; (call = waiting[i]); i++) {
if (obj[call.name]) {
obj[call.name].apply(null, call.args);
}
}
delete s.plugins.waiting[prefix];
}
return require;
};
/**
* Pauses the tracing of dependencies. Useful in a build scenario when
* multiple modules are bundled into one file, and they all need to be
* require before figuring out what is left still to load.
*/
require.pause = function () {
if (!s.paused) {
s.paused = [];
}
};
/**
* Resumes the tracing of dependencies. Useful in a build scenario when
* multiple modules are bundled into one file. This method is related
* to require.pause() and should only be called if require.pause() was called first.
*/
require.resume = function () {
var i, args, paused;
//Skip the resume if current context is in priority wait.
if (s.contexts[s.ctxName].config.priorityWait) {
return;
}
if (s.paused) {
paused = s.paused;
delete s.paused;
for (i = 0; (args = paused[i]); i++) {
require.checkDeps.apply(require, args);
}
}
require.checkLoaded(s.ctxName);
};
/**
* Trace down the dependencies to see if they are loaded. If not, trigger
* the load.
* @param {String} pluginPrefix the plugin prefix, if any associated with the name.
*
* @param {String} name: the name of the module that has the dependencies.
*
* @param {Array} deps array of dependencies.
*
* @param {Object} context: the loading context.
*
* @private
*/
require.checkDeps = function (pluginPrefix, name, deps, context) {
//Figure out if all the modules are loaded. If the module is not
//being loaded or already loaded, add it to the "to load" list,
//and request it to be loaded.
var i, dep;
if (pluginPrefix) {
callPlugin(pluginPrefix, context, {
name: "checkDeps",
args: [name, deps, context]
});
} else {
for (i = 0; (dep = deps[i]); i++) {
if (!context.specified[dep.fullName]) {
context.specified[dep.fullName] = true;
//If a plugin, call its load method.
if (dep.prefix) {
callPlugin(dep.prefix, context, {
name: "load",
args: [dep.name, context.contextName]
});
} else {
require.load(dep.name, context.contextName);
}
}
}
}
};
/**
* Register a module that modifies another module. The modifier will
* only be called once the target module has been loaded.
*
* First syntax:
*
* require.modify({
* "some/target1": "my/modifier1",
* "some/target2": "my/modifier2",
* });
*
* With this syntax, the my/modifier1 will only be loaded when
* "some/target1" is loaded.
*
* Second syntax, defining a modifier.
*
* require.modify("some/target1", "my/modifier",
* ["some/target1", "some/other"],
* function (target, other) {
* //Modify properties of target here.
* Only properties of target can be modified, but
* target cannot be replaced.
* }
* );
*/
require.modify = function (target, name, deps, callback, contextName) {
var prop, modifier, list,
cName = (typeof target === "string" ? contextName : name) || s.ctxName,
context = s.contexts[cName],
mods = context.modifiers;
if (typeof target === "string") {
//A modifier module.
//First store that it is a modifier.
list = mods[target] || (mods[target] = []);
if (!list[name]) {
list.push(name);
list[name] = true;
}
//Trigger the normal module definition logic.
require.def(name, deps, callback, contextName);
} else {
//A list of modifiers. Save them for future reference.
for (prop in target) {
if (!(prop in empty)) {
//Store the modifier for future use.
modifier = target[prop];
list = context.modifiers[prop] || (context.modifiers[prop] = []);
if (!list[modifier]) {
list.push(modifier);
list[modifier] = true;
if (context.specified[prop]) {
//Load the modifier right away.
req([modifier], cName);
}
}
}
}
}
};
require.isArray = function (it) {
return ostring.call(it) === "[object Array]";
};
require.isFunction = isFunction;
/**
* Gets one module's exported value. This method is used by require().
* It is broken out as a separate function to allow a host environment
* shim to overwrite this function with something appropriate for that
* environment.
*
* @param {String} moduleName the name of the module.
* @param {String} [contextName] the name of the context to use. Uses
* default context if no contextName is provided.
*
* @returns {Object} the exported module value.
*/
require.get = function (moduleName, contextName) {
if (moduleName === "exports" || moduleName === "module") {
throw new Error("require of " + moduleName + " is not allowed.");
}
contextName = contextName || s.ctxName;
var ret = s.contexts[contextName].defined[moduleName];
if (ret === undefined) {
throw new Error("require: module name '" +
moduleName +
"' has not been loaded yet for context: " +
contextName);
}
return ret;
};
/**
* Makes the request to load a module. May be an async load depending on
* the environment and the circumstance of the load call. Override this
* method in a host environment shim to do something specific for that
* environment.
*
* @param {String} moduleName the name of the module.
* @param {String} contextName the name of the context to use.
*/
require.load = function (moduleName, contextName) {
var context = s.contexts[contextName],
urlFetched = context.urlFetched,
loaded = context.loaded, url;
s.isDone = false;
//Only set loaded to false for tracking if it has not already been set.
if (!loaded[moduleName]) {
loaded[moduleName] = false;
}
if (contextName !== s.ctxName) {
//Not in the right context now, hold on to it until
//the current context finishes all its loading.
contextLoads.push(arguments);
} else {
//First derive the path name for the module.
url = require.nameToUrl(moduleName, null, contextName);
if (!urlFetched[url]) {
require.attach(url, contextName, moduleName);
urlFetched[url] = true;
}
context.startTime = (new Date()).getTime();
}
};
require.jsExtRegExp = /\.js$/;
/**
* Given a relative module name, like ./something, normalize it to
* a real name that can be mapped to a path.
* @param {String} name the relative name
* @param {String} baseName a real name that the name arg is relative
* to.
* @returns {String} normalized name
*/
require.normalizeName = function (name, baseName) {
//Adjust any relative paths.
var part;
if (name.charAt(0) === ".") {
//Convert baseName to array, and lop off the last part,
//so that . matches that "directory" and not name of the baseName's
//module. For instance, baseName of "one/two/three", maps to
//"one/two/three.js", but we want the directory, "one/two" for
//this normalization.
baseName = baseName.split("/");
baseName = baseName.slice(0, baseName.length - 1);
name = baseName.concat(name.split("/"));
for (i = 0; (part = name[i]); i++) {
if (part === ".") {
name.splice(i, 1);
i -= 1;
} else if (part === "..") {
name.splice(i - 1, 2);
i -= 2;
}
}
name = name.join("/");
}
return name;
};
/**
* Splits a name into a possible plugin prefix and
* the module name. If baseName is provided it will
* also normalize the name via require.normalizeName()
*
* @param {String} name the module name
* @param {String} [baseName] base name that name is
* relative to.
*
* @returns {Object} with properties, 'prefix' (which
* may be null), 'name' and 'fullName', which is a combination
* of the prefix (if it exists) and the name.
*/
require.splitPrefix = function (name, baseName) {
var index = name.indexOf("!"), prefix = null;
if (index !== -1) {
prefix = name.substring(0, index);
name = name.substring(index + 1, name.length);
}
//Account for relative paths if there is a base name.
if (baseName) {
name = require.normalizeName(name, baseName);
}
return {
prefix: prefix,
name: name,
fullName: prefix ? prefix + "!" + name : name
};
};
/**
* Converts a module name to a file path.
*/
require.nameToUrl = function (moduleName, ext, contextName) {
var paths, syms, i, parentModule, url,
config = s.contexts[contextName].config;
//If a colon is in the URL, it indicates a protocol is used and it is just
//an URL to a file, or if it starts with a slash or ends with .js, it is just a plain file.
//The slash is important for protocol-less URLs as well as full paths.
if (moduleName.indexOf(":") !== -1 || moduleName.charAt(0) === '/' || require.jsExtRegExp.test(moduleName)) {
//Just a plain path, not module name lookup, so just return it.
return moduleName;
} else if (moduleName.charAt(0) === ".") {
throw new Error("require.nameToUrl does not handle relative module names (ones that start with '.' or '..')");
} else {
//A module that needs to be converted to a path.
paths = config.paths;
syms = moduleName.split("/");
//For each module name segment, see if there is a path
//registered for it. Start with most specific name
//and work up from it.
for (i = syms.length; i > 0; i--) {
parentModule = syms.slice(0, i).join("/");
if (paths[parentModule]) {
syms.splice(0, i, paths[parentModule]);
break;
}
}
//Join the path parts together, then figure out if baseUrl is needed.
url = syms.join("/") + (ext || ".js");
return ((url.charAt(0) === '/' || url.match(/^\w+:/)) ? "" : config.baseUrl) + url;
}
};
/**
* Checks if all modules for a context are loaded, and if so, evaluates the
* new ones in right dependency order.
*
* @private
*/
require.checkLoaded = function (contextName) {
var context = s.contexts[contextName || s.ctxName],
waitInterval = context.config.waitSeconds * 1000,
//It is possible to disable the wait interval by using waitSeconds of 0.
expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
loaded, defined = context.defined,
modifiers = context.modifiers, waiting, noLoads = "",
hasLoadedProp = false, stillLoading = false, prop, priorityDone,
priorityName,
pIsWaiting = s.plugins.isWaiting, pOrderDeps = s.plugins.orderDeps,
i, module, allDone, loads, loadArgs, err,
traced = {};
//If already doing a checkLoaded call,
//then do not bother checking loaded state.
if (context.isCheckLoaded) {
return;
}
//Determine if priority loading is done. If so clear the priority. If
//not, then do not check
if (context.config.priorityWait) {
priorityDone = true;
for (i = 0; (priorityName = context.config.priorityWait[i]); i++) {
if (!context.loaded[priorityName]) {
priorityDone = false;
break;
}
}
if (priorityDone) {
//Clean up priority and call resume, since it could have
//some waiting dependencies to trace.
delete context.config.priorityWait;
require.resume();
} else {
return;
}
}
//Signal that checkLoaded is being require, so other calls that could be triggered
//by calling a waiting callback that then calls require and then this function
//should not proceed. At the end of this function, if there are still things
//waiting, then checkLoaded will be called again.
context.isCheckLoaded = true;
//Grab waiting and loaded lists here, since it could have changed since
//this function was first called, for instance, by the require.resume()
waiting = context.waiting;
loaded = context.loaded;
//See if anything is still in flight.
for (prop in loaded) {
if (!(prop in empty)) {
hasLoadedProp = true;
if (!loaded[prop]) {
if (expired) {
noLoads += prop + " ";
} else {
stillLoading = true;
break;
}
}
}
}
//Check for exit conditions.
if (!hasLoadedProp && !waiting.length
&& (!pIsWaiting || !pIsWaiting(context))
) {
//If the loaded object had no items, then the rest of
//the work below does not need to be done.
context.isCheckLoaded = false;
return;
}
if (expired && noLoads) {
//If wait time expired, throw error of unloaded modules.
err = new Error("require.js load timeout for modules: " + noLoads);
err.requireType = "timeout";
err.requireModules = noLoads;
}
if (stillLoading) {
//Something is still waiting to load. Wait for it.
context.isCheckLoaded = false;
if (isBrowser || isWebWorker) {
setTimeout(function () {
require.checkLoaded(contextName);
}, 50);
}
return;
}
//Order the dependencies. Also clean up state because the evaluation
//of modules might create new loading tasks, so need to reset.
//Be sure to call plugins too.
context.waiting = [];
context.loaded = {};
//Call plugins to order their dependencies, do their
//module definitions.
if (pOrderDeps) {
pOrderDeps(context);
}
//Before defining the modules, give priority treatment to any modifiers
//for modules that are already defined.
for (prop in modifiers) {
if (!(prop in empty)) {
if (defined[prop]) {
require.execModifiers(prop, traced, waiting, context);
}
}
}
//Define the modules, doing a depth first search.
for (i = 0; (module = waiting[i]); i++) {
require.exec(module, traced, waiting, context);
}
//Indicate checkLoaded is now done.
context.isCheckLoaded = false;
if (context.waiting.length
|| (pIsWaiting && pIsWaiting(context))
) {
//More things in this context are waiting to load. They were probably
//added while doing the work above in checkLoaded, calling module
//callbacks that triggered other require calls.
require.checkLoaded(contextName);
} else if (contextLoads.length) {
//Check for other contexts that need to load things.
//First, make sure current context has no more things to
//load. After defining the modules above, new require calls
//could have been made.
loaded = context.loaded;
allDone = true;
for (prop in loaded) {
if (!(prop in empty)) {
if (!loaded[prop]) {
allDone = false;
break;
}
}
}
if (allDone) {
s.ctxName = contextLoads[0][1];
loads = contextLoads;
//Reset contextLoads in case some of the waiting loads
//are for yet another context.
contextLoads = [];
for (i = 0; (loadArgs = loads[i]); i++) {
require.load.apply(require, loadArgs);
}
}
} else {
//Make sure we reset to default context.
s.ctxName = defContextName;
s.isDone = true;
if (require.callReady) {
require.callReady();
}
}
};
/**
* Executes the modules in the correct order.
*
* @private
*/
require.exec = function (module, traced, waiting, context) {
//Some modules are just plain script files, abddo not have a formal
//module definition,
if (!module) {
return undefined;
}
var name = module.name, cb = module.callback, deps = module.deps, j, dep,
defined = context.defined, ret, args = [], depModule,
usingExports = false, depName;
//If already traced or defined, do not bother a second time.
if (name) {
if (traced[name] || name in defined) {
return defined[name];
}
//Mark this module as being traced, so that it is not retraced (as in a circular
//dependency)
traced[name] = true;
}
if (deps) {
for (j = 0; (dep = deps[j]); j++) {
depName = dep.name;
if (depName === "exports") {
//CommonJS module spec 1.1
depModule = defined[name] = {};
usingExports = true;
} else if (depName === "module") {
//CommonJS module spec 1.1
depModule = {
id: name,
uri: name ? require.nameToUrl(name, null, context.contextName) : undefined
};
} else {
//Get dependent module. It could not exist, for a circular
//dependency or if the loaded dependency does not actually call
//require. Favor not throwing an error here if undefined because
//we want to allow code that does not use require as a module
//definition framework to still work -- allow a web site to
//gradually update to contained modules. That is more
//important than forcing a throw for the circular dependency case.
depModule = depName in defined ? defined[depName] : (traced[depName] ? undefined : require.exec(waiting[waiting[depName]], traced, waiting, context));
}
args.push(depModule);
}
}
//Call the callback to define the module, if necessary.
cb = module.callback;
if (cb && require.isFunction(cb)) {
ret = require.execCb(name, cb, args);
if (name) {
if (usingExports) {
ret = defined[name];
} else {
if (name in defined) {
throw new Error(name + " has already been defined");
} else {
defined[name] = ret;
}
}
}
}
//Execute modifiers, if they exist.
require.execModifiers(name, traced, waiting, context);
return ret;
};
/**
* Executes a module callack function. Broken out as a separate function
* solely to allow the build system to sequence the files in the built
* layer in the right sequence.
* @param {String} name the module name.
* @param {Function} cb the module callback/definition function.
* @param {Array} args The arguments (dependent modules) to pass to callback.
*
* @private
*/
require.execCb = function (name, cb, args) {
return cb.apply(null, args);
};
/**
* Executes modifiers for the given module name.
* @param {String} target
* @param {Object} traced
* @param {Object} context
*
* @private
*/
require.execModifiers = function (target, traced, waiting, context) {
var modifiers = context.modifiers, mods = modifiers[target], mod, i;
if (mods) {
for (i = 0; i < mods.length; i++) {
mod = mods[i];
//Not all modifiers define a module, they might collect other modules.
//If it is just a collection it will not be in waiting.
if (mod in waiting) {
require.exec(waiting[waiting[mod]], traced, waiting, context);
}
}
delete modifiers[target];
}
};
/**
* callback for script loads, used to check status of loading.
*
* @param {Event} evt the event from the browser for the script
* that was loaded.
*
* @private
*/
require.onScriptLoad = function (evt) {
//Using currentTarget instead of target for Firefox 2.0's sake. Not
//all old browsers will be supported, but this one was easy enough
//to support and still makes sense.
var node = evt.currentTarget || evt.srcElement, contextName, moduleName;
if (evt.type === "load" || readyRegExp.test(node.readyState)) {
//Pull out the name of the module and the context.
contextName = node.getAttribute("data-requirecontext");
moduleName = node.getAttribute("data-requiremodule");
//Mark the module loaded. Must do it here in addition
//to doing it in require.def in case a script does
//not call require.def
s.contexts[contextName].loaded[moduleName] = true;
require.checkLoaded(contextName);
//Clean up script binding.
if (node.removeEventListener) {
node.removeEventListener("load", require.onScriptLoad, false);
} else {
//Probably IE.
node.detachEvent("onreadystatechange", require.onScriptLoad);
}
}
};
/**
* Attaches the script represented by the URL to the current
* environment. Right now only supports browser loading,
* but can be redefined in other environments to do the right thing.
* @param {String} url the url of the script to attach.
* @param {String} contextName the name of the context that wants the script.
* @param {moduleName} the name of the module that is associated with the script.
* @param {Function} [callback] optional callback, defaults to require.onScriptLoad
* @param {String} [type] optional type, defaults to text/javascript
*/
require.attach = function (url, contextName, moduleName, callback, type) {
var node, loaded;
if (isBrowser) {
//In the browser so use a script tag
callback = callback || require.onScriptLoad;
node = document.createElement("script");
node.type = type || "text/javascript";
node.charset = "utf-8";
//Use async so Gecko does not block on executing the script if something
//like a long-polling comet tag is being run first. Gecko likes
//to evaluate scripts in DOM order, even for dynamic scripts.
//It will fetch them async, but only evaluate the contents in DOM
//order, so a long-polling script tag can delay execution of scripts
//after it. But telling Gecko we expect async gets us the behavior
//we want -- execute it whenever it is finished downloading. Only
//Helps Firefox 3.6+
//Allow some URLs to not be fetched async. Mostly helps the order!
//plugin
if (!s.skipAsync[url]) {
node.setAttribute("async", "async");
}
node.setAttribute("data-requirecontext", contextName);
node.setAttribute("data-requiremodule", moduleName);
//Set up load listener.
if (node.addEventListener) {
node.addEventListener("load", callback, false);
} else {
//Probably IE.
node.attachEvent("onreadystatechange", callback);
}
node.src = url;
return baseElement ? s.head.insertBefore(node, baseElement) : s.head.appendChild(node);
} else if (isWebWorker) {
//In a web worker, use importScripts. This is not a very
//efficient use of importScripts, importScripts will block until
//its script is downloaded and evaluated. However, if web workers
//are in play, the expectation that a build has been done so that
//only one script needs to be loaded anyway. This may need to be
//reevaluated if other use cases become common.
loaded = s.contexts[contextName].loaded;
loaded[moduleName] = false;
importScripts(url);
//Just mark the script loaded, someone else will check dependencies
//when all done.
loaded[moduleName] = true;
}
return null;
};
//Determine what baseUrl should be if not already defined via a require config object
s.baseUrl = cfg && cfg.baseUrl;
if (isBrowser && (!s.baseUrl || !s.head)) {
//Figure out baseUrl. Get it from the script tag with require.js in it.
scripts = document.getElementsByTagName("script");
if (cfg && cfg.baseUrlMatch) {
rePkg = cfg.baseUrlMatch;
} else {
rePkg = /(allplugins-|transportD-)?require\.js(\W|$)/i;
}
for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) {
//Set the "head" where we can append children by
//using the script's parent.
if (!s.head) {
s.head = script.parentNode;
}
//Using .src instead of getAttribute to get an absolute URL.
//While using a relative URL will be fine for script tags, other
//URLs used for text! resources that use XHR calls might benefit
//from an absolute URL.
src = script.src;
if (src) {
m = src.match(rePkg);
if (m) {
s.baseUrl = src.substring(0, m.index);
break;
}
}
}
}
//****** START page load functionality ****************
/**
* Sets the page as loaded and triggers check for all modules loaded.
*/
require.pageLoaded = function () {
if (!s.isPageLoaded) {
s.isPageLoaded = true;
if (scrollIntervalId) {
clearInterval(scrollIntervalId);
}
//Part of a fix for FF < 3.6 where readyState was not set to
//complete so libraries like jQuery that check for readyState
//after page load where not getting initialized correctly.
//Original approach suggested by Andrea Giammarchi:
//http://webreflection.blogspot.com/2009/11/195-chars-to-help-lazy-loading.html
//see other setReadyState reference for the rest of the fix.
if (setReadyState) {
document.readyState = "complete";
}
require.callReady();
}
};
/**
* Internal function that calls back any ready functions. If you are
* integrating RequireJS with another library without require.ready support,
* you can define this method to call your page ready code instead.
*/
require.callReady = function () {
var callbacks = s.readyCalls, i, callback;
if (s.isPageLoaded && s.isDone && callbacks.length) {
s.readyCalls = [];
for (i = 0; (callback = callbacks[i]); i++) {
callback();
}
}
};
/**
* Registers functions to call when the page is loaded
*/
require.ready = function (callback) {
if (s.isPageLoaded && s.isDone) {
callback();
} else {
s.readyCalls.push(callback);
}
return require;
};
if (isBrowser) {
if (document.addEventListener) {
//Standards. Hooray! Assumption here that if standards based,
//it knows about DOMContentLoaded.
document.addEventListener("DOMContentLoaded", require.pageLoaded, false);
window.addEventListener("load", require.pageLoaded, false);
//Part of FF < 3.6 readystate fix (see setReadyState refs for more info)
if (!document.readyState) {
setReadyState = true;
document.readyState = "loading";
}
} else if (window.attachEvent) {
window.attachEvent("onload", require.pageLoaded);
//DOMContentLoaded approximation, as found by Diego Perini:
//http://javascript.nwbox.com/IEContentLoaded/
if (self === self.top) {
scrollIntervalId = setInterval(function () {
try {
//From this ticket:
//http://bugs.dojotoolkit.org/ticket/11106,
//In IE HTML Application (HTA), such as in a selenium test,
//javascript in the iframe can't see anything outside
//of it, so self===self.top is true, but the iframe is
//not the top window and doScroll will be available
//before document.body is set. Test document.body
//before trying the doScroll trick.
if (document.body) {
document.documentElement.doScroll("left");
require.pageLoaded();
}
} catch (e) {}
}, 30);
}
}
//Check if document already complete, and if so, just trigger page load
//listeners. NOTE: does not work with Firefox before 3.6. To support
//those browsers, manually call require.pageLoaded().
if (document.readyState === "complete") {
require.pageLoaded();
}
}
//****** END page load functionality ****************
//Set up default context. If require was a configuration object, use that as base config.
if (cfg) {
req(cfg);
}
}());
/**
* @license RequireJS i18n Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
* Available via the MIT, GPL or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint regexp: false, nomen: false, plusplus: false */
/*global require: false, navigator: false */
/**
* This plugin handles i18n! prefixed modules. It does the following:
*
* 1) A regular module can have a dependency on an i18n bundle, but the regular
* module does not want to specify what locale to load. So it just specifies
* the top-level bundle, like "i18n!nls/colors".
*
* This plugin will load the i18n bundle at nls/colors, see that it is a root/master
* bundle since it does not have a locale in its name. It will then try to find
* the best match locale available in that master bundle, then request all the
* locale pieces for that best match locale. For instance, if the locale is "en-us",
* then the plugin will ask for the "en-us", "en" and "root" bundles to be loaded
* (but only if they are specified on the master bundle).
*
* Once all the bundles for the locale pieces load, then it mixes in all those
* locale pieces into each other, then finally sets the context.defined value
* for the nls/colors bundle to be that mixed in locale.
*
* 2) A regular module specifies a specific locale to load. For instance,
* i18n!nls/fr-fr/colors. In this case, the plugin needs to load the master bundle
* first, at nls/colors, then figure out what the best match locale is for fr-fr,
* since maybe only fr or just root is defined for that locale. Once that best
* fit is found, all of its locale pieces need to have their bundles loaded.
*
* Once all the bundles for the locale pieces load, then it mixes in all those
* locale pieces into each other, then finally sets the context.defined value
* for the nls/fr-fr/colors bundle to be that mixed in locale.
*/
(function () {
//regexp for reconstructing the master bundle name from parts of the regexp match
//nlsRegExp.exec("foo/bar/baz/nls/en-ca/foo") gives:
//["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
//nlsRegExp.exec("foo/bar/baz/nls/foo") gives:
//["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
//so, if match[5] is blank, it means this is the top bundle definition.
var nlsRegExp = /(^.*(^|\/)nls(\/|$))([^\/]*)\/?([^\/]*)/,
empty = {};
function getWaiting(name, context) {
var nlswAry = context.nlsWaiting;
return nlswAry[name] ||
//Push a new waiting object on the nlsWaiting array, but also put
//a shortcut lookup by name to the object on the array.
(nlswAry[name] = nlswAry[(nlswAry.push({ _name: name}) - 1)]);
}
/**
* Makes sure all the locale pieces are loaded, and finds the best match
* for the requested locale.
*/
function resolveLocale(masterName, bundle, locale, context) {
//Break apart the locale to get the parts.
var i, parts, toLoad, nlsw, loc, val, bestLoc = "root";
parts = locale.split("-");
//Now see what bundles exist for each country/locale.
//Want to walk up the chain, so if locale is en-us-foo,
//look for en-us-foo, en-us, en, then root.
toLoad = [];
nlsw = getWaiting(masterName, context);
for (i = parts.length; i > -1; i--) {
loc = i ? parts.slice(0, i).join("-") : "root";
val = bundle[loc];
if (val) {
//Store which bundle to use for the default bundle definition.
if (locale === context.config.locale && !nlsw._match) {
nlsw._match = loc;
}
//Store the best match for the target locale
if (bestLoc === "root") {
bestLoc = loc;
}
//Track that the locale needs to be resolved with its parts.
//Mark what locale should be used when resolving.
nlsw[loc] = loc;
//If locale value is true, it means it is a resource that
//needs to be loaded. Track it to load if it has not already
//been asked for.
if (val === true) {
//split off the bundl name from master name and insert the
//locale before the bundle name. So, if masterName is
//some/path/nls/colors, then the locale fr-fr's bundle name should
//be some/path/nls/fr-fr/colors
val = masterName.split("/");
val.splice(-1, 0, loc);
val = val.join("/");
if (!context.specified[val] && !(val in context.loaded) && !context.defined[val]) {
toLoad.push(val);
}
}
}
}
//If locale was not an exact match, store the closest match for it.
if (bestLoc !== locale) {
if (context.defined[bestLoc]) {
//Already got it. Easy peasy lemon squeezy.
context.defined[locale] = context.defined[bestLoc];
} else {
//Need to wait for things to load then define it.
nlsw[locale] = bestLoc;
}
}
//Load any bundles that are still needed.
if (toLoad.length) {
context.defined.require(toLoad);
}
}
require.plugin({
prefix: "i18n",
/**
* This callback is prefix-specific, only gets called for this prefix
*/
require: function (name, deps, callback, context) {
var i, match, nlsw, bundle, master, toLoad, obj = context.defined[name];
//All i18n modules must match the nls module name structure.
match = nlsRegExp.exec(name);
//If match[5] is blank, it means this is the top bundle definition,
//so it does not have to be handled. Only deal with ones that have a locale
//(a match[4] value but no match[5])
if (match[5]) {
master = match[1] + match[5];
//Track what locale bundle need to be generated once all the modules load.
nlsw = getWaiting(master, context);
nlsw[match[4]] = match[4];
bundle = context.nls[master];
if (!bundle) {
//No master bundle yet, ask for it.
context.defined.require([master]);
bundle = context.nls[master] = {};
}
//For nls modules, the callback is just a regular object,
//so save it off in the bundle now.
bundle[match[4]] = callback;
} else {
//Integrate bundle into the nls area.
bundle = context.nls[name];
if (bundle) {
//A specific locale already started the bundle object.
//Do a mixin (which will not overwrite the locale property
//on the bundle that has the previously loaded locale's info)
require.mixin(bundle, obj);
} else {
bundle = context.nls[name] = obj;
}
context.nlsRootLoaded[name] = true;
//Make sure there are no locales waiting to be resolved.
toLoad = context.nlsToLoad[name];
if (toLoad) {
delete context.nlsToLoad[name];
for (i = 0; i < toLoad.length; i++) {
resolveLocale(name, bundle, toLoad[i], context);
}
}
resolveLocale(name, bundle, context.config.locale, context);
}
},
/**
* Called when a new context is defined. Use this to store
* context-specific info on it.
*/
newContext: function (context) {
require.mixin(context, {
nlsWaiting: [],
nls: {},
nlsRootLoaded: {},
nlsToLoad: {}
});
if (!context.config.locale) {
context.config.locale = typeof navigator === "undefined" ? "root" :
(navigator.language || navigator.userLanguage || "root").toLowerCase();
}
},
/**
* Called when a dependency needs to be loaded.
*/
load: function (name, contextName) {
//Make sure the root bundle is loaded, to check if we can support
//loading the requested locale, or if a different one needs
//to be chosen.
var masterName, context = require.s.contexts[contextName], bundle,
match = nlsRegExp.exec(name), locale = match[4];
//If match[5] is blank, it means this is the top bundle definition,
//so it does not have to be handled. Only deal with ones that have a locale
//(a match[4] value but no match[5])
if (match[5]) {
//locale-specific bundle
masterName = match[1] + match[5];
bundle = context.nls[masterName];
if (context.nlsRootLoaded[masterName] && bundle) {
resolveLocale(masterName, bundle, locale, context);
} else {
//Store this locale to figure out after masterName is loaded and load masterName.
(context.nlsToLoad[masterName] || (context.nlsToLoad[masterName] = [])).push(locale);
context.defined.require([masterName]);
}
} else {
//Top-level bundle. Just call regular load, if not already loaded
if (!context.nlsRootLoaded[name]) {
require.load(name, contextName);
}
}
},
/**
* Called when the dependencies of a module are checked.
*/
checkDeps: function (name, deps, context) {
//i18n bundles are always defined as objects for their "dependencies",
//and that object is already processed in the require method, no need to
//do work in here.
},
/**
* Called to determine if a module is waiting to load.
*/
isWaiting: function (context) {
return !!context.nlsWaiting.length;
},
/**
* Called when all modules have been loaded.
*/
orderDeps: function (context) {
//Clear up state since further processing could
//add more things to fetch.
var i, j, master, msWaiting, bundle, parts, moduleSuffix, mixed,
modulePrefix, loc, defLoc, locPart, nlsWaiting = context.nlsWaiting,
bestFit;
context.nlsWaiting = [];
context.nlsToLoad = {};
//First, properly mix in any nls bundles waiting to happen.
for (i = 0; (msWaiting = nlsWaiting[i]); i++) {
//Each property is a master bundle name.
master = msWaiting._name;
bundle = context.nls[master];
defLoc = null;
//Create the module name parts from the master name. So, if master
//is foo/nls/bar, then the parts should be prefix: "foo/nls",
// suffix: "bar", and the final locale's module name will be foo/nls/locale/bar
parts = master.split("/");
modulePrefix = parts.slice(0, parts.length - 1).join("/");
moduleSuffix = parts[parts.length - 1];
//Cycle through the locale props on the waiting object and combine
//the locales together.
for (loc in msWaiting) {
if (loc !== "_name" && !(loc in empty)) {
if (loc === "_match") {
//Found default locale to use for the top-level bundle name.
defLoc = msWaiting[loc];
} else if (msWaiting[loc] !== loc) {
//A "best fit" locale, store it off to the end and handle
//it at the end by just assigning the best fit value, since
//after this for loop, the best fit locale will be defined.
(bestFit || (bestFit = {}))[loc] = msWaiting[loc];
} else {
//Mix in the properties of this locale together.
//Split the locale into pieces.
mixed = {};
parts = loc.split("-");
for (j = parts.length; j > 0; j--) {
locPart = parts.slice(0, j).join("-");
if (locPart !== "root" && bundle[locPart]) {
require.mixin(mixed, bundle[locPart]);
}
}
if (bundle.root) {
require.mixin(mixed, bundle.root);
}
context.defined[modulePrefix + "/" + loc + "/" + moduleSuffix] = mixed;
}
}
}
//Finally define the default locale. Wait to the end of the property
//loop above so that the default locale bundle has been properly mixed
//together.
context.defined[master] = context.defined[modulePrefix + "/" + defLoc + "/" + moduleSuffix];
//Handle any best fit locale definitions.
if (bestFit) {
for (loc in bestFit) {
if (!(loc in empty)) {
context.defined[modulePrefix + "/" + loc + "/" + moduleSuffix] = context.defined[modulePrefix + "/" + bestFit[loc] + "/" + moduleSuffix];
}
}
}
}
}
});
}());
/**
* @license RequireJS text Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
* Available via the MIT, GPL or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint regexp: false, nomen: false, plusplus: false */
/*global require: false, XMLHttpRequest: false, ActiveXObject: false */
(function () {
var progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'],
xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im;
if (!require.textStrip) {
require.textStrip = function (text) {
//Strips <?xml ...?> declarations so that external SVG and XML
//documents can be added to a document without worry. Also, if the string
//is an HTML document, only the part inside the body tag is returned.
if (text) {
text = text.replace(xmlRegExp, "");
var matches = text.match(bodyRegExp);
if (matches) {
text = matches[1];
}
} else {
text = "";
}
return text;
};
}
//Upgrade require to add some methods for XHR handling. But it could be that
//this require is used in a non-browser env, so detect for existing method
//before attaching one.
if (!require.getXhr) {
require.getXhr = function () {
//Would love to dump the ActiveX crap in here. Need IE 6 to die first.
var xhr, i, progId;
if (typeof XMLHttpRequest !== "undefined") {
return new XMLHttpRequest();
} else {
for (i = 0; i < 3; i++) {
progId = progIds[i];
try {
xhr = new ActiveXObject(progId);
} catch (e) {}
if (xhr) {
progIds = [progId]; // so faster next time
break;
}
}
}
if (!xhr) {
throw new Error("require.getXhr(): XMLHttpRequest not available");
}
return xhr;
};
}
if (!require.fetchText) {
require.fetchText = function (url, callback) {
var xhr = require.getXhr();
xhr.open('GET', url, true);
xhr.onreadystatechange = function (evt) {
//Do not explicitly handle errors, those should be
//visible via console output in the browser.
if (xhr.readyState === 4) {
callback(xhr.responseText);
}
};
xhr.send(null);
};
}
require.plugin({
prefix: "text",
/**
* This callback is prefix-specific, only gets called for this prefix
*/
require: function (name, deps, callback, context) {
//No-op, require never gets these text items, they are always
//a dependency, see load for the action.
},
/**
* Called when a new context is defined. Use this to store
* context-specific info on it.
*/
newContext: function (context) {
require.mixin(context, {
text: {},
textWaiting: []
});
},
/**
* Called when a dependency needs to be loaded.
*/
load: function (name, contextName) {
//Name has format: some.module!filext!strip!text
//The strip and text parts are optional.
//if strip is present, then that means only get the string contents
//inside a body tag in an HTML string. For XML/SVG content it means
//removing the <?xml ...?> declarations so the content can be inserted
//into the current doc without problems.
//If text is present, it is the actual text of the file.
var strip = false, text = null, key, url, index = name.indexOf("."),
modName = name.substring(0, index), fullKey,
ext = name.substring(index + 1, name.length),
context = require.s.contexts[contextName],
tWaitAry = context.textWaiting;
index = ext.indexOf("!");
if (index !== -1) {
//Pull off the strip arg.
strip = ext.substring(index + 1, ext.length);
ext = ext.substring(0, index);
index = strip.indexOf("!");
if (index !== -1 && strip.substring(0, index) === "strip") {
//Pull off the text.
text = strip.substring(index + 1, strip.length);
strip = "strip";
} else if (strip !== "strip") {
//strip is actually the inlined text.
text = strip;
strip = null;
}
}
key = modName + "!" + ext;
fullKey = strip ? key + "!" + strip : key;
//Store off text if it is available for the given key and be done.
if (text !== null && !context.text[key]) {
context.defined[name] = context.text[key] = text;
return;
}
//If text is not available, load it.
if (!context.text[key] && !context.textWaiting[key] && !context.textWaiting[fullKey]) {
//Keep track that the fullKey needs to be resolved, during the
//orderDeps stage.
if (!tWaitAry[fullKey]) {
tWaitAry[fullKey] = tWaitAry[(tWaitAry.push({
name: name,
key: key,
fullKey: fullKey,
strip: !!strip
}) - 1)];
}
//Load the text.
url = require.nameToUrl(modName, "." + ext, contextName);
context.loaded[name] = false;
require.fetchText(url, function (text) {
context.text[key] = text;
context.loaded[name] = true;
require.checkLoaded(contextName);
});
}
},
/**
* Called when the dependencies of a module are checked.
*/
checkDeps: function (name, deps, context) {
//No-op, checkDeps never gets these text items, they are always
//a dependency, see load for the action.
},
/**
* Called to determine if a module is waiting to load.
*/
isWaiting: function (context) {
return !!context.textWaiting.length;
},
/**
* Called when all modules have been loaded.
*/
orderDeps: function (context) {
//Clear up state since further processing could
//add more things to fetch.
var i, dep, text, tWaitAry = context.textWaiting;
context.textWaiting = [];
for (i = 0; (dep = tWaitAry[i]); i++) {
text = context.text[dep.key];
context.defined[dep.name] = dep.strip ? require.textStrip(text) : text;
}
}
});
}());
/**
* @license RequireJS jsonp Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
* Available via the MIT, GPL or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint nomen: false, plusplus: false */
/*global require: false, setTimeout: false */
(function () {
var countId = 0;
//A place to hold callback functions
require._jsonp = {};
require.plugin({
prefix: "jsonp",
/**
* This callback is prefix-specific, only gets called for this prefix
*/
require: function (name, deps, callback, context) {
//No-op, require never gets these jsonp items, they are always
//a dependency, see load for the action.
},
/**
* Called when a new context is defined. Use this to store
* context-specific info on it.
*/
newContext: function (context) {
require.mixin(context, {
jsonpWaiting: []
});
},
/**
* Called when a dependency needs to be loaded.
*/
load: function (name, contextName) {
//Name has format: some/url?param1=value1&callback=?
//where the last question mark indicates where the jsonp callback
//function name needs to go.
var index = name.indexOf("?"),
url = name.substring(0, index),
params = name.substring(index + 1, name.length),
context = require.s.contexts[contextName],
data = {
name: name
},
funcName = "f" + (countId++),
head = require.s.head,
node = head.ownerDocument.createElement("script");
//Create JSONP callback function
require._jsonp[funcName] = function (value) {
data.value = value;
context.loaded[name] = true;
require.checkLoaded(contextName);
//Use a setTimeout for cleanup because some older IE versions vomit
//if removing a script node while it is being evaluated.
setTimeout(function () {
head.removeChild(node);
delete require._jsonp[funcName];
}, 15);
};
//Hold on to the data for later dependency resolution in orderDeps.
context.jsonpWaiting.push(data);
//Build up the full JSONP URL
url = require.nameToUrl(url, "?", contextName);
//nameToUrl call may or may not have placed an ending ? on the URL,
//be sure there is one and add the rest of the params.
url += (url.indexOf("?") === -1 ? "?" : "") + params.replace("?", "require._jsonp." + funcName);
context.loaded[name] = false;
node.type = "text/javascript";
node.charset = "utf-8";
node.src = url;
//Use async so Gecko does not block on executing the script if something
//like a long-polling comet tag is being run first. Gecko likes
//to evaluate scripts in DOM order, even for dynamic scripts.
//It will fetch them async, but only evaluate the contents in DOM
//order, so a long-polling script tag can delay execution of scripts
//after it. But telling Gecko we expect async gets us the behavior
//we want -- execute it whenever it is finished downloading. Only
//Helps Firefox 3.6+
node.setAttribute("async", "async");
head.appendChild(node);
},
/**
* Called when the dependencies of a module are checked.
*/
checkDeps: function (name, deps, context) {
//No-op, checkDeps never gets these jsonp items, they are always
//a dependency, see load for the action.
},
/**
* Called to determine if a module is waiting to load.
*/
isWaiting: function (context) {
return !!context.jsonpWaiting.length;
},
/**
* Called when all modules have been loaded.
*/
orderDeps: function (context) {
//Clear up state since further processing could
//add more things to fetch.
var i, dep, waitAry = context.jsonpWaiting;
context.jsonpWaiting = [];
for (i = 0; (dep = waitAry[i]); i++) {
context.defined[dep.name] = dep.value;
}
}
});
}());
/**
* @license RequireJS order Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
* Available via the MIT, GPL or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint nomen: false, plusplus: false */
/*global require: false, window: false, document: false, setTimeout: false */
(function () {
//Sadly necessary browser inference due to differences in the way
//that browsers load and execute dynamically inserted javascript
//and whether the script/cache method works.
//Currently, Gecko and Opera do not load/fire onload for scripts with
//type="script/cache" but they execute injected scripts in order
//unless the 'async' flag is present.
var supportsInOrderExecution = ((window.opera && Object.prototype.toString.call(window.opera) === "[object Opera]") ||
//If Firefox 2 does not have to be supported, then
//a better check may be:
//('mozIsLocallyAvailable' in window.navigator)
("MozAppearance" in document.documentElement.style)),
readyRegExp = /^(complete|loaded)$/;
//Callback used by the type="script/cache" callback that indicates a script
//has finished downloading.
function scriptCacheCallback(evt) {
var node = evt.currentTarget || evt.srcElement, i,
context, contextName, moduleName, waiting, cached;
if (evt.type === "load" || readyRegExp.test(node.readyState)) {
//Pull out the name of the module and the context.
contextName = node.getAttribute("data-requirecontext");
moduleName = node.getAttribute("data-requiremodule");
context = require.s.contexts[contextName];
waiting = context.orderWaiting;
cached = context.orderCached;
//Mark this cache request as loaded
cached[moduleName] = true;
//Find out how many ordered modules have loaded
for (i = 0; cached[waiting[i]]; i++) {}
if (i > 0) {
require(waiting.splice(0, i), contextName);
}
//If no other order cache items are in the queue, do some cleanup.
if (!waiting.length) {
context.orderCached = {};
}
//Remove this script tag from the DOM
//Use a setTimeout for cleanup because some older IE versions vomit
//if removing a script node while it is being evaluated.
setTimeout(function () {
node.parentNode.removeChild(node);
}, 15);
}
}
require.plugin({
prefix: "order",
/**
* This callback is prefix-specific, only gets called for this prefix
*/
require: function (name, deps, callback, context) {
//No-op, require never gets these order items, they are always
//a dependency, see load for the action.
},
/**
* Called when a new context is defined. Use this to store
* context-specific info on it.
*/
newContext: function (context) {
require.mixin(context, {
orderWaiting: [],
orderCached: {}
});
},
/**
* Called when a dependency needs to be loaded.
*/
load: function (name, contextName) {
var context = require.s.contexts[contextName],
url = require.nameToUrl(name, null, contextName);
//Make sure the async attribute is not set for any pathway involving
//this script.
require.s.skipAsync[url] = true;
if (supportsInOrderExecution) {
//Just a normal script tag append, but without async attribute
//on the script.
require([name], contextName);
} else {
//Credit to LABjs author Kyle Simpson for finding that scripts
//with type="script/cache" allow scripts to be downloaded into
//browser cache but not executed. Use that
//so that subsequent addition of a real type="text/javascript"
//tag will cause the scripts to be executed immediately in the
//correct order.
context.orderWaiting.push(name);
context.loaded[name] = false;
require.attach(url, contextName, name, scriptCacheCallback, "script/cache");
}
},
/**
* Called when the dependencies of a module are checked.
*/
checkDeps: function (name, deps, context) {
//No-op, checkDeps never gets these order items, they are always
//a dependency, see load for the action.
},
/**
* Called to determine if a module is waiting to load.
*/
isWaiting: function (context) {
return !!context.orderWaiting.length;
},
/**
* Called when all modules have been loaded. Not needed for this plugin.
* State is reset as part of scriptCacheCallback.
*/
orderDeps: function (context) {
}
});
}());
//Target build file for a require.js that has all of require's functionality,
//and includes specific plugins: i18n and text.
Raw
util.js
// assembled module (order does not matter)
require.pause();
// maven layer
var groupId = "com.example";
var artifactId = "helper-util";
var version = "1.0.0";
var artifact = groupId + ":" + artifactId + ":" + version
// requirejs layer
var module = groupId + "/" + artifactId + "/util";
require.def( module,
["i18n!" + module + "/nls/messages"],
function(messages) {
return {
color: "black",
size: "unisize",
sayHello: function() {
alert( messages.hello );
}
};
}
);
require.def("i18n!" + module + "/nls/messages", {
"root": {
hello: "Hello, RequireJS!",
},
"fr-fr" : true,
}
);
require.def("i18n!" + module + "/nls/fr-fr/messages", {
hello: "Bonjour, RequireJS!",
}
);
require.resume();
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment