Changes for version 4.0.0.

A logging system has been added.

The alsoProcessOriginal rule has been added.

The sharp dependency has been updated to version 0.33.2.

Node version no lower than 18.17.0 is now required to work.

Author: Ulyanov-programmer

README.md

@@ -34,21 +34,24 @@ _OR_
 ```
 yarn add gulp-sharp-optimize-images -D
 ```
-****
+
+---
+
 ### Example of usage
 
 ```js
-import sharpOptimizeImages from "gulp-sharp-optimize-images";
-import gulp from "gulp";
+import sharpOptimizeImages from 'gulp-sharp-optimize-images';
+import gulp from 'gulp';
 
 export function yourImages() {
   return gulp
-    .src("yourSrcImagePath")
+    .src('yourSrcImagePath')
     .pipe(
       sharpOptimizeImages({
         webp: {
           quality: 80,
           lossless: false,
+          alsoProcessOriginal: true,
         },
         avif: {
           quality: 100,
@@ -67,7 +70,7 @@ export function yourImages() {
       })
     )
 
-    .pipe(gulp.dest("yourDistImagePath"));
+    .pipe(gulp.dest('yourDistImagePath'));
 }
 ```
 
@@ -93,8 +96,11 @@ Also optimizes and transmits the original.
 <br>
 
 ```js
-// example, all images will be converted to avif. The originals will also be optimized and transferred.
+// example, all images will be converted to avif.
 avif: {
+  // If true, the originals will also be optimized and transferred.
+  alsoProcessOriginal: false,
+
   param: value,
 },
 ```
@@ -104,7 +110,13 @@ avif: {
 Type: `any` (depends on the parameter)<br>
 Option for an output image. <br>
 To get acquainted with all the available parameters, please take a look:
-https://sharp.pixelplumbing.com/api-output#jpeg
+https://sharp.pixelplumbing.com/api-output
+
+#### alsoProcessOriginal
+
+Type: `boolean`<br>
+Default value: `false`<br>
+It also allows you to optimize and move the original file. It only works for the type `outputImageExtname: {}` parameter. <br>
 
 ### imageExtname_to_imageExtname
 
@@ -123,6 +135,33 @@ jpg_to_jpg: {
 },
 ```
 
+### logLevel
+
+Type: `string`<br>
+Default value: `small`<br>
+Can get the value: `small | full | ''`<br>
+Allows you to change the logging.
+
+```js
+// usage example
+sharpOptimizeImages({
+  logLevel: 'small',
+  ...
+});
+```
+
+```bash
+// Log if the value of logLevel is equal to 'small' (default value):
+yourImage.jpg => webp
+
+// Log if the value of logLevel is equal to 'full':
+The file the_absolute_path_to_your/image.jpg was processed to image.webp
+
+// Log if the value of logLevel is equal to '' (or other value):
+
+(the log is disabled)
+```
+
 ### Supported format names:
 
 - `png`

index.d.ts

@@ -13,6 +13,8 @@ interface SharpOptimizeImagesInputTypes {
 
 interface SharpOptimizeImagesTypesParams {
   quality?: number
+  logLevel?: string
+  alsoProcessOriginal?: boolean
   lossless?: boolean
   progressive?: boolean
   chromaSubsampling?: string

index.js

@@ -1,122 +1,133 @@
 import { obj } from 'through2'
 import sharp from 'sharp'
 import Vinyl from 'vinyl'
-
-const ALLOWED_EXTENSIONS = [
-  '.gif',
-  '.png',
-  '.jpg', '.jpeg',
-  '.webp',
-  '.avif',
-  '.tiff',
-  '.heif',
-]
-const optionsByDefault = {
-  quality: 90,
-  lossless: false,
-  chromaSubsampling: '4:2:0'
-}
+import chalk from 'chalk'
+
+const
+  ALLOWED_EXTENSIONS = [
+    '.gif',
+    '.png',
+    '.jpg', '.jpeg',
+    '.webp',
+    '.avif',
+    '.tiff',
+    '.heif',
+  ],
+  DEFAULT_CONVERSION_OPTIONS = {
+    quality: 90,
+    lossless: false,
+    chromaSubsampling: '4:2:0',
+  },
+  DEFAULT_SHARP_OPTIONS = {
+    animated: true,
+    limitInputPixels: false,
+  }
 
 
 export default function sharpOptimizeImages(options) {
+  let logLevel = options.logLevel ?? 'small'
+  delete options.logLevel
+  let optionObjects = Object.entries(options)
+
   return obj(async function (file, enc, callback) {
-    if (file.isNull()) {
-      return callback(null, file)
-    }
-    if (ALLOWED_EXTENSIONS.includes(file.extname) == false) {
-      console.error(`${file.basename} not supported, just copy.`)
+    if (!file) return callback(null, file)
 
-      return callback(null, file)
-    }
-    if (typeof options !== 'object') {
+    if (typeof options !== 'object')
       throw new Error('Invalid parameters, they must be an object.')
+
+    if (!ALLOWED_EXTENSIONS.includes(file.extname)) {
+      logAboutSuccessfulCopy(file, logLevel)
+      return callback(null, file)
     }
 
-    let convertedImages = []
-    let optionObjects = Object.entries(options)
+    let originalFileExtname = file.extname.split('.').at(-1)
+
 
-    for (let [optionObjectFormat, optionObjectProps] of optionObjects) {
-      let splittedObjectName = optionObjectFormat.split('_to_')
-      let convertFromOfGeneralExtname = splittedObjectName[0]
-      let convertToExtname = splittedObjectName[1]
+    for (let [format, props] of optionObjects) {
+      let [convertFrom, convertTo] = format.split('_to_')
 
-      if (extnamesIsCorrect(convertFromOfGeneralExtname, convertToExtname) == false) {
+      if (!extnamesIsCorrect(convertFrom, convertTo)) {
         throw new Error('Invalid name of an object! Make sure you have spelled the extension names correctly.')
       }
 
-      if (convertToExtname == undefined) {
-        let optimizedFile = await convert(file, file.extname.replace('.', ''), optionObjectProps)
-        let convertedFile = await convert(file, convertFromOfGeneralExtname, optionObjectProps)
+      // Checking that the file has not a suitable extension
+      if (convertTo && `.${convertFrom}` != file.extname) continue
 
-        convertedImages.push(optimizedFile, convertedFile)
-      }
-      else if (file.extname == `.${convertFromOfGeneralExtname}`) {
-        let convertedFile = await convert(file, convertToExtname, optionObjectProps)
-        convertedImages.push(convertedFile)
+      //? For general conversion rules such as png: {}
+      if (!convertTo) {
+        this.push(await convert(file, convertFrom, props))
+        logAboutSuccessfulConversion(file, convertFrom, logLevel)
+
+        if (props.alsoProcessOriginal) {
+          this.push(await convert(file, originalFileExtname, props))
+          logAboutSuccessfulConversion(file, originalFileExtname, logLevel)
+        }
       }
-    }
+      //? For specific conversion rules such as png_to_webp: {}
+      else {
+        this.push(await convert(file, convertTo, props))
 
-    for (let convertedImage of convertedImages) {
-      this.push(convertedImage)
+        logAboutSuccessfulConversion(file, convertTo, logLevel)
+      }
     }
 
     return callback()
   })
 }
 
 async function convert(file, newFileFormat, options) {
-  let sharpInstance = sharp(file.contents, { animated: true, limitInputPixels: false, })
-
-  switch (newFileFormat) {
-    case 'gif':
-      sharpInstance = sharpInstance.gif(Object.assign(optionsByDefault, options))
-      break
-    case 'png':
-      sharpInstance = sharpInstance.png(Object.assign(optionsByDefault, options))
-      break
-    case 'jpg':
-    case 'jpeg':
-      sharpInstance = sharpInstance.jpeg(Object.assign(optionsByDefault, options))
-      break
-    case 'webp':
-      sharpInstance = sharpInstance.webp(Object.assign(optionsByDefault, options))
-      break
-    case 'tiff':
-      sharpInstance = sharpInstance.tiff(Object.assign(optionsByDefault, options))
-      break
-    case 'avif':
-      sharpInstance = sharpInstance.avif(Object.assign(optionsByDefault, options))
-      break
-    case 'heif':
-      sharpInstance = sharpInstance.heif(Object.assign(optionsByDefault, options))
-      break
-    default:
-      return false
-  }
+  let sharpInstance =
+    sharp(file.contents, DEFAULT_SHARP_OPTIONS)
+      .toFormat(newFileFormat, Object.assign(DEFAULT_CONVERSION_OPTIONS, options))
 
-  let buffer = await sharpInstance.toBuffer()
-  return toVinyl(buffer, newFileFormat, file)
+  return toVinyl(await sharpInstance.toBuffer(), newFileFormat, file)
 }
 
 function toVinyl(buffer, newFileFormat, file) {
-  let newFileName = file.basename.substr(0, file.basename.lastIndexOf(".")) + `.${newFileFormat}`
-  let newFilePath = `${file.dirname}/${newFileName}`
+  let newFileName = file.basename.substr(0, file.basename.lastIndexOf('.'))
+    + '.' + newFileFormat
 
   return new Vinyl({
     cwd: file.cwd,
     base: file.base,
-    path: newFilePath,
+    path: `${file.dirname}\\${newFileName}`,
     contents: buffer,
   })
 }
 
 
 function extnamesIsCorrect(...extnames) {
   for (let extname of extnames) {
-    if (extname && ALLOWED_EXTENSIONS.includes(`.${extname}`) == false) {
+    if (extname && !ALLOWED_EXTENSIONS.includes('.' + extname))
       return false
-    } else {
-      return true
-    }
   }
+
+  return true
+}
+
+function logAboutSuccessfulConversion(file, newFileExtname, logLevel) {
+  let filename = file.basename.split('.')[0]
+
+  if (logLevel == 'full')
+    console.log(
+      'The file ' + chalk.green(file.path)
+      + ' was processed to '
+      + chalk.green(filename + '.' + chalk.bold(newFileExtname))
+    )
+  else if (logLevel == 'small')
+    console.log(
+      chalk.green(file.basename) + ' => ' + chalk.green.bold(newFileExtname)
+    )
+}
+function logAboutSuccessfulCopy(file, logLevel) {
+  if (logLevel == 'full')
+    console.log(chalk.hex('#FF8800')
+      (
+        `The image ${chalk.bold(file.basename)} cannot be processed, so it is copied.`
+      )
+    )
+  else if (logLevel == 'small')
+    console.log(chalk.hex('#FF8800')
+      (file.basename + ' => ' + chalk.bold('copied'))
+    )
 }

package.json

@@ -33,15 +33,15 @@
     "avif"
   ],
   "engines": {
-    "node": ">=14.15.0"
+    "node": ">=18.17.0"
   },
   "bugs": {
     "url": "https://github.com/Ulyanov-programmer/gulp-sharp-optimize-images/issues"
   },
   "dependencies": {
-    "sharp": "^0.32.1",
+    "sharp": "^0.33.2",
     "through2": "^4.0.2",
     "vinyl": "^3.0.0"
   },
   "devDependencies": {}
-}
+}