@travetto/image 5.0.12 → 5.0.14

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
@@ -34,7 +27,7 @@ import { ImageUtil } from '@travetto/image';
 
 export class ResizeService {
   async resizeImage(imgPath: string, width: number, height: number): Promise<string> {
-    const stream = await ImageUtil.resize(createReadStream(imgPath), { w: width, h: height });
+    const stream = await ImageUtil.convert(createReadStream(imgPath), { w: width, h: height });
     const out = imgPath.replace(/[.][^.]+$/, (ext) => `.resized${ext}`);
     await pipeline(stream, createWriteStream(out));
     return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/image",
-  "version": "5.0.12",
+  "version": "5.0.14",
   "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,18 +1,15 @@
 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 { AppError, castTo } from '@travetto/runtime';
 
-import { CommandOperation } from '@travetto/command';
-import { castTo } from '@travetto/runtime';
+type ImageFormat = 'jpeg' | 'png' | 'avif' | 'webp';
 
 /**
- * Image resize options
+ * Image convert options
  */
-export interface ResizeOptions {
+export interface ConvertOptions {
   /**
    * New height
    */
@@ -26,23 +23,11 @@ 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;
-}
-
-
 type ImageType = Readable | Buffer | ReadableStream;
 
 /**
@@ -51,103 +36,67 @@ 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
+   * Resize image
    */
-  static PNG_COMPRESSOR = new CommandOperation({
-    containerImage: 'agregad/pngquant:latest',
-    localCheck: ['pngquant', ['-h']]
-  });
+  static async convert<T extends ImageType>(image: T, options: ConvertOptions): Promise<T> {
+    if (options.optimize && !options.format) {
+      if (Buffer.isBuffer(image)) {
+        options.format = await this.getFileType(image);
+      }
+      throw new AppError('Format is required for optimizing');
+    }
 
-  /**
-   * Compressor
-   */
-  static JPEG_COMPRESSOR = new CommandOperation({
-    containerImage: 'shomatan/jpegoptim:1.4.4',
-    localCheck: ['jpegoptim', ['-h']]
-  });
+    const { default: sharp } = await import('sharp');
 
-  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);
+    let builder = sharp();
+    if (options.w || options.h) {
+      const dims = [options.w, options.h].map(x => x ? Math.trunc(x) : undefined);
+      const fluid = dims.some(x => !x);
+      builder = builder.resize({
+        width: dims[0],
+        height: dims[1],
+        fit: fluid ? 'inside' : 'fill'
+      });
     }
-  }
 
-  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' });
+    switch (options.format) {
+      case 'jpeg':
+        builder = builder.jpeg(options.optimize ? { quality: 80, progressive: true } : {});
+        break;
+      case 'png':
+        builder = builder.png(options.optimize ? { compressionLevel: 9, quality: 80, adaptiveFiltering: true } : {});
+        break;
+      case 'avif':
+        builder = builder.avif(options.optimize ? { quality: 70 } : {});
+        break;
+      case 'webp':
+        builder = builder.webp(options.optimize ? { quality: 80 } : {});
+        break;
     }
-    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);
-  }
-
-  /**
-   * Resize image
-   */
-  static async resize<T extends ImageType>(image: T, options: ResizeOptions = {}): Promise<T> {
-    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');
 
-      return this.#sharpReturn(
-        sharp().resize({
-          width: dims[0],
-          height: dims[1],
-          fit: fluid ? 'inside' : 'fill'
-        }),
-        image,
-        options.optimize,
-      );
-    }
+    const stream = Buffer.isBuffer(image) ? Readable.from(image) : image;
+    pipeline(stream, builder);
+    return castTo('pipeThrough' in image ?
+      ReadableStream.from(builder) :
+      Buffer.isBuffer(image) ? builder.toBuffer() : builder);
   }
 
   /**
-   * Optimize an image
+   * Get Image Dimensions
    */
-  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);
-    }
+  static async getDimensions(image: Buffer | string): Promise<{ width: number, height: number, aspect: number }> {
+    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 Dimensions
+   * Get image type
    */
-  static async getDimensions(image: Buffer | string): Promise<{ width: number, height: number, aspect: number }> {
+  static async getFileType(image: Buffer | string): Promise<ImageFormat> {
     const { default: sharp } = await import('sharp');
-    return sharp(image).metadata().then(v => ({ width: v.width!, height: v.height!, aspect: v.width! / v.height! }));
+    return sharp(image).metadata().then(v =>
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      v.format?.replace('heif', 'avif')! as ImageFormat
+    );
   }
 }