zcompile/src/utils.js

"use strict";
const fs = require('fs-extra');

const Path = require('path');

const Utils = exports;

Utils.isObjectLiteral = function(thing) {
    return !!thing && typeof thing == 'object' && (thing.constructor === Object || Object.getPrototypeOf(thing) === null);
};

Utils.reportSettings = function(settings) {
	let logMessage = ['Minifying:'];

	if (settings.minifySelectors) logMessage.push('Selectors');
	if (settings.minifyCSS) logMessage.push('CSS files');
	if (settings.minifyJS) logMessage.push('JavaScript files' + (settings.minifyJS.harmony ? ' (harmony)' : ''));
	if (settings.minifyHTML) logMessage.push('HTML files' + (settings.minifyHTML.minifyInlineJS ? ' + inline JavaScript' : '') + (settings.minifyHTML.minifyInlineCSS ? ' + inline CSS' : ''));
	if (settings.minifyXML) logMessage.push('XML files');

	if (logMessage.length == 1) logMessage = ['Not minifying anything'];

	logMessage = logMessage.join('\n  - ');
	console.log(logMessage);
};

Utils.loadImports = function(code, srcDir, path, recursivelyImport) {
	let _ = path.lastIndexOf('.') + 1 || path.length;

	/*
		WARNING: File paths are relative to source and destination dirs
	*/
	let pathWithoutExt = path.slice(0, _); // "html/app." (last dot included) instead of "html/app.js"
	let extension = path.slice(_); // js, html, css ...

	code = code.replace(/<ZC-IMPORT\[(.+?)\]>/g, (_, importFile) => {
		let importFilePath, importFileAbsPath;

		if (importFile.indexOf('/') === 0) {
			importFileAbsPath = importFile;
		} else if (importFile.indexOf('/') > 0) {
			importFilePath = Utils.getFolder(pathWithoutExt) + '/' + importFile;
		} else {
			if (extension) {
				importFilePath = pathWithoutExt + importFile + '.' + extension;
			} else {
				importFilePath = pathWithoutExt + '.' + importFile;
			}
		}

		if (!importFileAbsPath) {
			importFileAbsPath = srcDir + importFilePath;
		}

		let ret = fs.readFileSync(importFileAbsPath, 'utf8');
		if (recursivelyImport) {
			ret = Utils.loadImports(ret, srcDir, importFilePath, true);
		}
		return ret;
	});
	return code;
};

Utils.getFolder = function(file) {
	file = Path.normalize(file);
	return file.split(Path.sep).slice(0, -1).join(Path.sep);
};

Utils.TYPE = {
	JS: 'js',
	CSS: 'css',
	HTML: 'html',
	XML: 'xml',
	JSON: 'json',
};

Utils.getType = function(extension, extensions) {
	if (extensions.js.includes(extension)) {
		return Utils.TYPE.JS;
	} else if (extensions.css.includes(extension)) {
		return Utils.TYPE.CSS;
	} else if (extensions.html.includes(extension)) {
		return Utils.TYPE.HTML;
	} else if (extensions.xml.includes(extension)) {
		return Utils.TYPE.XML;
	} else if (extensions.json.includes(extension)) {
		return Utils.TYPE.JSON;
	} else {
		throw new TypeError(`Unknown type for extension ${extension}`);
	}
};

Utils.clone = function(thing) {
    if (Array.isArray(thing)) {
        return thing.map(Utils.clone);
    } else if (Utils.isObjectLiteral(thing)) {
        let ret = Object.create(null);
        Object.keys(thing).forEach(propName => {
            ret[propName] = Utils.clone(thing[propName]);
        });
        return ret;
    } else {
        return thing;
    }
};

Utils.makeSettings = function(defaults, provided) {
	let result = Object.create(null);

	Object.keys(defaults).forEach(propName => {
		let defaultValue = defaults[propName];
		let providedValue = provided[propName];

		if (providedValue === undefined) {
			result[propName] = defaultValue;
		} else if (Utils.isObjectLiteral(defaultValue)) {
			if (providedValue === true) {
				result[propName] = defaultValue;
			} else if (!Utils.isObjectLiteral(providedValue)) {
				result[propName] = Utils.clone(providedValue);
			} else {
				result[propName] = Utils.makeSettings(defaultValue, providedValue);
			}
		} else {
			result[propName] = Utils.clone(providedValue);
		}
	});

	return result;
};