function debug(str) {
//dump(' -*- webapp-optimize.js: ' + str + '\n');
}
/**
* Expose a global `win' object and load `l10n.js' in it --
* note: the `?reload' trick ensures we don't load a cached `l10njs' library.
*/
var win = { navigator: {} };
Services.scriptloader.loadSubScript('file:///' + GAIA_DIR +
'/shared/js/l10n.js?reload=' + new Date().getTime(), win);
/**
* Locale list -- by default, only the default one
*/
var l10nLocales = [GAIA_DEFAULT_LOCALE];
var l10nDictionary = {
locales: {},
default_locale: GAIA_DEFAULT_LOCALE
};
l10nDictionary.locales[GAIA_DEFAULT_LOCALE] = {};
/**
* whitelist by app name for javascript asset aggregation.
*/
const JS_AGGREGATION_WHITELIST = [
'calendar'
];
/**
* Helpers
*/
function optimize_getFileContent(webapp, htmlFile, relativePath) {
let paths = relativePath.split('/');
let file;
// get starting directory: webapp root, HTML file or /shared/
if (/^\//.test(relativePath)) {
paths.shift();
file = webapp.sourceDirectoryFile.clone();
} else {
file = htmlFile.parent.clone();
}
if (paths[0] == 'shared') {
file = getFile(GAIA_DIR);
}
paths.forEach(function appendPath(name) {
file.append(name);
if (isSubjectToBranding(file.path)) {
file.append((OFFICIAL == 1) ? 'official' : 'unofficial');
}
});
try {
return getFileContent(file);
} catch (e) {
dump(file.path + ' could not be found.\n');
return '';
}
}
/**
* Aggregates javascript files by type to reduce the IO overhead.
* Depending on the script tags there are two files made:
*
* - defered scripts (
*
*
* This function is somewhat conservative about what it will aggregate and will
* only group scripts found the documents section.
*
* @param {HTMLDocument} doc DOM document of the file.
* @param {Object} webapp details of current web app.
* @param {NSFile} htmlFile filename/path of the document.
*/
function optimize_aggregateJsResources(doc, webapp, htmlFile) {
// Everyone should be putting their scripts in head with defer.
// The best case is that only l10n.js is put into a normal.
let scripts = Array.slice(
doc.head.querySelectorAll('script[src]')
);
let deferred = {
prefix: 'defer_',
content: '',
lastNode: null
};
let normal = {
prefix: '',
content: '',
lastNode: null
};
scripts.forEach(function(script, idx) {
let html = script.outerHTML;
// per-script out see comment in function header.
if ('skipOptimize' in script.dataset) {
// remove from scripts so it will not be commented out...
debug(
'[optimize ' + webapp.sourceDirectoryName + '] ' +
'skipping script "' + html + '"'
);
scripts.splice(idx, 1);
return;
}
// we inject the whole outerHTML into the comment for debugging so
// if there is something valuable in the html that effects the script
// that broke the app it should be fairly easy to tell what happened.
let content = '; /* "' + html + ' "*/\n\n';
// fetch the whole file append it to the comment.
content += optimize_getFileContent(webapp, htmlFile, script.src);
let config = normal;
if (script.defer)
config = deferred;
config.content += content;
config.lastNode = script;
// some apps (email) use version in the script types
// (text/javascript;version=x).
//
// If we don't have the same version in the aggregate the
// app will not load correctly.
if (script.type.indexOf('version') !== -1) {
config.type = script.type;
}
});
// root name like index or oncall, etc...
let baseName = htmlFile.path.split('/').pop().split('.')[0];
// used as basis for aggregated scripts...
let rootDirectory = htmlFile.parent;
// find the absolute root of the app's html file.
let rootUrl = htmlFile.parent.path;
rootUrl = rootUrl.replace(webapp.manifestFile.parent.path, '');
// the above will yield something like: '', '/facebook/', '/contacts/', etc...
function writeAggregatedScript(config) {
// skip if we don't have any content to write.
if (!config.content)
return;
// prefix the file we are about to write content to.
let scriptBaseName =
Gaia.aggregatePrefix + config.prefix + baseName + '.js';
let target = rootDirectory.clone();
target.append(scriptBaseName);
debug('writing aggregated source file: ' + target.path);
// write the contents of the aggregated script
writeContent(target, config.content);
let script = doc.createElement('script');
let lastScript = config.lastNode;
script.src = rootUrl + '/' + scriptBaseName;
script.defer = lastScript.defer;
// use the config's type if given (for text/javascript;version=x)
script.type = config.type || lastScript.type;
debug('writing to path="' + target.path + '" src="' + script.src + '"');
// insert after the last script node of this type...
let parent = lastScript.parentNode;
parent.insertBefore(script, lastScript.nextSibling);
}
writeAggregatedScript(deferred);
writeAggregatedScript(normal);
function commentScript(script) {
script.outerHTML = '';
}
// comment out all scripts
scripts.forEach(commentScript);
}
function optimize_embedl10nResources(doc, dictionary) {
// remove all external l10n resource nodes
var resources = doc.querySelectorAll('link[type="application/l10n"]');
for (let i = 0; i < resources.length; i++) {
let res = resources[i].outerHTML;
resources[i].outerHTML = '';
}
// put the current dictionary in an inline JSON script
let script = doc.createElement('script');
script.type = 'application/l10n';
script.innerHTML = '\n ' + JSON.stringify(dictionary) + '\n';
doc.documentElement.appendChild(script);
}
function optimize_serializeHTMLDocument(doc, file) {
debug('saving: ' + file.path);
// the doctype string should always be '' but just in case...
let doctypeStr = '';
let dt = doc.doctype;
if (dt && dt.name) {
doctypeStr = '\n';
}
// outerHTML breaks the formating, so let's use innerHTML instead
let htmlStr = '\n*/, ' \n');
htmlStr += '>\n ' + innerHTML + '\n