266 lines
8.4 KiB
JavaScript
266 lines
8.4 KiB
JavaScript
define([
|
|
"./buildControlBase"
|
|
], function(bc){
|
|
var defaultBc = {
|
|
// v1.6- default values
|
|
internStrings:true,
|
|
internSkipList:[],
|
|
optimize:"",
|
|
layerOptimize:"shrinksafe",
|
|
useSourceMaps:1,
|
|
cssOptimize:"",
|
|
cssImportIgnore:"",
|
|
stripConsole:"normal",
|
|
scopeMap:[],
|
|
insertAbsMids:1,
|
|
applyDojoPragmas:1,
|
|
localeList:"ar,ca,cs,da,de,el,en-gb,en-us,es-es,fi-fi,fr-fr,he-il,hu,it-it,ja-jp,ko-kr,nl-nl,nb,pl,pt-br,pt-pt,ru,sk,sl,sv,th,tr,zh-tw,zh-cn".split(","),
|
|
|
|
|
|
// this is a dojo pragma
|
|
replaceLoaderConfig:1,
|
|
|
|
defaultConfig:{
|
|
hasCache:{
|
|
// these are the values given above, not-built client code may test for these so they need to be available
|
|
'dojo-built':1,
|
|
'dojo-loader':1,
|
|
'dom':1,
|
|
'host-browser':1,
|
|
"config-tlmSiblingOfDojo":1,
|
|
|
|
// default
|
|
"config-selectorEngine":"acme"
|
|
},
|
|
async:0
|
|
},
|
|
|
|
files:[],
|
|
dirs:[],
|
|
trees:[],
|
|
replacements:{},
|
|
|
|
staticHasFeatures:{
|
|
// consider turning these hard on for standard 1.x build
|
|
//'config-publishRequireResult':1,
|
|
//'config-tlmSiblingOfDojo':1,
|
|
|
|
'extend-dojo':1,
|
|
'dojo-amd-factory-scan':0,
|
|
'dojo-built':1,
|
|
'dojo-combo-api':0,
|
|
'dojo-log-api':1,
|
|
'dojo-test-sniff':0,// must be turned on for several tests to work
|
|
'dojo-config-addOnLoad':1,
|
|
'dojo-config-api':1,
|
|
'dojo-config-require':1,
|
|
'dojo-dom-ready-api':1,
|
|
'dojo-guarantee-console':1,
|
|
'dojo-has-api':1,
|
|
'dojo-inject-api':1,
|
|
'dojo-loader':1,
|
|
'dojo-modulePaths':1,
|
|
'dojo-moduleUrl':1,
|
|
'dojo-publish-privates':0,
|
|
'dojo-requirejs-api':0,
|
|
'dojo-sniff':1,
|
|
'dojo-sync-loader':1,
|
|
'dojo-timeout-api':1,
|
|
'dojo-trace-api':0,
|
|
'dojo-undef-api':0,
|
|
'dojo-v1x-i18n-Api':1,
|
|
'dojo-xhr-factory':1,
|
|
"dojo-fast-sync-require":1,
|
|
'config-deferredInstrumentation':1,
|
|
'dom':1,
|
|
'host-browser':1,
|
|
'host-node':0,
|
|
'host-rhino':0
|
|
},
|
|
|
|
discoveryProcs:["build/discover"],
|
|
|
|
plugins:{
|
|
"dojo/text":"build/plugins/text",
|
|
"dojo/i18n":"build/plugins/i18n",
|
|
"dojo/has":"build/plugins/has",
|
|
"dojo/domReady":"build/plugins/domReady",
|
|
"dojo/loadInit":"build/plugins/loadInit",
|
|
"dojo/require":"build/plugins/require",
|
|
"dojo/selector/_loader":"build/plugins/querySelector"
|
|
},
|
|
|
|
gates:[
|
|
// [synchronized?, gate-name, gate-message]
|
|
[0, "read", "reading resources"],
|
|
[0, "text", "processing raw resource content"],
|
|
[0, "tokenize", "tokenizing resource"],
|
|
[0, "tokens", "processing resource tokens"],
|
|
[0, "parse", "parsing resource"],
|
|
[1, "ast", "processing resource AST"],
|
|
[1, "optimize", "executing global optimizations"],
|
|
[1, "write", "writing resources"],
|
|
[1, "cleanup", "cleaning up"],
|
|
[1, "report", "reporting"]
|
|
],
|
|
|
|
transformConfig: {},
|
|
|
|
transforms:{
|
|
trace: ["build/transforms/trace", "read"],
|
|
read: ["build/transforms/read", "read"],
|
|
dojoPragmas: ["build/transforms/dojoPragmas", "read"],
|
|
insertSymbols: ["build/transforms/insertSymbols", "read"],
|
|
depsDeclarative: ["build/transforms/depsDeclarative", "read"],
|
|
depsScan: ["build/transforms/depsScan", "ast"],
|
|
hasFixup: ["build/transforms/hasFixup", "ast"],
|
|
write: ["build/transforms/write", "write"],
|
|
writeAmd: ["build/transforms/writeAmd", "write"],
|
|
writeOptimized: ["build/transforms/writeOptimized", "write"],
|
|
copy: ["build/transforms/copy", "write"],
|
|
writeDojo: ["build/transforms/writeDojo", "write"],
|
|
optimizeCss: ["build/transforms/optimizeCss", "optimize"],
|
|
writeCss: ["build/transforms/writeCss", "write"],
|
|
hasFindAll: ["build/transforms/hasFindAll", "read"],
|
|
hasReport: ["build/transforms/hasReport", "cleanup"],
|
|
depsDump: ["build/transforms/depsDump", "cleanup"],
|
|
dojoReport: ["build/transforms/dojoReport", "report"],
|
|
report: ["build/transforms/report", "report"]
|
|
},
|
|
|
|
transformJobs:[[
|
|
// immediately filter the stuff to not be transformed in any way
|
|
function(resource, bc){
|
|
return(bc.mini && resource.tag.miniExclude) || (!bc.copyTests && resource.tag.test) || (resource.tag.ignore);
|
|
},
|
|
[]
|
|
],[
|
|
// if the tag says just copy, then just copy
|
|
function(resource, bc){
|
|
return resource.tag.copyOnly;
|
|
},
|
|
["copy"]
|
|
],[
|
|
// the synthetic report module
|
|
function(resource, bc){
|
|
return resource.tag.report;
|
|
},
|
|
["dojoReport", "insertSymbols", "report"]
|
|
],[
|
|
// dojo.js, the loader
|
|
function(resource, bc){
|
|
if(resource.mid=="dojo/dojo"){
|
|
bc.loader = resource;
|
|
resource.boots = [];
|
|
// the loader is treated as an AMD module when creating the "dojo" layer, but and AMD dependency scan won't
|
|
// work because it's not an AMD module; therefore, initialize deps here and make sure not to do the depsScan transform
|
|
resource.deps = [];
|
|
bc.amdResources[resource.mid] = resource;
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
["read", "dojoPragmas", "hasFindAll", "hasFixup", "writeDojo", "writeOptimized"]
|
|
],[
|
|
// package has module
|
|
function(resource, bc){
|
|
if(/^\w+\/has$/.test(resource.mid)){
|
|
bc.amdResources[resource.mid] = resource;
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
["read", "dojoPragmas", "hasFindAll", "hasFixup", "depsScan", "writeAmd", "writeOptimized", "hasReport", "depsDump"]
|
|
],[
|
|
// flattened nls bundles
|
|
function(resource, bc){
|
|
return !!resource.tag.flattenedNlsBundle;
|
|
},
|
|
["writeAmd", "writeOptimized"]
|
|
],[
|
|
// nls resources
|
|
function(resource, bc){
|
|
if((/\/nls\//.test(resource.mid) || /\/nls\/.+\.js$/.test(resource.src)) && ((!resource.tag.test || bc.copyTests=="build"))){
|
|
resource.tag.nls = 1;
|
|
bc.amdResources[resource.mid] = resource;
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
["read", "dojoPragmas", "hasFindAll", "hasFixup", "depsScan", "writeAmd", "writeOptimized"]
|
|
],[
|
|
// synthetic AMD modules (used to create layers on-the-fly
|
|
function(resource, bc){
|
|
if(resource.tag.synthetic && resource.tag.amd){
|
|
bc.amdResources[resource.mid] = resource;
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
// just like regular AMD modules, but without a bunch of unneeded transforms
|
|
["depsScan", "writeAmd", "writeOptimized"]
|
|
],[
|
|
// synthetic dojo/loadInit! resources
|
|
// FIXME: can't this be added to the previous transform?
|
|
function(resource, bc){
|
|
if(resource.tag.loadInitResource){
|
|
bc.amdResources[resource.mid] = resource;
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
// just like regular AMD modules (the next transform job), but without a bunch of unneeded transforms
|
|
["writeAmd", "writeOptimized"]
|
|
],[
|
|
// AMD module:
|
|
// already marked as an amd resource
|
|
// ...or...
|
|
// not dojo/dojo.js (filtered above), not package has module (filtered above), not nls bundle (filtered above), not test or building test, not build control script or profile script but still a Javascript resource...
|
|
function(resource, bc){
|
|
if(resource.tag.amd || (/\.js$/.test(resource.src) && (!resource.tag.test || bc.copyTests=="build") && !/\.(bcs|profile)\.js$/.test(resource.src))){
|
|
bc.amdResources[resource.mid] = resource;
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
["read", "dojoPragmas", "hasFindAll", "insertSymbols", "hasFixup", "depsScan", "writeAmd", "writeOptimized"]
|
|
],[
|
|
// Declarative Resource:
|
|
// This resource (usually HTML) should be scanned for declarative dependencies and copied.
|
|
function(resource, bc){
|
|
return resource.tag.declarative;
|
|
},
|
|
["read", "dojoPragmas", "depsDeclarative", "write"]
|
|
],[
|
|
// a test resource; if !bc.copyTests then the resource was filtered in the first item; otherwise, if the resource is a potential module and building tests, then it was filtered above;
|
|
function(resource, bc){
|
|
return resource.tag.test;
|
|
},
|
|
["read", "dojoPragmas", "write"]
|
|
],[
|
|
// html file; may need access contents for template interning and/or dojoPragmas; therefore, can't use copy transform
|
|
function(resource, bc){
|
|
return /\.(html|htm)$/.test(resource.src);
|
|
},
|
|
["read", "dojoPragmas", "write"]
|
|
],[
|
|
// css that are designated to compact
|
|
function(resource, bc){
|
|
return /\.css$/.test(resource.src);
|
|
},
|
|
["read", "optimizeCss", "write"]
|
|
],[
|
|
// just copy everything else except tests which were copied above iff desired...
|
|
function(resource, bc){
|
|
return !resource.tag.test;
|
|
},
|
|
["copy"]
|
|
]
|
|
]
|
|
};
|
|
for(var p in defaultBc){
|
|
bc[p] = defaultBc[p];
|
|
}
|
|
return bc;
|
|
});
|