define(['dojo/json', 'build/fs', 'build/fileUtils', 'build/transforms/writeAmd', '../build'],
|
function(json, fs, fileUtils, writeAmd, buildModule){
|
var targetStylesheet;
|
return {
|
start:function(
|
mid,
|
referenceModule,
|
bc
|
){
|
// mid may contain a pragma (e.g. "!strip"); remove
|
mid = mid.split("!")[0];
|
var cssPlugin = bc.amdResources["xstyle/css"],
|
stylesheetInfo = bc.getSrcModuleInfo(mid, referenceModule, true),
|
cssResource = bc.resources[stylesheetInfo.url],
|
xstyleModuleInfo = bc.getSrcModuleInfo("xstyle/core/parser", referenceModule, true),
|
xstyleText = fs.readFileSync(xstyleModuleInfo.url + '.js', "utf8"),
|
xstyleProcess = buildModule(xstyleText);
|
|
function processStylesheetLayers(){
|
// build all the target stylesheets from the layers
|
if(!bc.processedStylesheets){
|
bc.processedStylesheets = true;
|
for(var i in bc.layers){
|
var layer = bc.layers[i];
|
targetStylesheet = layer.targetStylesheet;
|
if(targetStylesheet){
|
// we want to calculate the target stylesheet relative to the layer
|
var layerModule = layer.name && bc.getSrcModuleInfo(layer.name);
|
var moduleInfo = bc.getSrcModuleInfo(targetStylesheet, layerModule, true);
|
var targetStylesheetModule = bc.resources[moduleInfo.url];
|
var targetDestStylesheetModule = bc.getDestModuleInfo(targetStylesheet, null, true);
|
var targetStylesheetUrl = bc.currentTargetStylesheetUrl = moduleInfo.url;
|
var targetDestStylesheetUrl = targetDestStylesheetModule.url;
|
// initialize the target stylesheet
|
var targetStylesheetContents = '';
|
try{
|
if(targetStylesheetModule){
|
targetStylesheetContents = processCss(targetStylesheetModule).standardCss;
|
}else{
|
targetStylesheetModule = moduleInfo;
|
}
|
var moduleSet = writeAmd.computeLayerContents({mid:'stylesheet-process' + i}, layer.include, layer.exclude);
|
var targetResource;
|
for (var i in moduleSet) {
|
var module = moduleSet[i];
|
if(module.getCss){
|
if(module.mid == targetStylesheetModule.mid) {
|
// probably not necessary to assign this anymore
|
targetResource = module;
|
// if it is the target stylesheet, the contents are already included
|
}else{
|
targetStylesheetContents += module.getCss();
|
}
|
}
|
}
|
if(targetResource){
|
var loadIndicator = '#' + targetResource.module.mid.replace(/\//g,'-').replace(/\..*/,'')
|
+ '-loaded{display:none}';
|
targetStylesheetContents += loadIndicator;
|
targetResource.module.originalCss = targetResource.module.text;
|
targetResource.isTargetStylesheet = true;
|
}
|
targetStylesheetModule.isTargetStylesheet = true;
|
targetStylesheetModule.originalCss = targetStylesheetModule.text;
|
targetStylesheetModule.text = targetStylesheetContents;
|
|
var url = targetDestStylesheetUrl.replace(/\/x$/,'');
|
|
fileUtils.ensureDirectoryByFilename(url);
|
fs.writeFileSync(url, targetStylesheetContents);
|
}catch(e){
|
console.error('error creating css layer', e.stack || e);
|
}
|
bc.currentTargetStylesheetUrl = targetStylesheetUrl = null;
|
}
|
}
|
}
|
}
|
if(targetStylesheet){
|
}else{
|
// there is no targe stylesheet, so
|
// we will be directly inlining the stylesheet in the layer, so we need the createStyleSheet module
|
var createStyleSheetModule = bc.getSrcModuleInfo('xstyle/core/load-css', referenceModule);
|
}
|
// read the stylesheet so we can process
|
//var text= fs.readFileSync(stylesheetInfo.src, "utf8");
|
|
if (!cssPlugin){
|
throw new Error("text! plugin missing");
|
}
|
if (!cssResource){
|
throw new Error("text resource (" + stylesheetInfo.url + ") missing");
|
}
|
|
var result = [cssPlugin];
|
if(createStyleSheetModule){
|
// if we are inlining the stylesheet, we need the functionality to insert a stylesheet from text
|
result.push(bc.amdResources['xstyle/core/load-css']);
|
}
|
if(bc.internStrings && !bc.internSkip(stylesheetInfo.mid, referenceModule)){
|
// or inline it
|
result.push({
|
module:cssResource,
|
pid:stylesheetInfo.pid,
|
mid:stylesheetInfo.mid,
|
deps:[],
|
getText:function(){
|
var processed = this.processed = processCss(this.module, true);//stylesheetInfo.url, // inline resources too
|
return processed.xstyleCss ?
|
json.stringify({
|
cssText: processed.standardCss,
|
xCss: processed.xstyleCss
|
}) :
|
json.stringify(processed.standardCss +"");
|
},
|
getCss: function(){
|
this.cssRetrieved = true;
|
return processCss(this.module).standardCss;//, targetStylesheetUrl);
|
},
|
internStrings: function(){
|
processStylesheetLayers();
|
if(this.isTargetStylesheet){
|
// a target stylesheet, this should go through the xstyle loader
|
// to ensure it is actually loaded
|
return ['', '0'];
|
}
|
if(this.cssRetrieved){
|
// the CSS has been written to a stylesheet, we intern an indicator that
|
// it has already been loaded
|
return ['url:' + this.mid, '{}'];
|
}
|
// it hasn't been written to a target stylesheet, so it needs to actually be inlined
|
return ['url:' + this.mid, this.getText()];
|
}
|
});
|
}
|
function processCss(module, inlineAllResource){
|
var text = module.originalCss || module.getText ? module.getText() : module.text;
|
if(text===undefined){
|
// the module likely did not go through the read transform; therefore, just read it manually
|
text= fs.readFileSync(module.src, "utf8");
|
}
|
try{
|
var processed = xstyleProcess(text, bc.currentTargetStylesheetUrl || module.src, module.src, inlineAllResource);
|
//for(var i = 0; i < processed.requiredModules.length; i++){
|
// TODO: at some point, we may add an option to include the modules that
|
// are required by the stylesheet, but at least by default these should
|
// probably be async lazy loaded
|
//}
|
}catch(e){
|
console.error('Error processing CSS', e.stack || e);
|
processed = {standardCss: text};
|
}
|
return processed;
|
}
|
return result;
|
}
|
};
|
});
|
