coa.js

/* jshint quotmark: false */
'use strict';

const FS = require('fs');
const PATH = require('path');
const chalk = require('chalk');
const { loadConfig, optimize } = require('../svgo-node.js');
const pluginsMap = require('../../plugins/plugins.js');
const PKG = require('../../package.json');
const { encodeSVGDatauri, decodeSVGDatauri } = require('./tools.js');
const regSVGFile = /\.svg$/i;

/**
 * Synchronously check if path is a directory. Tolerant to errors like ENOENT.
 * @param {string} path
 */
function checkIsDir(path) {
    try {
        return FS.lstatSync(path).isDirectory();
    } catch(e) {
        return false;
    }
}

module.exports = function makeProgram(program) {
    program
        .name(PKG.name)
        .description(PKG.description, {
            INPUT: 'Alias to --input'
        })
        .version(PKG.version, '-v, --version')
        .arguments('[INPUT...]')
        .option('-i, --input <INPUT...>', 'Input files, "-" for STDIN')
        .option('-s, --string <STRING>', 'Input SVG data string')
        .option('-f, --folder <FOLDER>', 'Input folder, optimize and rewrite all *.svg files')
        .option('-o, --output <OUTPUT...>', 'Output file or folder (by default the same as the input), "-" for STDOUT')
        .option('-p, --precision <INTEGER>', 'Set number of digits in the fractional part, overrides plugins params')
        .option('--config <CONFIG>', 'Config file or JSON string to extend or replace default')
        .option('--datauri <FORMAT>', 'Output as Data URI string (base64), URI encoded (enc) or unencoded (unenc)')
        .option('--multipass', 'Pass over SVGs multiple times to ensure all optimizations are applied')
        .option('--pretty', 'Make SVG pretty printed')
        .option('--indent <INTEGER>', 'Indent number when pretty printing SVGs')
        .option('-r, --recursive', 'Use with \'-f\'. Optimizes *.svg files in folders recursively.')
        .option('-q, --quiet', 'Only output error messages, not regular status messages')
        .option('--show-plugins', 'Show available plugins and exit')
        .action(action);
}

async function action(args, opts) {
    var input = opts.input || args;
    var output = opts.output;
    var config = {}

    if (opts.precision != null) {
        const number = Number.parseInt(opts.precision, 0);
        if (Number.isNaN(number)) {
            console.error("error: option '-p, --precision' argument must be an integer number");
            process.exit(1)
        } else {
            opts.precision = number;
        }
    }

    if (opts.datauri != null) {
        if (opts.datauri !== 'base64' && opts.datauri !== 'enc' && opts.datauri !== 'unenc') {
          console.error("error: option '--datauri' must have one of the following values: 'base64', 'enc' or 'unenc'")
          process.exit(1)
        }
    }

    if (opts.indent != null) {
        const number = Number.parseInt(opts.indent, 0);
        if (Number.isNaN(number)) {
            console.error("error: option '--indent' argument must be an integer number");
            process.exit(1);
        } else {
            opts.indent = number;
        }
    }

    // --show-plugins
    if (opts.showPlugins) {
        showAvailablePlugins();
        return;
    }

    // w/o anything
    if (
        (input.length === 0 || input[0] === '-') &&
        !opts.string &&
        !opts.stdin &&
        !opts.folder &&
        process.stdin.isTTY === true
    ) return program.help();

    if (typeof process == 'object' && process.versions && process.versions.node && PKG && PKG.engines.node) {
        var nodeVersion = String(PKG.engines.node).match(/\d*(\.\d+)*/)[0];
        if (parseFloat(process.versions.node) < parseFloat(nodeVersion)) {
            throw Error(`${PKG.name} requires Node.js version ${nodeVersion} or higher.`);
        }
    }

    // --config
    const loadedConfig = await loadConfig(opts.config);
    if (loadedConfig != null) {
      config = loadedConfig;
    }

    // --quiet
    if (opts.quiet) {
        config.quiet = opts.quiet;
    }

    // --recursive
    if (opts.recursive) {
        config.recursive = opts.recursive;
    }

    // --precision
    if (opts.precision != null) {
        var precision = Math.min(Math.max(0, opts.precision), 20);
        config.floatPrecision = precision;
    }

    // --multipass
    if (opts.multipass) {
        config.multipass = true;
    }

    // --pretty
    if (opts.pretty) {
        config.js2svg = config.js2svg || {};
        config.js2svg.pretty = true;
        if (opts.indent != null) {
            config.js2svg.indent = opts.indent;
        }
    }

    // --output
    if (output) {
        if (input.length && input[0] != '-') {
            if (output.length == 1 && checkIsDir(output[0])) {
                var dir = output[0];
                for (var i = 0; i < input.length; i++) {
                    output[i] = checkIsDir(input[i]) ? input[i] : PATH.resolve(dir, PATH.basename(input[i]));
                }
            } else if (output.length < input.length) {
                output = output.concat(input.slice(output.length));
            }
        }
    } else if (input.length) {
        output = input;
    } else if (opts.string) {
        output = '-';
    }

    if (opts.datauri) {
        config.datauri = opts.datauri;
    }

    // --folder
    if (opts.folder) {
        var ouputFolder = output && output[0] || opts.folder;
        await optimizeFolder(config, opts.folder, ouputFolder);
    }

    // --input
    if (input.length !== 0) {
        // STDIN
        if (input[0] === '-') {
            return new Promise((resolve, reject) => {
                var data = '',
                    file = output[0];

                process.stdin
                    .on('data', chunk => data += chunk)
                    .once('end', () => processSVGData(config, {input: 'string'}, data, file).then(resolve, reject));
            });
        // file
        } else {
            await Promise.all(
              input.map((file, n) => optimizeFile(config, file, output[n]))
            );
        }

    // --string
    } else if (opts.string) {
        var data = decodeSVGDatauri(opts.string);

        return processSVGData(config, {input: 'string'}, data, output[0]);
    }
}

/**
 * Optimize SVG files in a directory.
 * @param {Object} config options
 * @param {string} dir input directory
 * @param {string} output output directory
 * @return {Promise}
 */
function optimizeFolder(config, dir, output) {
    if (!config.quiet) {
        console.log(`Processing directory '${dir}':\n`);
    }
    return FS.promises.readdir(dir).then(files => processDirectory(config, dir, files, output));
}

/**
 * Process given files, take only SVG.
 * @param {Object} config options
 * @param {string} dir input directory
 * @param {Array} files list of file names in the directory
 * @param {string} output output directory
 * @return {Promise}
 */
function processDirectory(config, dir, files, output) {
    // take only *.svg files, recursively if necessary
    var svgFilesDescriptions = getFilesDescriptions(config, dir, files, output);

    return svgFilesDescriptions.length ?
        Promise.all(svgFilesDescriptions.map(fileDescription => optimizeFile(config, fileDescription.inputPath, fileDescription.outputPath))) :
        Promise.reject(new Error(`No SVG files have been found in '${dir}' directory.`));
}

/**
 * Get svg files descriptions
 * @param {Object} config options
 * @param {string} dir input directory
 * @param {Array} files list of file names in the directory
 * @param {string} output output directory
 * @return {Array}
 */
function getFilesDescriptions(config, dir, files, output) {
    const filesInThisFolder = files
        .filter(name => regSVGFile.test(name))
        .map(name => ({
            inputPath: PATH.resolve(dir, name),
            outputPath: PATH.resolve(output, name),
        }));

    return config.recursive ?
        [].concat(
            filesInThisFolder,
            files
                .filter(name => checkIsDir(PATH.resolve(dir, name)))
                .map(subFolderName => {
                    const subFolderPath = PATH.resolve(dir, subFolderName);
                    const subFolderFiles = FS.readdirSync(subFolderPath);
                    const subFolderOutput = PATH.resolve(output, subFolderName);
                    return getFilesDescriptions(config, subFolderPath, subFolderFiles, subFolderOutput);
                })
                .reduce((a, b) => [].concat(a, b), [])
        ) :
        filesInThisFolder;
}

/**
 * Read SVG file and pass to processing.
 * @param {Object} config options
 * @param {string} file
 * @param {string} output
 * @return {Promise}
 */
function optimizeFile(config, file, output) {
    return FS.promises.readFile(file, 'utf8').then(
        data => processSVGData(config, {input: 'file', path: file}, data, output, file),
        error => checkOptimizeFileError(config, file, output, error)
    );
}

/**
 * Optimize SVG data.
 * @param {Object} config options
 * @param {string} data SVG content to optimize
 * @param {string} output where to write optimized file
 * @param {string} [input] input file name (being used if output is a directory)
 * @return {Promise}
 */
function processSVGData(config, info, data, output, input) {
    var startTime = Date.now(),
        prevFileSize = Buffer.byteLength(data, 'utf8');

    const result = optimize(data, { ...config, ...info });
    if (config.datauri) {
        result.data = encodeSVGDatauri(result.data, config.datauri);
    }
    var resultFileSize = Buffer.byteLength(result.data, 'utf8'),
        processingTime = Date.now() - startTime;

    return writeOutput(input, output, result.data).then(function() {
        if (!config.quiet && output != '-') {
            if (input) {
                console.log(`\n${PATH.basename(input)}:`);
            }
            printTimeInfo(processingTime);
            printProfitInfo(prevFileSize, resultFileSize);
        }
    },
    error => Promise.reject(new Error(error.code === 'ENOTDIR' ? `Error: output '${output}' is not a directory.` : error)));
}

/**
 * Write result of an optimization.
 * @param {string} input
 * @param {string} output output file name. '-' for stdout
 * @param {string} data data to write
 * @return {Promise}
 */
function writeOutput(input, output, data) {
    if (output == '-') {
        console.log(data);
        return Promise.resolve();
    }

    FS.mkdirSync(PATH.dirname(output), { recursive: true });

    return FS.promises.writeFile(output, data, 'utf8').catch(error => checkWriteFileError(input, output, data, error));
}


/**
 * Write a time taken by optimization.
 * @param {number} time time in milliseconds.
 */
function printTimeInfo(time) {
    console.log(`Done in ${time} ms!`);
}

/**
 * Write optimizing information in human readable format.
 * @param {number} inBytes size before optimization.
 * @param {number} outBytes size after optimization.
 */
function printProfitInfo(inBytes, outBytes) {
    var profitPercents = 100 - outBytes * 100 / inBytes;

    console.log(
        (Math.round((inBytes / 1024) * 1000) / 1000) + ' KiB' +
        (profitPercents < 0 ? ' + ' : ' - ') +
        chalk.green(Math.abs((Math.round(profitPercents * 10) / 10)) + '%') + ' = ' +
        (Math.round((outBytes / 1024) * 1000) / 1000) + ' KiB'
    );
}

/**
 * Check for errors, if it's a dir optimize the dir.
 * @param {Object} config
 * @param {string} input
 * @param {string} output
 * @param {Error} error
 * @return {Promise}
 */
function checkOptimizeFileError(config, input, output, error) {
    if (error.code == 'EISDIR') {
        return optimizeFolder(config, input, output);
    } else if (error.code == 'ENOENT') {
        return Promise.reject(new Error(`Error: no such file or directory '${error.path}'.`));
    }
    return Promise.reject(error);
}

/**
 * Check for saving file error. If the output is a dir, then write file there.
 * @param {string} input
 * @param {string} output
 * @param {string} data
 * @param {Error} error
 * @return {Promise}
 */
function checkWriteFileError(input, output, data, error) {
    if (error.code == 'EISDIR' && input) {
        return FS.promises.writeFile(PATH.resolve(output, PATH.basename(input)), data, 'utf8');
    } else {
        return Promise.reject(error);
    }
}

/**
 * Show list of available plugins with short description.
 */
function showAvailablePlugins() {
    const list = Object.entries(pluginsMap)
      .sort(([a], [b]) => a.localeCompare(b))
      .map(([name, plugin]) => ` [ ${chalk.green(name)} ] ${plugin.description}`)
      .join('\n');
    console.log('Currently available plugins:\n' + list);
}

module.exports.checkIsDir = checkIsDir;