ImageMinify/ImageMinify.js

#! /usr/bin/env node
`use strict`

var fs   = require('fs-extra');
var path = require('path');
var exec = require('child_process').exec;
var program      = require('commander');
var readlineSync = require('readline-sync');
var ProgressBar  = require('progress');


program
.option('-r, --removeorigin', 'Auto remove origin image when jobs done')
.option('-s, --silence', 'Run in background')
.option('-q, --quality <quality>', 'Output image quality.Default is 85')
.option('-e, --ext <ext>', 'Output file extension.Support jpg,png,auto.Default is auto')
.option('-o, --output <output>', 'Output folder path.Default is current image path with a subfolder named minified')
.usage('-q [Quality] -e [Extension] -o [Output Path] Path...')
.arguments('[path...]')
.parse(process.argv);

var Config = {
    path : program.args[0],
    quality : program.quality,
    output : program.output,
    ext : program.ext,
    isFolder:false,
    currentDir:'',
    outputDir:''
}
var ImageList = [],failureList = [];
var processBar;

if(!Config.path) return program.outputHelp();
exec('gm -version | grep -o -E \'^GraphicsMagick ([0-9]|\.)+\'',function(err,stdout,stderr){
    if(err || !stdout) return console.error('GraphicsMagick not installed!!!')
    checkPath();
})

function checkPath(){
    fs.stat(Config.path,function(err,stats){
        if(err || !stats) return console.error(`No such file or directory [${Config.path}]`)

        if(stats.isFile()){
            let ext = path.extname(Config.path);
            if(!ext.match(/^.(jpg|jpeg|png|gif|bmp|raw)$/gi)){
                return console.log("ImageMinify only support image with extension name in jpg,jpeg,png,gif,bmp or raw");
            }
            ImageList.push(Config.path);
            Config.currentDir = path.parse(Config.path).dir;
            prepareTask();
        }else{
            Config.isFolder = true;
            Config.currentDir = path.resolve(Config.path);
            analysisFolder(Config.currentDir);
            prepareTask();
        }
    });
}
function analysisFolder(readPath){
    let currentPath = readPath;
    let fileList = fs.readdirSync(currentPath);
    for(let fileName of fileList){
        let filePath = path.join(currentPath,fileName);
        let fileStat = fs.statSync(filePath);
        if(fileStat.isFile()){
            let ext = path.extname(fileName);
            if(ext.match(/jpg|jpeg|png|gif|bmp|raw/gi)){
                ImageList.push(filePath);
            }
        }else{
            analysisFolder(filePath);
        }
    }
}

function prepareTask(){
    if(!Config.output){
        if(program.silence){
            Config.output = 'minified';
        }else{
            Config.output = readlineSync.question('Output directory [minified] : ');
            if(!Config.output) Config.output = 'minified';
        }
    }
    Config.outputDir = path.resolve(Config.currentDir,Config.output);

    if(!Config.quality){
        if(program.silence){
            Config.quality = 85;
        }else{
            Config.quality = Number(readlineSync.question('Output quality [85] : '));
            if(!Config.quality) Config.quality = 85;
        }
    }

    if(!Config.ext){
        if(program.silence){
            Config.ext = 'auto';
        }else{
            Config.ext = readlineSync.question('Output extension,only support jpg,png,gif or auto [auto] : ');
            if(!Config.ext || !Config.ext.match(/^(jpg|png|gif)$/i)) Config.ext = 'auto';
        }
    }

    startTask();
}

function startTask(){
    console.log('-----------------------------------------------------------------');
    console.log(`[ Path ] ${Config.path}`);
    console.log(`[Folder] ${Config.isFolder}\t[Quality] ${Config.quality}\t[OutputExtension] ${Config.ext}\t[Amount] ${ImageList.length}`);
    console.log('-----------------------------------------------------------------');
    console.log(`[OutputDirectory] ${Config.outputDir}`);
    console.log('-----------------------------------------------------------------');
    processBar = new ProgressBar('Minifying: [:bar][:current/:total] [:image]', { total: ImageList.length, width: 20, complete: '*' });
    minify();
}

function minify(){
    if(ImageList.length==0) return finished();
    let image = ImageList.pop();
    let pathParse = path.parse(image);
    let imageDir = pathParse.dir;
    let fileName = pathParse.name;
    let subDir = imageDir.replace(Config.currentDir,'');
    let outputExt = (Config.ext=='auto')?pathParse.ext.replace('.',''):Config.ext;
    let outputDir = Config.outputDir + subDir;
    let outputFile = `${outputDir}/${fileName}.${outputExt}`;
    fs.mkdirpSync(outputDir);
    exec(`gm convert -strip -format '${outputExt}' -quality ${Config.quality} -depth 8 '${image}' '${outputFile}'`,function(err,stdout,stderr){
        if(err || stdout || stderr){
            failureList.push(image);
        }else{
            if(program.removeorigin) fs.removeSync(image);
        }
        processBar.tick(1,{'image':`${subDir}/${fileName}`});
        minify();
    });
}
function finished(){
    if(!program.silence) console.log('\All images minified');
}