picslim 0.0.8 → 2.0.0

package/README.md

@@ -1,6 +1,12 @@
 # PicSlim
 
-**Picslim** is a Node.js package that allows you to optimize images in a specified directory. It supports JPEG and PNG images, and you can control the quality and resizing of the images during optimization.
+**Picslim** is a robust Node.js package that efficiently optimizes images within a specified directory (recursively). It supports **JPEG**, **PNG**, **WebP**, and **AVIF** formats, offering fine-grained control over image quality, resizing, and format conversion.
+
+Features:
+- **Fast**: Uses parallel processing to utilize all CPU cores.
+- **Recursive**: Automatically finds images in subdirectories.
+- **Modern Formats**: Optional support for generating **WebP** and **AVIF**.
+- **Smart Resizing**: Maintains aspect ratio and avoids enlarging images.
 
 ## Installation
 
@@ -10,52 +16,70 @@ You can install picslim globally using npm:
 npm install -g picslim
 ```
 
-# Usage
-
-Once installed, you can use the optimizimage command in your terminal. Here's how you can use it:
+or run it directly with npx:
 
+```bash
+npx picslim
 ```
-picslim [options]
-```
-
-Options:
 
-**-q, --quality [value]:** Set the image quality (1 to 100, default: 80).<br>
-**-mw, --maxWidth [value]:** Set the maximum width allowed (default: null).<br>
-**-mh, --maxHeight [value]:** Set the maximum height allowed (default: null).<br>
-**-c, --compressionLevel [value]:** Set the compression level (0 to 9, default: 9).
+# Usage
 
-Example:
+Once installed, you can use the `picslim` command in your terminal:
 
 ```bash
-picslim -q 90 -w 1920
+picslim [options]
 ```
 
-This will optimize all JPEG and PNG images in the current directory, and the optimized images will be saved in a 'min' directory.
-
-### Example
-
-Suppose you have a directory with the following images:
+### Options
+
+- `-c, --config <path>`: Path to the configuration file. (default: 'config.json')
+- `-q, --quality <number>`: Image quality (0-100).
+- `-l, --compressionLevel <number>`: PNG compression level (0-9).
+- `-w, --maxWidth <number>`: Maximum width allowed for images.
+- `-h, --maxHeight <number>`: Maximum height allowed for images.
+- `-i, --input <path>`: Path to the input directory.
+- `-o, --output <path>`: Path to the output directory.
+- `-f, --formats <list>`: Comma-separated list of output formats (default: Source only). Options: `source`, `webp`, `avif`.
+
+### Configuration File
+
+You can create a `config.json` file in your project directory to specify default settings.
+
+```json
+{
+  "inputDir": "./in",
+  "outputDir": "./min",
+  "quality": 80,
+  "maxWidth": null,
+  "maxHeight": null,
+  "compressionLevel": 9,
+  "formats": ["source"]
+}
+```
 
-- image1.jpg
-- image2.jpg
-- image3.png
-- image4.png
+### Examples
 
-You can optimize all these images with the following command:
+**1. Basic Optimization (Default)**
+Optimizes images in the current directory and saves them to `./min`. Keeps original format.
+```bash
+picslim
+```
 
+**2. Custom Input/Output and Resizing**
 ```bash
-picslim -q 90 -w 1920
+picslim -i ./assets -o ./build/assets -w 800
 ```
 
-After running the command, you will have the following directory structure:
+**3. Generate WebP Only**
+Converts all images to WebP format.
+```bash
+picslim -f webp
+```
 
-```markdown
-- min
-  - image1.jpg
-  - image2.jpg
-  - image3.png
-  - image4.png
+**4. Generate Optimized Source + AVIF**
+Keeps the original format (optimized) AND generates an AVIF version.
+```bash
+picslim -f source,avif
 ```
 
 ### License
@@ -65,3 +89,7 @@ This project is licensed under the MIT License. See the LICENSE file for details
 ### Author
 
 Ivan Mercedes
+
+### Contributors
+
+- [Elminson De Oleo Baez](https://github.com/elminson)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picslim",
-  "version": "0.0.8",
+  "version": "2.0.0",
   "description": "Picslim is a Node.js package that allows you to optimize images in a specified directory.",
   "main": "picslim.js",
   "bin": {
@@ -8,7 +8,11 @@
   },
   "source": "picslim.js",
   "scripts": {
-    "start": "node picslim.js  -q 80",
+    "start": "node picslim.js -q 80",
+    "test": "node picslim.js -i ./in -o ./out",
+    "test:webp": "node picslim.js -i ./in -o ./out -f webp",
+    "test:all": "node picslim.js -i ./in -o ./out -f source,webp,avif",
+    "clean": "rm -rf ./out/*",
     "format": "standard --fix",
     "prepare": "husky install"
   },
@@ -46,6 +50,8 @@
     ]
   },
   "dependencies": {
+    "chalk": "^4.1.2",
+    "cli-progress": "^3.12.0",
     "sharp": "^0.32.6",
     "yargs": "^17.7.2"
   },

package/picslim.js

@@ -1,7 +1,12 @@
 #!/usr/bin/env node
-const fs = require('fs').promises
-const sharp = require('sharp')
 const yargs = require('yargs')
+const path = require('path')
+const chalk = require('chalk')
+const cliProgress = require('cli-progress')
+const { loadConfig } = require('./src/config')
+const { walkDirectory, isImage } = require('./src/utils')
+const { processImage } = require('./src/image-processor')
+const os = require('os')
 
 /**
  * Parses command line arguments using yargs library.
@@ -12,153 +17,139 @@ function parseArguments () {
       alias: 'config',
       describe: 'Path to the configuration file',
       demandOption: false,
-      type: 'string',
-      default: 'config.json'
+      type: 'string'
+    },
+    q: {
+      alias: 'quality',
+      describe: 'Image quality',
+      type: 'number'
+    },
+    l: {
+      alias: 'compressionLevel',
+      describe: 'PNG compression level',
+      type: 'number'
+    },
+    w: {
+      alias: 'maxWidth',
+      describe: 'Maximum width allowed',
+      type: 'number'
+    },
+    h: {
+      alias: 'maxHeight',
+      describe: 'Maximum height allowed',
+      type: 'number'
+    },
+    i: {
+      alias: 'input',
+      describe: 'Path to the input directory',
+      type: 'string'
+    },
+    o: {
+      alias: 'output',
+      describe: 'Path to the output directory',
+      type: 'string'
+    },
+    f: {
+      alias: 'formats',
+      describe: 'Output formats (comma separated). Default: source. Options: source, webp, avif',
+      type: 'string'
     }
   }).argv
 }
 
-/**
- * Verifies if the output directory exists; if not, creates it.
- *
- * @param {string} dir - The directory to verify.
- */
-async function createOutputDirectory (dir) {
-  try {
-    await fs.access(dir)
-  } catch (error) {
-    await fs.mkdir(dir)
-  }
-}
-
-/**
- * Process and optimize an image file.
- *
- * @param {string} inputPath - Path to the input image file.
- * @param {string} outputPath - Path to the output image file.
- * @param {string} file - The file name.
- * @param {number} maxWidth - Maximum width allowed.
- * @param {number} maxHeight - Maximum height allowed.
- * @param {number} quality - Image quality.
- * @param {number} compressionLevel - PNG compression level.
- */
-async function processImage (inputPath, outputPath, file, maxWidth, maxHeight, quality, compressionLevel) {
-  try {
-    const image = sharp(inputPath)
-    const metadata = await image.metadata()
-    const originalWidth = metadata.width
-    const originalHeight = metadata.height
-    const imageProcessor = image.resize(
-      originalWidth > maxWidth ? maxWidth : null,
-      originalHeight > maxHeight ? maxHeight : null
-    )
-
-    if (file.match(/\.(jpg|jpeg)$/i)) {
-      await imageProcessor.jpeg({ quality }).toFile(outputPath)
-      console.log(`Optimized JPEG image: ${file}`)
-    } else if (file.match(/\.(png)$/i)) {
-      await imageProcessor.png({ quality, compressionLevel }).toFile(outputPath)
-      console.log(`Optimized PNG image: ${file}`)
-    }
-  } catch (error) {
-    console.error(`Optimization error ${file}: `, error)
-  }
-}
+async function main () {
+  console.log(chalk.blue('picslim - Image Optimization Tool'))
 
-/**
- * Load settings from a configuration file.
- *
- * @param {string} configFile - Path to the configuration file.
- */
-async function loadConfig (configFile) {
-  try {
-    const configData = await fs.readFile(configFile, 'utf8')
+  const argv = parseArguments()
 
-    if (configData.trim() === '') {
-      console.error('Configuration file is empty.')
-      process.exit(1)
-    }
+  // Load config (merges defaults, config file, and argv)
+  const baseConfig = await loadConfig(argv.config)
 
-    if (!validateJson(configData)) {
-      console.error('Configuration file is not a valid JSON object.')
-      process.exit(1)
-    }
+  // Parse formats from CLI if present
+  let formats = baseConfig.formats
+  if (argv.formats) {
+    formats = argv.formats.split(',').map(f => f.trim().toLowerCase())
+  }
 
-    const config = JSON.parse(configData)
+  // Overrides from argv
+  const config = {
+    ...baseConfig,
+    inputDir: argv.input || baseConfig.inputDir,
+    outputDir: argv.output || baseConfig.outputDir,
+    quality: argv.quality || baseConfig.quality,
+    compressionLevel: argv.compressionLevel || baseConfig.compressionLevel,
+    maxWidth: argv.maxWidth || baseConfig.maxWidth,
+    maxHeight: argv.maxHeight || baseConfig.maxHeight,
+    formats
+  }
 
-    validateConfig(config)
+  const inputDir = path.resolve(config.inputDir)
+  const outputDir = path.resolve(config.outputDir)
 
-    if (typeof config !== 'object' || Array.isArray(config)) {
-      console.error('Configuration file is not a valid JSON object.')
-      process.exit(1)
-    }
+  console.log(chalk.gray(`Input: ${inputDir}`))
+  console.log(chalk.gray(`Output: ${outputDir}`))
 
-    if (!config.inputDir || !config.outputDir) {
-      console.error("Configuration error: 'inputDir' and 'outputDir' are required fields.")
-      process.exit(1)
-    }
-
-    return config
-  } catch (error) {
-    console.error('Error loading or parsing the configuration file: ', error)
+  // Find files
+  console.log('Scanning files...')
+  let files = []
+  try {
+    files = await walkDirectory(inputDir)
+  } catch (e) {
+    console.error(chalk.red(`Error reading input directory: ${e.message}`))
     process.exit(1)
   }
-}
 
-function validateJson (json) {
-  const isJson = (str) => {
-    try {
-      JSON.parse(str)
-    } catch (e) {
-      // Error
-      // JSON is not okay
-      return false
-    }
+  // Filter images
+  const images = files.filter(isImage)
 
-    return true
+  if (images.length === 0) {
+    console.log(chalk.yellow('No images found to process.'))
+    return
   }
 
-  return isJson(json)
-}
+  console.log(chalk.green(`Found ${images.length} images. Starting optimization...`))
 
-/**
- * Validate the configuration object.
- *
- * @param {object} config - The loaded configuration object.
- */
-function validateConfig (config) {
-  if (!config.inputDir || !config.outputDir) {
-    console.error("Configuration error: 'inputDir' and 'outputDir' are required fields.")
-    process.exit(1)
-  }
-}
+  // Prepare batch processing
+  const progressBar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic)
+  progressBar.start(images.length, 0)
 
-/**
- * The main function that processes all image files in the input directory.
- */
-async function main () {
-  const argv = parseArguments()
-  const config = await loadConfig(argv.config)
+  const concurrencyLevel = os.cpus().length // Use number of CPU cores
 
-  const inputDir = config.inputDir
-  const outputDir = config.outputDir
-  const quality = config.quality
-  const maxWidth = config.maxWidth
-  const maxHeight = config.maxHeight
-  const compressionLevel = config.compressionLevel
+  let completed = 0
+  const errors = []
 
-  await createOutputDirectory(outputDir)
+  // Chunking helper
+  const chunk = (arr, size) => Array.from({ length: Math.ceil(arr.length / size) }, (v, i) =>
+    arr.slice(i * size, i * size + size)
+  )
 
-  try {
-    const files = await fs.readdir(inputDir)
-    for (const file of files) {
-      const inputPath = `${inputDir}/${file}`
-      const outputPath = `${outputDir}/${file}`
-      await processImage(inputPath, outputPath, file, maxWidth, maxHeight, quality, compressionLevel)
-    }
-  } catch (error) {
-    console.error('Error reading input directory: ', error)
+  const batches = chunk(images, concurrencyLevel)
+
+  for (const batch of batches) {
+    const promises = batch.map(async (filePath) => {
+      const relativePath = path.relative(inputDir, filePath)
+      const result = await processImage(filePath, outputDir, relativePath, config)
+      completed++
+      progressBar.update(completed)
+      if (!result.success) {
+        errors.push(result)
+      }
+    })
+    await Promise.all(promises)
+  }
+
+  progressBar.stop()
+
+  console.log('\n' + chalk.blue('--------------------------------------------------'))
+  console.log(chalk.green('Optimization complete!'))
+  console.log(`Processed: ${completed}`)
+  if (errors.length > 0) {
+    console.log(chalk.red(`Errors: ${errors.length}`))
+    errors.forEach(e => console.log(chalk.red(` - ${e.file}: ${e.error}`)))
+  } else {
+    console.log(chalk.green('No errors encountered.'))
   }
+  console.log(chalk.blue('--------------------------------------------------'))
 }
 
 main()