| #!/usr/bin/env node |
| /** |
| * html-minifier CLI tool |
| * |
| * The MIT License (MIT) |
| * |
| * Copyright (c) 2014-2016 Zoltan Frombach |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy of |
| * this software and associated documentation files (the "Software"), to deal in |
| * the Software without restriction, including without limitation the rights to |
| * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of |
| * the Software, and to permit persons to whom the Software is furnished to do so, |
| * subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in all |
| * copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS |
| * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR |
| * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER |
| * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| */ |
| |
| 'use strict'; |
| |
| var camelCase = require('camel-case'); |
| var fs = require('fs'); |
| var info = require('./package.json'); |
| var minify = require('./' + info.main).minify; |
| var paramCase = require('param-case'); |
| var path = require('path'); |
| var program = require('commander'); |
| |
| program._name = info.name; |
| program.version(info.version); |
| |
| function fatal(message) { |
| console.error(message); |
| process.exit(1); |
| } |
| |
| /** |
| * JSON does not support regexes, so, e.g., JSON.parse() will not create |
| * a RegExp from the JSON value `[ "/matchString/" ]`, which is |
| * technically just an array containing a string that begins and end with |
| * a forward slash. To get a RegExp from a JSON string, it must be |
| * constructed explicitly in JavaScript. |
| * |
| * The likelihood of actually wanting to match text that is enclosed in |
| * forward slashes is probably quite rare, so if forward slashes were |
| * included in an argument that requires a regex, the user most likely |
| * thought they were part of the syntax for specifying a regex. |
| * |
| * In the unlikely case that forward slashes are indeed desired in the |
| * search string, the user would need to enclose the expression in a |
| * second set of slashes: |
| * |
| * --customAttrSrround "[\"//matchString//\"]" |
| */ |
| function parseRegExp(value) { |
| if (value) { |
| return new RegExp(value.replace(/^\/(.*)\/$/, '$1')); |
| } |
| } |
| |
| function parseJSON(value) { |
| if (value) { |
| try { |
| return JSON.parse(value); |
| } |
| catch (e) { |
| if (/^{/.test(value)) { |
| fatal('Could not parse JSON value \'' + value + '\''); |
| } |
| return value; |
| } |
| } |
| } |
| |
| function parseJSONArray(value) { |
| if (value) { |
| value = parseJSON(value); |
| return Array.isArray(value) ? value : [value]; |
| } |
| } |
| |
| function parseJSONRegExpArray(value) { |
| value = parseJSONArray(value); |
| return value && value.map(parseRegExp); |
| } |
| |
| function parseString(value) { |
| return value; |
| } |
| |
| var mainOptions = { |
| caseSensitive: 'Treat attributes in case sensitive manner (useful for SVG; e.g. viewBox)', |
| collapseBooleanAttributes: 'Omit attribute values from boolean attributes', |
| collapseInlineTagWhitespace: 'Collapse white space around inline tag', |
| collapseWhitespace: 'Collapse white space that contributes to text nodes in a document tree.', |
| conservativeCollapse: 'Always collapse to 1 space (never remove it entirely)', |
| customAttrAssign: ['Arrays of regex\'es that allow to support custom attribute assign expressions (e.g. \'<div flex?="{{mode != cover}}"></div>\')', parseJSONRegExpArray], |
| customAttrCollapse: ['Regex that specifies custom attribute to strip newlines from (e.g. /ng-class/)', parseRegExp], |
| customAttrSurround: ['Arrays of regex\'es that allow to support custom attribute surround expressions (e.g. <input {{#if value}}checked="checked"{{/if}}>)', parseJSONRegExpArray], |
| customEventAttributes: ['Arrays of regex\'es that allow to support custom event attributes for minifyJS (e.g. ng-click)', parseJSONRegExpArray], |
| decodeEntities: 'Use direct Unicode characters whenever possible', |
| html5: 'Parse input according to HTML5 specifications', |
| ignoreCustomComments: ['Array of regex\'es that allow to ignore certain comments, when matched', parseJSONRegExpArray], |
| ignoreCustomFragments: ['Array of regex\'es that allow to ignore certain fragments, when matched (e.g. <?php ... ?>, {{ ... }})', parseJSONRegExpArray], |
| includeAutoGeneratedTags: 'Insert tags generated by HTML parser', |
| keepClosingSlash: 'Keep the trailing slash on singleton elements', |
| maxLineLength: ['Max line length', parseInt], |
| minifyCSS: ['Minify CSS in style elements and style attributes (uses clean-css)', parseJSON], |
| minifyJS: ['Minify Javascript in script elements and on* attributes (uses uglify-js)', parseJSON], |
| minifyURLs: ['Minify URLs in various attributes (uses relateurl)', parseJSON], |
| preserveLineBreaks: 'Always collapse to 1 line break (never remove it entirely) when whitespace between tags include a line break.', |
| preventAttributesEscaping: 'Prevents the escaping of the values of attributes.', |
| processConditionalComments: 'Process contents of conditional comments through minifier', |
| processScripts: ['Array of strings corresponding to types of script elements to process through minifier (e.g. "text/ng-template", "text/x-handlebars-template", etc.)', parseJSONArray], |
| quoteCharacter: ['Type of quote to use for attribute values (\' or ")', parseString], |
| removeAttributeQuotes: 'Remove quotes around attributes when possible.', |
| removeComments: 'Strip HTML comments', |
| removeEmptyAttributes: 'Remove all attributes with whitespace-only values', |
| removeEmptyElements: 'Remove all elements with empty contents', |
| removeOptionalTags: 'Remove unrequired tags', |
| removeRedundantAttributes: 'Remove attributes when value matches default.', |
| removeScriptTypeAttributes: 'Remove type="text/javascript" from script tags. Other type attribute values are left intact.', |
| removeStyleLinkTypeAttributes: 'Remove type="text/css" from style and link tags. Other type attribute values are left intact.', |
| removeTagWhitespace: 'Remove space between attributes whenever possible', |
| sortAttributes: 'Sort attributes by frequency', |
| sortClassName: 'Sort style classes by frequency', |
| trimCustomFragments: 'Trim white space around ignoreCustomFragments.', |
| useShortDoctype: 'Replaces the doctype with the short (HTML5) doctype' |
| }; |
| var mainOptionKeys = Object.keys(mainOptions); |
| mainOptionKeys.forEach(function(key) { |
| var option = mainOptions[key]; |
| if (Array.isArray(option)) { |
| key = key === 'minifyURLs' ? '--minify-urls' : '--' + paramCase(key); |
| key += option[1] === parseJSON ? ' [value]' : ' <value>'; |
| program.option(key, option[0], option[1]); |
| } |
| else if (~['html5', 'includeAutoGeneratedTags'].indexOf(key)) { |
| program.option('--no-' + paramCase(key), option); |
| } |
| else { |
| program.option('--' + paramCase(key), option); |
| } |
| }); |
| program.option('-o --output <file>', 'Specify output file (if not specified STDOUT will be used for output)'); |
| |
| function readFile(file) { |
| try { |
| return fs.readFileSync(file, { encoding: 'utf8' }); |
| } |
| catch (e) { |
| fatal('Cannot read ' + file + '\n' + e.message); |
| } |
| } |
| |
| var config = {}; |
| program.option('-c --config-file <file>', 'Use config file', function(configPath) { |
| var data = readFile(configPath); |
| try { |
| config = JSON.parse(data); |
| } |
| catch (je) { |
| try { |
| config = require(path.resolve(configPath)); |
| } |
| catch (ne) { |
| fatal('Cannot read the specified config file.\nAs JSON: ' + je.message + '\nAs module: ' + ne.message); |
| } |
| } |
| mainOptionKeys.forEach(function(key) { |
| if (key in config) { |
| var option = mainOptions[key]; |
| if (Array.isArray(option)) { |
| var value = config[key]; |
| config[key] = option[1](typeof value === 'string' ? value : JSON.stringify(value)); |
| } |
| } |
| }); |
| }); |
| program.option('--input-dir <dir>', 'Specify an input directory'); |
| program.option('--output-dir <dir>', 'Specify an output directory'); |
| program.option('--file-ext <text>', 'Specify an extension to be read, ex: html'); |
| var content; |
| program.arguments('[files...]').action(function(files) { |
| content = files.map(readFile).join(''); |
| }).parse(process.argv); |
| |
| function createOptions() { |
| var options = {}; |
| mainOptionKeys.forEach(function(key) { |
| var param = program[key === 'minifyURLs' ? 'minifyUrls' : camelCase(key)]; |
| if (typeof param !== 'undefined') { |
| options[key] = param; |
| } |
| else if (key in config) { |
| options[key] = config[key]; |
| } |
| }); |
| return options; |
| } |
| |
| function mkdir(outputDir, callback) { |
| fs.mkdir(outputDir, function(err) { |
| if (err) { |
| switch (err.code) { |
| case 'ENOENT': |
| return mkdir(path.join(outputDir, '..'), function() { |
| mkdir(outputDir, callback); |
| }); |
| case 'EEXIST': |
| break; |
| default: |
| fatal('Cannot create directory ' + outputDir + '\n' + err.message); |
| } |
| } |
| callback(); |
| }); |
| } |
| |
| function processFile(inputFile, outputFile) { |
| fs.readFile(inputFile, { encoding: 'utf8' }, function(err, data) { |
| if (err) { |
| fatal('Cannot read ' + inputFile + '\n' + err.message); |
| } |
| var minified; |
| try { |
| minified = minify(data, createOptions()); |
| } |
| catch (e) { |
| fatal('Minification error on ' + inputFile + '\n' + e.message); |
| } |
| fs.writeFile(outputFile, minified, { encoding: 'utf8' }, function(err) { |
| if (err) { |
| fatal('Cannot write ' + outputFile + '\n' + err.message); |
| } |
| }); |
| }); |
| } |
| |
| function processDirectory(inputDir, outputDir, fileExt) { |
| fs.readdir(inputDir, function(err, files) { |
| if (err) { |
| fatal('Cannot read directory ' + inputDir + '\n' + err.message); |
| } |
| files.forEach(function(file) { |
| var inputFile = path.join(inputDir, file); |
| var outputFile = path.join(outputDir, file); |
| fs.stat(inputFile, function(err, stat) { |
| if (err) { |
| fatal('Cannot read ' + inputFile + '\n' + err.message); |
| } |
| else if (stat.isDirectory()) { |
| processDirectory(inputFile, outputFile, fileExt); |
| } |
| else if (!fileExt || path.extname(file) === '.' + fileExt) { |
| mkdir(outputDir, function() { |
| processFile(inputFile, outputFile); |
| }); |
| } |
| }); |
| }); |
| }); |
| } |
| |
| function writeMinify() { |
| var minified; |
| try { |
| minified = minify(content, createOptions()); |
| } |
| catch (e) { |
| fatal('Minification error:\n' + e.message); |
| } |
| (program.output ? fs.createWriteStream(program.output).on('error', function(e) { |
| fatal('Cannot write ' + program.output + '\n' + e.message); |
| }) : process.stdout).write(minified); |
| } |
| |
| var inputDir = program.inputDir; |
| var outputDir = program.outputDir; |
| var fileExt = program.fileExt; |
| if (inputDir || outputDir) { |
| if (!inputDir) { |
| fatal('The option output-dir needs to be used with the option input-dir. If you are working with a single file, use -o.'); |
| } |
| else if (!outputDir) { |
| fatal('You need to specify where to write the output files with the option --output-dir'); |
| } |
| processDirectory(inputDir, outputDir, fileExt); |
| } |
| // Minifying one or more files specified on the CMD line |
| else if (content) { |
| writeMinify(); |
| } |
| // Minifying input coming from STDIN |
| else { |
| content = ''; |
| process.stdin.setEncoding('utf8'); |
| process.stdin.on('data', function(data) { |
| content += data; |
| }).on('end', writeMinify); |
| } |