zcompile/src/zc.js

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

const Utils = require('./utils.js');
const Variables = require('./variables.js');
const Selectors = require('./selectors.js');
const Path = require('path');
const CSS = require('css');

const MinifyCSS = require('./zc-minify-css.js');
const MinifyHTML = require('./zc-minify-html.js');
const MinifyXML = require('./zc-minify-xml.js');
const MinifyJS = require('./zc-minify-js.js');
const MinifyJSON = require('./zc-minify-json.js');

module.exports = function(settings) {
	settings = Utils.makeSettings({
		minifySelectors: {
			imports: [],
			prefix: '',
			exportTo: null,
		},
		minifyCSS: true,
		minifyJS: {
			harmony: false,
			passes: 1,
			debug: false,
		},
		minifyHTML: {
			minifyInlineJS: false,
			minifyInlineCSS: false,
			eventAttributes: [ /^(dom|child|mutation|dispatch)?on/ ],
		},
		minifyXML: true,
		minifyJSON: true,

		onloadjs: code => code,
		onloadcss: code => code,
		onloadhtml: code => code,
		onloadxml: code => code,
		onloadjson: code => code,

		onloadfile: (data, extension, path) => data,
		onminifyfile: (data, extension, path) => data,

		recursivelyImport: false,

		source: './src/',
		destination: './dist/',
		extensions: {
			js: ['js'],
			css: ['css'],
			html: ['html'],
			xml: ['xml'],
			json: ['json'],
		},
		files: [],
		copy: [],
	}, settings);

	Utils.reportSettings(settings);

	let configuredMinifyJS = function(code) {
		for (let i = 0; i < settings.minifyJS.passes; i++) {
			code = MinifyJS(code, {
				debug: settings.minifyJS.debug,
				harmony: settings.minifyJS.harmony,
				// passes: settings.minifyJS.passes,
			});
		}
		return code;
	};

	let selectors = settings.minifySelectors && new Selectors({
		prepend: settings.minifySelectors.prefix,
		externalSelectors: (() => {
			let ret = { c: [], i: [] };
			settings.minifySelectors.imports.forEach(file => {
				let json = fs.readFileSync(file, 'utf8'),
					pkg = JSON.parse(json);

				[].push.apply(ret.c, pkg.c);
				[].push.apply(ret.i, pkg.i);

				console.log(`Imported selectors from ${file}`);
			});
			return ret;
		})()
	});

	// Clean paths and add slash at the end
	// NOTE: Undefined behaviour if source path doesn't exist; destination path doesn't have to exist
	const SRC_DIR = fs.realpathSync(settings.source) + '/';
	const DST_DIR = Path.normalize(settings.destination + '/');

	console.log(`Source:      ${SRC_DIR}`);
	console.log(`Destination: ${DST_DIR}`);

	// For files that only need to be copied and not altered, just copy them
	settings.copy.forEach(fileToCopy => {
		fs.copySync(SRC_DIR + fileToCopy, DST_DIR + fileToCopy);
		console.log(`Copied ${fileToCopy}`);
	});

	var codeToMinify = [];

	// First, get and replace all the selectors from all files
	settings.files.forEach(path => {

		/*
			WARNING: File paths are relative to source and destination dirs
		*/
		let extension = path.slice(path.lastIndexOf('.') + 1 || path.length); // js, html, css ...

		let data = fs.readFileSync(SRC_DIR + path, 'utf8'); // The actual contents of the file

		data = Utils.loadImports(data, SRC_DIR, path, settings.recursivelyImport);

		let variables = new Variables();
		data = data.replace(/<ZC-SET\[(.+?)\]\[(.+?)\]>/g, (_, name, value) => {
			variables.set(name, value);
			return '';
		});
		data = data.replace(/<ZC-USE\[(.+?)\]>/g, (_, name) => {
			return variables.get(name);
		});
		variables.end();

		data = settings.onloadfile(data, extension, path);

		switch (Utils.getType(extension, settings.extensions)) {
			case Utils.TYPE.JS:
				data = settings.onloadjs(data);
				if (settings.minifySelectors) {
					data = data.replace(/['"]([#.])([a-z-]+)['"]/g, (_, prefix, sel) => {
						let minifiedSel = selectors.minifySelector(sel, prefix == '.');
						return `"${prefix}${minifiedSel}"`;
					});
				}
				break;

			case Utils.TYPE.CSS:
				data = settings.onloadcss(data);
				if (settings.minifySelectors) {
					let cssAst = CSS.parse(data),
						rulesToProcess = cssAst.stylesheet.rules.slice(),
						rule;

					while (rule = rulesToProcess.shift()) {
						if (rule.type == 'media') {
							rulesToProcess = rulesToProcess.concat(rule.rules);
						}

						if (rule.type == 'rule') {
							rule.selectors.forEach((ruleSelector, idx) => {
								rule.selectors[idx] = ruleSelector.replace(/([.#])([a-z-]+)(?=[ \[:,.#)]|$)/g, (_, prefix, sel) => {
									let minifiedSel = selectors.minifySelector(sel, prefix == '.');
									return `${prefix}${minifiedSel}`;
								});
							});
						}
					}
					data = CSS.stringify(cssAst, {
						compress: true,
					});
				}
				break;

			case Utils.TYPE.HTML:
				data = settings.onloadhtml(data);
				if (settings.minifySelectors) {
					data = data.replace(/ (class|for|id)="([a-z- ]+)"/g, (_, type, sel) => {
						let ret = ` ${type}="`;

						if (type == 'class') {
							sel.split(/\s+/).forEach(klass => {
								klass = klass.trim();
								if (klass) ret += selectors.minifySelector(klass, true) + ' ';
							});
						} else {
							sel = sel.trim();
							if (sel) ret += selectors.minifySelector(sel, false);
						}

						ret += '"';
						return ret;
					});
				}
				break;

			case Utils.TYPE.XML:
				data = settings.onloadxml(data);
				break;

			case Utils.TYPE.JSON:
				data = settings.onloadjson(data);
				break;
		}

		codeToMinify.push({
			extension: extension,
			file: path,
			data: data
		});
	});

	if (settings.minifySelectors && settings.minifySelectors.exportTo) {
		let json = JSON.stringify(selectors.export()),
			file = settings.minifySelectors.exportTo;
		fs.writeFileSync(file, json);
		console.log(`Exported selectors to ${file}`);
	}

	// Then, minify all the files and write them to their destinations
	codeToMinify.forEach(({ extension, file, data }) => {
		let folder = Utils.getFolder(file);

		switch (Utils.getType(extension, settings.extensions)) {
			case Utils.TYPE.JS:
				if (settings.minifyJS) {
					data = configuredMinifyJS(data);
				}
				break;

			case Utils.TYPE.CSS:
				if (settings.minifyCSS) {
					data = MinifyCSS(data);
				}
				break;

			case Utils.TYPE.HTML:
				if (settings.minifyHTML) {
					data = MinifyHTML(data, {
						minifyJS: settings.minifyHTML.minifyInlineJS && function(data) {
							data = settings.onloadjs(data);
							return configuredMinifyJS(data);
						},
						minifyCSS: settings.minifyHTML.minifyInlineCSS && function(data) {
							return MinifyCSS(data);
						},
						eventAttributes: settings.minifyHTML.eventAttributes,
					});
				}
				break;

			case Utils.TYPE.XML:
				if (settings.minifyXML) {
					data = MinifyXML(data);
				}
				break;

			case Utils.TYPE.JSON:
				if (settings.minifyJSON) {
					data = MinifyJSON(data);
				}
				break;
		}

		data = settings.onminifyfile(data, extension, file);

		fs.outputFileSync(DST_DIR + file, data);
		console.log(`Processed ${file}`);
	});
};