picslim 1.0.0 → 2.0.0

package/README.md

@@ -1,6 +1,12 @@
 # PicSlim
 
-**Picslim** is a Node.js package that allows you to efficiently optimize images within a specified directory. It supports **JPEG** and **PNG** images, image formats, offering fine-grained control over image quality and resizing options during the optimization process. With **Picslim**, you can effortlessly reduce file sizes and enhance the loading performance of your images.
+**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,7 +16,7 @@ You can install picslim globally using npm:
 npm install -g picslim
 ```
 
-or
+or run it directly with npx:
 
 ```bash
 npx picslim
@@ -18,9 +24,9 @@ npx picslim
 
 # Usage
 
-Once installed, you can use the optimizimage command in your terminal. Here's how you can use it:
+Once installed, you can use the `picslim` command in your terminal:
 
-```
+```bash
 picslim [options]
 ```
 
@@ -33,10 +39,11 @@ picslim [options]
 - `-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. Here's an example configuration:
+You can create a `config.json` file in your project directory to specify default settings.
 
 ```json
 {
@@ -45,49 +52,34 @@ You can create a `config.json` file in your project directory to specify default
   "quality": 80,
   "maxWidth": null,
   "maxHeight": null,
-  "compressionLevel": 9
+  "compressionLevel": 9,
+  "formats": ["source"]
 }
 ```
 
-### Example:
-
-Optimize images using default settings from the configuration file:
+### Examples
 
+**1. Basic Optimization (Default)**
+Optimizes images in the current directory and saves them to `./min`. Keeps original format.
 ```bash
 picslim
 ```
 
-Optimize images with custom settings:
-
+**2. Custom Input/Output and Resizing**
 ```bash
-picslim -q 90 -w 800 -h 600 -l 4 -i input_images -o output_images
+picslim -i ./assets -o ./build/assets -w 800
 ```
 
-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:
-
-- image1.jpg
-- image2.jpg
-- image3.png
-- image4.png
-
-You can optimize all these images with the following command:
-
+**3. Generate WebP Only**
+Converts all images to WebP format.
 ```bash
-picslim -q 90 -w 1920
+picslim -f webp
 ```
 
-After running the command, you will have the following directory structure:
-
-```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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picslim",
-  "version": "1.0.0",
+  "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,184 +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',
-      demandOption: false,
-      type: 'number',
-      default: null
+      type: 'number'
     },
     l: {
       alias: 'compressionLevel',
       describe: 'PNG compression level',
-      demandOption: false,
-      type: 'number',
-      default: null
+      type: 'number'
     },
     w: {
       alias: 'maxWidth',
       describe: 'Maximum width allowed',
-      demandOption: false,
-      type: 'number',
-      default: null
+      type: 'number'
     },
     h: {
       alias: 'maxHeight',
       describe: 'Maximum height allowed',
-      demandOption: false,
-      type: 'number',
-      default: null
+      type: 'number'
     },
     i: {
       alias: 'input',
       describe: 'Path to the input directory',
-      demandOption: false,
-      type: 'string',
-      default: null
+      type: 'string'
     },
     o: {
       alias: 'output',
       describe: 'Path to the output directory',
-      demandOption: false,
-      type: 'string',
-      default: null
+      type: 'string'
+    },
+    f: {
+      alias: 'formats',
+      describe: 'Output formats (comma separated). Default: source. Options: source, webp, avif',
+      type: 'string'
     }
   }).argv
 }
 
-/**
- * Creates an output directory if it doesn't exist.
- * @param {string} dir - The directory path to create.
- * @returns {Promise<void>}
- */
-async function createOutputDirectory (dir) {
-  try {
-    await fs.access(dir)
-  } catch (error) {
-    await fs.mkdir(dir)
-  }
-}
+async function main () {
+  console.log(chalk.blue('picslim - Image Optimization Tool'))
 
-/**
- * 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)
+  const argv = parseArguments()
+
+  // Load config (merges defaults, config file, and argv)
+  const baseConfig = await loadConfig(argv.config)
+
+  // Parse formats from CLI if present
+  let formats = baseConfig.formats
+  if (argv.formats) {
+    formats = argv.formats.split(',').map(f => f.trim().toLowerCase())
   }
-}
 
-/**
- * Load settings from a configuration file. If the specified configuration file doesn't exist,
- * it will use the default 'config.json' from the package.
- *
- * @param {string} configFile - Path to the configuration file.
- */
-async function loadConfig (configFile) {
-  let config
-  try {
-    const configData = await fs.readFile(configFile, 'utf8')
-    config = JSON.parse(configData)
-  } catch (error) {
-    console.error('Using the default configuration from the package. ✅')
-    config = require('./config.json') // Load default configuration from the package
+  // 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
   }
 
-  if (!validateConfigObject(config)) {
-    console.error('Invalid configuration object.')
+  const inputDir = path.resolve(config.inputDir)
+  const outputDir = path.resolve(config.outputDir)
+
+  console.log(chalk.gray(`Input: ${inputDir}`))
+  console.log(chalk.gray(`Output: ${outputDir}`))
+
+  // 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)
   }
 
-  if (!config.inputDir || !config.outputDir) {
-    console.error("Configuration error: 'inputDir' and 'outputDir' are required fields.")
-    process.exit(1)
+  // Filter images
+  const images = files.filter(isImage)
+
+  if (images.length === 0) {
+    console.log(chalk.yellow('No images found to process.'))
+    return
   }
 
-  return config
-}
+  console.log(chalk.green(`Found ${images.length} images. Starting optimization...`))
 
-/**
- * Validate the configuration object.
- *
- * @param {object} config - The loaded configuration object.
- */
-function validateConfigObject (config) {
-  return (
-    typeof config === 'object' &&
-    !Array.isArray(config) &&
-    config.inputDir &&
-    config.outputDir
-  )
-}
+  // Prepare batch processing
+  const progressBar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic)
+  progressBar.start(images.length, 0)
 
-/**
- * Returns the input directory path based on the provided arguments and configuration.
- * If the provided arguments or configuration are '.', returns the current working directory.
- * @param {string} argvInput - The input directory path provided as an argument.
- * @param {string} configInputDir - The input directory path provided in the configuration.
- * @returns {string} - The input directory path.
- */
-function getInputDirectory (argvInput, configInputDir) {
-  if (argvInput === '.' || configInputDir === '.') {
-    return process.cwd()
-  }
+  const concurrencyLevel = os.cpus().length // Use number of CPU cores
 
-  return argvInput || configInputDir
-}
+  let completed = 0
+  const errors = []
 
-/**
- * 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 inputDir = getInputDirectory(argv.input, config.inputDir)
-  const outputDir = getInputDirectory(argv.output, config.outputDir)
-  const quality = argv.quality ? argv.quality : config.quality
-  const maxWidth = argv.maxWidth ? argv.maxWidth : config.maxWidth
-  const maxHeight = argv.maxHeight ? argv.maxHeight : config.maxHeight
-  const compressionLevel = argv.compressionLevel ? argv.compressionLevel : config.compressionLevel
+  // Chunking helper
+  const chunk = (arr, size) => Array.from({ length: Math.ceil(arr.length / size) }, (v, i) =>
+    arr.slice(i * size, i * size + size)
+  )
 
-  await createOutputDirectory(outputDir)
+  const batches = chunk(images, concurrencyLevel)
 
-  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)
+  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()