@travetto/image 5.0.12 → 5.0.13

package/README.md

@@ -13,17 +13,10 @@ npm install @travetto/image
 yarn add @travetto/image
 ```
 
-This module provides functionality for image resizing, and png optimization. This is primarily meant to be used in conjunction with other modules, like the [Email Compilation Support](https://github.com/travetto/travetto/tree/main/module/email-compiler#readme "Email compiling module") module. It can also be invoked directly as needed (as it can be very handy for batch processing images on the command line). 
+This module provides functionality for image resizing, and image optimization. This is primarily meant to be used in conjunction with other modules, like the [Email Compilation Support](https://github.com/travetto/travetto/tree/main/module/email-compiler#readme "Email compiling module") module. It can also be invoked directly as needed (as it can be very handy for batch processing images on the command line). 
 
-The [ImageUtil](https://github.com/travetto/travetto/tree/main/module/image/src/util.ts#L51) functionality supports two operation modes:
-   *  In-process operations using [sharp](https://sharp.pixelplumbing.com/)
-   *  Out-of-process operations using [ImageMagick](https://imagemagick.org/index.php),[pngquant](https://pngquant.org/) and [Jpegoptim](https://github.com/tjko/jpegoptim).
-
-## In-Process
-The in process operations leverage [sharp](https://sharp.pixelplumbing.com/) and will perform within expectations, and will execute substantially faster than invoking a subprocess.  The primary caveats here being that [Jpegoptim](https://github.com/tjko/jpegoptim) and [pngquant](https://pngquant.org/) are better geared for image optimization.  Additionally, by running these processes in-memory, there will be shared contention within the process.
-
-## Out-of-Process
-The out-of-process executions will leverage external tools ([ImageMagick](https://imagemagick.org/index.php),[pngquant](https://pngquant.org/) and [Jpegoptim](https://github.com/tjko/jpegoptim)) via [CommandOperation](https://github.com/travetto/travetto/tree/main/module/command/src/command.ts#L12)s.  These tools are tried and tested, but come with the overhead of invoking a separate process to operate.  The benefit here is externalized memory usage, and a more robust optimization flow.
+## Sharp
+The in process operations leverage [sharp](https://sharp.pixelplumbing.com/) and will perform within expectations, and will execute substantially faster than invoking a subprocess.
 
 **Code: Simple Image Resize**
 ```typescript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/image",
-  "version": "5.0.12",
+  "version": "5.0.13",
   "description": "Image support, resizing, and optimization",
   "keywords": [
     "images",
@@ -23,7 +23,6 @@
     "directory": "module/image"
   },
   "dependencies": {
-    "@travetto/command": "^5.0.11",
     "@travetto/runtime": "^5.0.11",
     "sharp": "^0.33.5"
   },

package/src/util.ts

@@ -1,14 +1,13 @@
 import { Readable } from 'node:stream';
 import { ReadableStream } from 'node:stream/web';
 import { pipeline } from 'node:stream/promises';
-import { buffer as toBuffer } from 'node:stream/consumers';
-import { ChildProcess } from 'node:child_process';
 
 import type { Sharp } from 'sharp';
 
-import { CommandOperation } from '@travetto/command';
 import { castTo } from '@travetto/runtime';
 
+type ImageFormat = 'jpeg' | 'png' | 'avif' | 'webp';
+
 /**
  * Image resize options
  */
@@ -26,20 +25,16 @@ export interface ResizeOptions {
    */
   optimize?: boolean;
   /**
-   * Sub process, allows for externalization of memory
+   * Output image format, defaults to input format
    */
-  asSubprocess?: boolean;
+  format?: ImageFormat;
 }
 
 /**
  * Image optimize options
  */
 export interface OptimizeOptions {
-  format?: 'png' | 'jpeg';
-  /**
-   * Sub process, allows for externalization of memory
-   */
-  asSubprocess?: boolean;
+  format?: ImageFormat;
 }
 
 
@@ -50,49 +45,12 @@ type ImageType = Readable | Buffer | ReadableStream;
  */
 export class ImageUtil {
 
-  /**
-   * Resize/conversion util
-   */
-  static CONVERTER = new CommandOperation({
-    containerImage: 'jameskyburz/graphicsmagick-alpine:v1.0.0',
-    localCheck: ['gm', ['-version']]
-  });
-
-  /**
-   * Compressor
-   */
-  static PNG_COMPRESSOR = new CommandOperation({
-    containerImage: 'agregad/pngquant:latest',
-    localCheck: ['pngquant', ['-h']]
-  });
-
-  /**
-   * Compressor
-   */
-  static JPEG_COMPRESSOR = new CommandOperation({
-    containerImage: 'shomatan/jpegoptim:1.4.4',
-    localCheck: ['jpegoptim', ['-h']]
-  });
-
-  static async #subprocessReturn<T extends ImageType>(proc: ChildProcess, input: T): Promise<T> {
-    if (Buffer.isBuffer(input)) {
-      const [, buffer] = await Promise.all([
-        pipeline(Readable.from(input), proc.stdin!),
-        toBuffer(proc.stdout!)
-      ]);
-      return castTo(buffer);
-    } else {
-      pipeline(castTo<Readable>(input), proc.stdin!);
-      return castTo('pipeThrough' in input ? ReadableStream.from(proc.stdout!) : proc.stdout);
-    }
-  }
-
-  static async #sharpReturn<T extends ImageType>(output: Sharp, input: T, optimize?: boolean, format?: 'jpeg' | 'png'): Promise<T> {
-    if (optimize) {
-      output = output
-        .jpeg({ quality: 80, progressive: true, force: format === 'jpeg' })
-        .png({ compressionLevel: 9, quality: 80, adaptiveFiltering: true, force: format === 'png' });
-    }
+  static async #sharpReturn<T extends ImageType>(output: Sharp, input: T, optimize?: boolean, format?: ImageFormat): Promise<T> {
+    output = output
+      .jpeg({ ...(optimize ? { quality: 80, progressive: true } : {}), force: format === 'jpeg' })
+      .png({ ...(optimize ? { compressionLevel: 9, quality: 80, adaptiveFiltering: true } : {}), force: format === 'png' })
+      .avif({ ...(optimize ? { quality: 70 } : {}), force: format === 'avif' })
+      .webp({ ...(optimize ? { quality: 80 } : {}), force: format === 'webp' });
     const stream = Buffer.isBuffer(input) ? Readable.from(input) : input;
     pipeline(stream, output);
     return castTo('pipeThrough' in input ? ReadableStream.from(output) : Buffer.isBuffer(input) ? output.toBuffer() : output);
@@ -105,42 +63,26 @@ export class ImageUtil {
     const dims = [options.w, options.h].map(x => x ? Math.trunc(x) : undefined);
     const fluid = dims.some(x => !x);
 
-    if (options.asSubprocess) {
-      return this.#subprocessReturn(
-        await this.CONVERTER.exec('gm', 'convert', '-resize', dims.map(x => x || '').join('x'), '-auto-orient',
-          ...(options.optimize ? ['-strip', '-quality', '86'] : []), '-', '-'),
-        image);
-    } else {
-      const { default: sharp } = await import('sharp');
+    const { default: sharp } = await import('sharp');
 
-      return this.#sharpReturn(
-        sharp().resize({
-          width: dims[0],
-          height: dims[1],
-          fit: fluid ? 'inside' : 'fill'
-        }),
-        image,
-        options.optimize,
-      );
-    }
+    return this.#sharpReturn(
+      sharp().resize({
+        width: dims[0],
+        height: dims[1],
+        fit: fluid ? 'inside' : 'fill'
+      }),
+      image,
+      options.optimize,
+      options.format
+    );
   }
 
   /**
    * Optimize an image
    */
   static async optimize<T extends ImageType>(image: T, options: OptimizeOptions = {}): Promise<T> {
-    if (options.asSubprocess) {
-      switch (options.format) {
-        case 'png': return this.#subprocessReturn(
-          await this.PNG_COMPRESSOR.exec('pngquant', '--quality', '40-80', '--speed', '1', '--force', '-'), image);
-        default:
-        case 'jpeg': return this.#subprocessReturn(
-          await this.JPEG_COMPRESSOR.exec('jpegoptim', '-m70', '-s', '--stdin', '--stdout', '-'), image);
-      }
-    } else {
-      const { default: sharp } = await import('sharp');
-      return this.#sharpReturn(sharp(), image, true, options.format);
-    }
+    const { default: sharp } = await import('sharp');
+    return this.#sharpReturn(sharp(), image, true, options.format);
   }
 
   /**
@@ -150,4 +92,12 @@ export class ImageUtil {
     const { default: sharp } = await import('sharp');
     return sharp(image).metadata().then(v => ({ width: v.width!, height: v.height!, aspect: v.width! / v.height! }));
   }
+
+  /**
+   * Get image type
+   */
+  static async getFileType(image: Buffer | string): Promise<string> {
+    const { default: sharp } = await import('sharp');
+    return sharp(image).metadata().then(v => v.format?.replace('heif', 'avif')!);
+  }
 }