loader_xd.js
No OneTemporary
Actions

Size

21 KB

Subscribers

None

loader_xd.js
View Options

	if(!dojo._hasResource["dojo._base._loader.loader_xd"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
	dojo._hasResource["dojo._base._loader.loader_xd"] = true;
	//Cross-domain resource loader.
	dojo.provide("dojo._base._loader.loader_xd");

	dojo._xdReset = function(){
	//summary: Internal xd loader function. Resets the xd state.

	//This flag indicates where or not we have crossed into xdomain territory. Once any resource says
	//it is cross domain, then the rest of the resources have to be treated as xdomain because we need
	//to evaluate resources in order. If there is a xdomain resource followed by a xhr resource, we can't load
	//the xhr resource until the one before it finishes loading. The text of the xhr resource will be converted
	//to match the format for a xd resource and put in the xd load queue.
	this._isXDomain = djConfig.useXDomain \|\| false;

	this._xdTimer = 0;
	this._xdInFlight = {};
	this._xdOrderedReqs = [];
	this._xdDepMap = {};
	this._xdContents = [];
	this._xdDefList = [];
	}

	//Call reset immediately to set the state.
	dojo._xdReset();

	dojo._xdCreateResource = function(/String/contents, /String/resourceName, /String/resourcePath){
	//summary: Internal xd loader function. Creates an xd module source given an
	//non-xd module contents.

	//Remove comments. Not perfect, but good enough for dependency resolution.
	var depContents = contents.replace(/(\/\([\s\S]?)\\/\|\/\/(.)$)/mg , "");

	//Find dependencies.
	var deps = [];
	var depRegExp = /dojo.(require\|requireIf\|provide\|requireAfterIf\|platformRequire\|requireLocalization)$([\w\W]*?)$/mg;
	var match;
	while((match = depRegExp.exec(depContents)) != null){
	if(match[1] == "requireLocalization"){
	//Need to load the local bundles asap, since they are not
	//part of the list of modules watched for loading.
	eval(match[0]);
	}else{
	deps.push('"' + match[1] + '", ' + match[2]);
	}
	}

	//Create resource object and the call to _xdResourceLoaded.
	var output = [];
	output.push("dojo._xdResourceLoaded({\n");

	//Add dependencies
	if(deps.length > 0){
	output.push("depends: [");
	for(var i = 0; i < deps.length; i++){
	if(i > 0){
	output.push(",\n");
	}
	output.push("[" + deps[i] + "]");
	}
	output.push("],");
	}

	//Add the contents of the file inside a function.
	//Pass in dojo as an argument to the function to help with
	//allowing multiple versions of dojo in a page.
	output.push("\ndefineResource: function(dojo){");

	//Don't put in the contents in the debugAtAllCosts case
	//since the contents may have syntax errors. Let those
	//get pushed up when the script tags are added to the page
	//in the debugAtAllCosts case.
	if(!djConfig["debugAtAllCosts"] \|\| resourceName == "dojo._base._loader.loader_debug"){
	output.push(contents);
	}
	//Add isLocal property so we know if we have to do something different
	//in debugAtAllCosts situations.
	output.push("\n}, resourceName: '" + resourceName + "', resourcePath: '" + resourcePath + "'});");

	return output.join(""); //String
	}

	dojo._xdIsXDomainPath = function(/string/relpath) {
	//summary: Figure out whether the path is local or x-domain
	//If there is a colon before the first / then, we have a URL with a protocol.

	var colonIndex = relpath.indexOf(":");
	var slashIndex = relpath.indexOf("/");

	if(colonIndex > 0 && colonIndex < slashIndex){
	return true;
	}else{
	//Is the base script URI-based URL a cross domain URL?
	//If so, then the relpath will be evaluated relative to
	//baseUrl, and therefore qualify as xdomain.
	//Only treat it as xdomain if the page does not have a
	//host (file:// url) or if the baseUrl does not match the
	//current window's domain.
	var url = this.baseUrl;
	colonIndex = url.indexOf(":");
	slashIndex = url.indexOf("/");
	if(colonIndex > 0 && colonIndex < slashIndex && (!location.host \|\| url.indexOf("http://" + location.host) != 0)){
	return true;
	}
	}
	return false;
	}

	dojo._loadPath = function(/String/relpath, /String?/module, /Function?/cb){
	//summary: Internal xd loader function. Overrides loadPath() from loader.js.
	//xd loading requires slightly different behavior from loadPath().

	var currentIsXDomain = this._xdIsXDomainPath(relpath);
	this._isXDomain \|= currentIsXDomain;

	var uri = this.baseUrl + relpath;
	if(currentIsXDomain){
	// check whether the relpath is an absolute URL itself. If so, we
	// ignore baseUrl
	var colonIndex = relpath.indexOf(":");
	var slashIndex = relpath.indexOf("/");
	if(colonIndex > 0 && colonIndex < slashIndex){
	uri = relpath;
	}
	}

	if(djConfig.cacheBust && dojo.isBrowser) { uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,""); }
	try{
	return ((!module \|\| this._isXDomain) ? this._loadUri(uri, cb, currentIsXDomain, module) : this._loadUriAndCheck(uri, module, cb)); //Boolean
	}catch(e){
	console.debug(e);
	return false; //Boolean
	}
	}

	dojo._loadUri = function(/String/uri, /Function?/cb, /boolean/currentIsXDomain, /String?/module){
	//summary: Internal xd loader function. Overrides loadUri() from loader.js.
	// xd loading requires slightly different behavior from loadPath().
	//description: Wanted to override getText(), but it is used by
	// the widget code in too many, synchronous ways right now.
	if(this._loadedUrls[uri]){
	return 1; //Boolean
	}

	//Add the module (resource) to the list of modules.
	//Only do this work if we have a modlue name. Otherwise,
	//it is a non-xd i18n bundle, which can load immediately and does not
	//need to be tracked. Also, don't track dojo.i18n, since it is a prerequisite
	//and will be loaded correctly if we load it right away: it has no dependencies.
	if(this._isXDomain && module && module != "dojo.i18n"){
	this._xdOrderedReqs.push(module);

	//Add to waiting resources if it is an xdomain resource.
	//Don't add non-xdomain i18n bundles, those get evaled immediately.
	if(currentIsXDomain \|\| uri.indexOf("/nls/") == -1){
	this._xdInFlight[module] = true;

	//Increment inFlightCount
	//This will stop the modulesLoaded from firing all the way.
	this._inFlightCount++;
	}

	//Start timer
	if(!this._xdTimer){
	this._xdTimer = setInterval("dojo._xdWatchInFlight();", 100);
	}
	this._xdStartTime = (new Date()).getTime();
	}

	if (currentIsXDomain){
	//Fix name to be a .xd.fileextension name.
	var lastIndex = uri.lastIndexOf('.');
	if(lastIndex <= 0){
	lastIndex = uri.length - 1;
	}

	var xdUri = uri.substring(0, lastIndex) + ".xd";
	if(lastIndex != uri.length - 1){
	xdUri += uri.substring(lastIndex, uri.length);
	}

	//Add to script src
	var element = document.createElement("script");
	element.type = "text/javascript";
	element.src = xdUri;
	if(!this.headElement){
	this._headElement = document.getElementsByTagName("head")[0];

	//Head element may not exist, particularly in html
	//html 4 or tag soup cases where the page does not
	//have a head tag in it. Use html element, since that will exist.
	//Seems to be an issue mostly with Opera 9 and to lesser extent Safari 2
	if(!this._headElement){
	this._headElement = document.getElementsByTagName("html")[0];
	}
	}
	this._headElement.appendChild(element);
	}else{
	var contents = this._getText(uri, null, true);
	if(contents == null){ return 0; /boolean/}

	//If this is not xdomain, or if loading a i18n resource bundle, then send it down
	//the normal eval/callback path.
	if(this._isXDomain
	&& uri.indexOf("/nls/") == -1
	&& module != "dojo.i18n"){
	var res = this._xdCreateResource(contents, module, uri);
	dojo.eval(res);
	}else{
	if(cb){ contents = '('+contents+')'; }
	var value = dojo.eval(contents);
	if(cb){
	cb(value);
	}
	}
	}

	//These steps are done in the non-xd loader version of this function.
	//Maintain these steps to fit in with the existing system.
	this._loadedUrls[uri] = true;
	this._loadedUrls.push(uri);
	return true; //Boolean
	}

	dojo._xdResourceLoaded = function(/Object/res){
	//summary: Internal xd loader function. Called by an xd module resource when
	//it has been loaded via a script tag.
	var deps = res.depends;
	var requireList = null;
	var requireAfterList = null;
	var provideList = [];
	if(deps && deps.length > 0){
	var dep = null;
	var insertHint = 0;
	var attachedResource = false;
	for(var i = 0; i < deps.length; i++){
	dep = deps[i];

	//Look for specific dependency indicators.
	if (dep[0] == "provide"){
	provideList.push(dep[1]);
	}else{
	if(!requireList){
	requireList = [];
	}
	if(!requireAfterList){
	requireAfterList = [];
	}

	var unpackedDeps = this._xdUnpackDependency(dep);
	if(unpackedDeps.requires){
	requireList = requireList.concat(unpackedDeps.requires);
	}
	if(unpackedDeps.requiresAfter){
	requireAfterList = requireAfterList.concat(unpackedDeps.requiresAfter);
	}
	}

	//Call the dependency indicator to allow for the normal dojo setup.
	//Only allow for one dot reference, for the i18n._preloadLocalizations calls
	//(and maybe future, one-dot things).
	var depType = dep[0];
	var objPath = depType.split(".");
	if(objPath.length == 2){
	dojo[objPath[0]][objPath[1]].apply(dojo[objPath[0]], dep.slice(1));
	}else{
	dojo[depType].apply(dojo, dep.slice(1));
	}
	}


	//If loading the debugAtAllCosts module, eval it right away since we need
	//its functions to properly load the other modules.
	if(provideList.length == 1 && provideList[0] == "dojo._base._loader.loader_debug"){
	res.defineResource(dojo);
	}else{
	//Save off the resource contents for definition later.
	var contentIndex = this._xdContents.push({
	content: res.defineResource,
	resourceName: res["resourceName"],
	resourcePath: res["resourcePath"],
	isDefined: false
	}) - 1;

	//Add provide/requires to dependency map.
	for(var i = 0; i < provideList.length; i++){
	this._xdDepMap[provideList[i]] = { requires: requireList, requiresAfter: requireAfterList, contentIndex: contentIndex };
	}
	}

	//Now update the inflight status for any provided resources in this loaded resource.
	//Do this at the very end (in a separate for loop) to avoid shutting down the
	//inflight timer check too soon.
	for(var i = 0; i < provideList.length; i++){
	this._xdInFlight[provideList[i]] = false;
	}
	}
	}

	dojo._xdLoadFlattenedBundle = function(/String/moduleName, /String/bundleName, /String?/locale, /Object/bundleData){
	//summary: Internal xd loader function. Used when loading
	//a flattened localized bundle via a script tag.
	locale = locale \|\| "root";
	var jsLoc = dojo.i18n.normalizeLocale(locale).replace('-', '_');
	var bundleResource = [moduleName, "nls", bundleName].join(".");
	var bundle = dojo["provide"](bundleResource);
	bundle[jsLoc] = bundleData;

	//Assign the bundle for the original locale(s) we wanted.
	var mapName = [moduleName, jsLoc, bundleName].join(".");
	var bundleMap = dojo._xdBundleMap[mapName];
	if(bundleMap){
	for(var param in bundleMap){
	bundle[param] = bundleData;
	}
	}
	};


	dojo._xdInitExtraLocales = function(){
	// Simulate the extra locale work that dojo.requireLocalization does.

	var extra = djConfig.extraLocale;
	if(extra){
	if(!extra instanceof Array){
	extra = [extra];
	}

	dojo._xdReqLoc = dojo.xdRequireLocalization;
	dojo.xdRequireLocalization = function(m, b, locale, fLocales){
	dojo._xdReqLoc(m,b,locale, fLocales);
	if(locale){return;}
	for(var i=0; i<extra.length; i++){
	dojo._xdReqLoc(m,b,extra[i], fLocales);
	}
	};
	}
	}

	dojo._xdBundleMap = {};

	dojo.xdRequireLocalization = function(/String/moduleName, /String/bundleName, /String?/locale, /String/availableFlatLocales){
	//summary: Internal xd loader function. The xd version of dojo.requireLocalization.


	//Account for allowing multiple extra locales. Do this here inside the function
	//since dojo._xdInitExtraLocales() depends on djConfig being set up, but that only
	//happens after hostenv_browser runs. loader_xd has to come before hostenv_browser
	//though since hostenv_browser can do a dojo.require for the debug module.
	if(dojo._xdInitExtraLocales){
	dojo._xdInitExtraLocales();
	dojo._xdInitExtraLocales = null;
	dojo.xdRequireLocalization.apply(dojo, arguments);
	return;
	}

	var locales = availableFlatLocales.split(",");

	//Find the best-match locale to load.
	//Assumes dojo.i18n has already been loaded. This is true for xdomain builds,
	//since it is included in dojo.xd.js.
	var jsLoc = dojo.i18n.normalizeLocale(locale);

	var bestLocale = "";
	for(var i = 0; i < locales.length; i++){
	//Locale must match from start of string.
	if(jsLoc.indexOf(locales[i]) == 0){
	if(locales[i].length > bestLocale.length){
	bestLocale = locales[i];
	}
	}
	}

	var fixedBestLocale = bestLocale.replace('-', '_');
	//See if the bundle we are going to use is already loaded.
	var bundleResource = dojo.getObject([moduleName, "nls", bundleName].join("."));
	if(bundleResource && bundleResource[fixedBestLocale]){
	bundle[jsLoc.replace('-', '_')] = bundleResource[fixedBestLocale];
	}else{
	//Need to remember what locale we wanted and which one we actually use.
	//Then when we load the one we are actually using, use that bundle for the one
	//we originally wanted.
	var mapName = [moduleName, (fixedBestLocale\|\|"root"), bundleName].join(".");
	var bundleMap = dojo._xdBundleMap[mapName];
	if(!bundleMap){
	bundleMap = dojo._xdBundleMap[mapName] = {};
	}
	bundleMap[jsLoc.replace('-', '_')] = true;

	//Do just a normal dojo.require so the resource tracking stuff works as usual.
	dojo.require(moduleName + ".nls" + (bestLocale ? "." + bestLocale : "") + "." + bundleName);
	}
	}

	// Replace dojo.requireLocalization with a wrapper
	dojo._xdRealRequireLocalization = dojo.requireLocalization;
	dojo.requireLocalization = function(/String/moduleName, /String/bundleName, /String?/locale, /String/availableFlatLocales){
	// summary: loads a bundle intelligently based on whether the module is
	// local or xd. Overrides the local-case implementation.

	var modulePath = this.moduleUrl(moduleName).toString();
	if (this._xdIsXDomainPath(modulePath)) {
	// call cross-domain loader
	return dojo.xdRequireLocalization.apply(dojo, arguments);
	} else {
	// call local-loader
	return dojo._xdRealRequireLocalization.apply(dojo, arguments);
	}
	}

	//This is a bit brittle: it has to know about the dojo methods that deal with dependencies
	//It would be ideal to intercept the actual methods and do something fancy at that point,
	//but I have concern about knowing which provide to match to the dependency in that case,
	//since scripts can load whenever they want, and trigger new calls to dojo._xdResourceLoaded().
	dojo._xdUnpackDependency = function(/Array/dep){
	//summary: Internal xd loader function. Determines what to do with a dependency
	//that was listed in an xd version of a module contents.

	//Extract the dependency(ies).
	var newDeps = null;
	var newAfterDeps = null;
	switch(dep[0]){
	case "requireIf":
	case "requireAfterIf":
	//First arg (dep[1]) is the test. Depedency is dep[2].
	if(dep[1] === true){
	newDeps = [{name: dep[2], content: null}];
	}
	break;
	case "platformRequire":
	var modMap = dep[1];
	var common = modMap["common"]\|\|[];
	var newDeps = (modMap[dojo.hostenv.name_]) ? common.concat(modMap[dojo.hostenv.name_]\|\|[]) : common.concat(modMap["default"]\|\|[]);
	//Flatten the array of arrays into a one-level deep array.
	//Each result could be an array of 3 elements (the 3 arguments to dojo.require).
	//We only need the first one.
	if(newDeps){
	for(var i = 0; i < newDeps.length; i++){
	if(newDeps[i] instanceof Array){
	newDeps[i] = {name: newDeps[i][0], content: null};
	}else{
	newDeps[i] = {name: newDeps[i], content: null};
	}
	}
	}
	break;
	case "require":
	//Just worry about dep[1]
	newDeps = [{name: dep[1], content: null}];
	break;
	case "i18n._preloadLocalizations":
	//We can eval these immediately, since they load i18n bundles.
	//Since i18n bundles have no dependencies, whenever they are loaded
	//in a script tag, they are evaluated immediately, so we do not have to
	//treat them has an explicit dependency for the dependency mapping.
	//We can call it immediately since dojo.i18n is part of dojo.xd.js.
	dojo.i18n._preloadLocalizations.apply(dojo.i18n._preloadLocalizations, dep.slice(1));
	break;
	}

	//The requireIf and requireAfterIf needs to be evaluated after the current resource is evaluated.
	if(dep[0] == "requireAfterIf" \|\| dep[0] == "requireIf"){
	newAfterDeps = newDeps;
	newDeps = null;
	}
	return {requires: newDeps, requiresAfter: newAfterDeps}; //Object
	}

	dojo._xdWalkReqs = function(){
	//summary: Internal xd loader function.
	//Walks the requires and evaluates module resource contents in
	//the right order.
	var reqChain = null;
	var req;
	for(var i = 0; i < this._xdOrderedReqs.length; i++){
	req = this._xdOrderedReqs[i];
	if(this._xdDepMap[req]){
	reqChain = [req];
	reqChain[req] = true; //Allow for fast lookup of the req in the array
	this._xdEvalReqs(reqChain);
	}
	}
	}

	dojo._xdEvalReqs = function(/Array/reqChain){
	//summary: Internal xd loader function.
	//Does a depth first, breadth second search and eval of required modules.
	while(reqChain.length > 0){
	var req = reqChain[reqChain.length - 1];
	var res = this._xdDepMap[req];
	if(res){
	//Trace down any requires for this resource.
	//START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack
	var reqs = res.requires;
	if(reqs && reqs.length > 0){
	var nextReq;
	for(var i = 0; i < reqs.length; i++){
	nextReq = reqs[i].name;
	if(nextReq && !reqChain[nextReq]){
	//New req depedency. Follow it down.
	reqChain.push(nextReq);
	reqChain[nextReq] = true;
	this._xdEvalReqs(reqChain);
	}
	}
	}
	//END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack

	//Evaluate the resource.
	var contents = this._xdContents[res.contentIndex];
	if(!contents.isDefined){
	var content = contents.content;
	content["resourceName"] = contents["resourceName"];
	content["resourcePath"] = contents["resourcePath"];
	this._xdDefList.push(content);
	contents.isDefined = true;
	}
	this._xdDepMap[req] = null;

	//Trace down any requireAfters for this resource.
	//START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack
	var reqs = res.requiresAfter;
	if(reqs && reqs.length > 0){
	var nextReq;
	for(var i = 0; i < reqs.length; i++){
	nextReq = reqs[i].name;
	if(nextReq && !reqChain[nextReq]){
	//New req depedency. Follow it down.
	reqChain.push(nextReq);
	reqChain[nextReq] = true;
	this._xdEvalReqs(reqChain);
	}
	}
	}
	//END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack
	}

	//Done with that require. Remove it and go to the next one.
	reqChain.pop();
	}
	}

	dojo._xdClearInterval = function(){
	//summary: Internal xd loader function.
	//Clears the interval timer used to check on the
	//status of in-flight xd module resource requests.
	clearInterval(this._xdTimer);
	this._xdTimer = 0;
	}

	dojo._xdWatchInFlight = function(){
	//summary: Internal xd loader function.
	//Monitors in-flight requests for xd module resources.

	var noLoads = "";
	var waitInterval = (djConfig.xdWaitSeconds \|\| 15) * 1000;
	var expired = (this._xdStartTime + waitInterval) < (new Date()).getTime();

	//If any xdInFlight are true, then still waiting for something to load.
	//Come back later. If we timed out, report the things that did not load.
	for(var param in this._xdInFlight){
	if(this._xdInFlight[param] === true){
	if(expired){
	noLoads += param + " ";
	}else{
	return;
	}
	}
	}

	//All done. Clean up and notify.
	this._xdClearInterval();

	if(expired){
	throw "Could not load cross-domain resources: " + noLoads;
	}

	this._xdWalkReqs();

	var defLength = this._xdDefList.length;
	for(var i= 0; i < defLength; i++){
	var content = dojo._xdDefList[i];
	if(djConfig["debugAtAllCosts"] && content["resourceName"]){
	if(!this["_xdDebugQueue"]){
	this._xdDebugQueue = [];
	}
	this._xdDebugQueue.push({resourceName: content.resourceName, resourcePath: content.resourcePath});
	}else{
	//Evaluate the resource to bring it into being.
	//Pass dojo in so that later, to support multiple versions of dojo
	//in a page, we can pass which version of dojo to use.
	content(dojo);
	}
	}

	//Evaluate any resources that were not evaled before.
	//This normally shouldn't happen with proper dojo.provide and dojo.require
	//usage, but providing it just in case. Note that these may not be executed
	//in the original order that the developer intended.
	//Pass dojo in so that later, to support multiple versions of dojo
	//in a page, we can pass which version of dojo to use.
	for(var i = 0; i < this._xdContents.length; i++){
	var current = this._xdContents[i];
	if(current.content && !current.isDefined){
	current.content(dojo);
	}
	}

	//Clean up for the next round of xd loading.
	this._xdReset();

	if(this["_xdDebugQueue"] && this._xdDebugQueue.length > 0){
	this._xdDebugFileLoaded();
	}else{
	this._xdNotifyLoaded();
	}
	}

	dojo._xdNotifyLoaded = function(){
	//Clear inflight count so we will finally do finish work.
	this._inFlightCount = 0;

	//Only trigger call loaded if dj_load_init has run.
	if(this._initFired && !this._loadNotifying){
	this._callLoaded();
	}
	}

	}

File Metadata

Mime Type: text/plain
Expires: Sun, Apr 6, 22:44 (2 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 25575
Default Alt Text: loader_xd.js (21 KB)

loader_xd.jsNo OneTemporaryActions

loader_xd.jsView Options

File Metadata

Event Timeline

loader_xd.js
No OneTemporary
Actions

loader_xd.js
View Options