@travetto/image 5.0.13 → 5.0.15

package/README.md

@@ -27,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.13",
+  "version": "5.0.15",
   "description": "Image support, resizing, and optimization",
   "keywords": [
     "images",

package/src/util.ts

@@ -1,17 +1,18 @@
+import { createReadStream } from 'node:fs';
 import { Readable } from 'node:stream';
 import { ReadableStream } from 'node:stream/web';
 import { pipeline } from 'node:stream/promises';
-
-import type { Sharp } from 'sharp';
+import { Metadata } from 'sharp';
 
 import { castTo } from '@travetto/runtime';
 
 type ImageFormat = 'jpeg' | 'png' | 'avif' | 'webp';
+type Input = Buffer | string | ReadableStream | Readable;
 
 /**
- * Image resize options
+ * Image convert options
  */
-export interface ResizeOptions {
+export interface ConvertOptions {
   /**
    * New height
    */
@@ -30,74 +31,68 @@ export interface ResizeOptions {
   format?: ImageFormat;
 }
 
-/**
- * Image optimize options
- */
-export interface OptimizeOptions {
-  format?: ImageFormat;
-}
-
-
-type ImageType = Readable | Buffer | ReadableStream;
-
 /**
  * Simple support for image manipulation.
  */
 export class ImageUtil {
 
-  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);
-  }
-
   /**
-   * Resize image
+   * Convert 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);
-
+  static async convert<T extends Input>(image: T, { format, optimize, ...opts }: ConvertOptions): Promise<T extends string ? Readable : T> {
     const { default: sharp } = await import('sharp');
 
-    return this.#sharpReturn(
-      sharp().resize({
+    let builder = sharp();
+    if (opts.w || opts.h) {
+      const dims = [opts.w, opts.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'
-      }),
-      image,
-      options.optimize,
-      options.format
-    );
-  }
+      });
+    }
 
-  /**
-   * Optimize an image
-   */
-  static async optimize<T extends ImageType>(image: T, options: OptimizeOptions = {}): Promise<T> {
-    const { default: sharp } = await import('sharp');
-    return this.#sharpReturn(sharp(), image, true, options.format);
-  }
+    builder = builder
+      .avif({ force: format === 'avif', ...optimize ? { quality: 70 } : {} })
+      .webp({ force: format === 'webp', ...optimize ? { quality: 80 } : {} })
+      .png({ force: format === 'png', ...optimize ? { compressionLevel: 9, quality: 80, adaptiveFiltering: true } : {} })
+      .jpeg({ force: format === 'jpeg', ...optimize ? { quality: 80, progressive: true } : {} });
 
-  /**
-   * Get Image Dimensions
-   */
-  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! }));
+    const stream = Buffer.isBuffer(image) ?
+      Readable.from(image) :
+      (typeof image === 'string' ? createReadStream(image) : image);
+
+    pipeline(stream, builder);
+    return castTo(
+      typeof image === 'string' ?
+        builder : Buffer.isBuffer(image) ?
+          builder.toBuffer() :
+          (image instanceof ReadableStream) ?
+            ReadableStream.from(builder) : builder
+    );
   }
 
   /**
-   * Get image type
+   * Get Image metadata
    */
-  static async getFileType(image: Buffer | string): Promise<string> {
+  static async getMetadata(image: Input): Promise<{
+    width: number;
+    height: number;
+    aspect: number;
+    format: ImageFormat;
+  }> {
     const { default: sharp } = await import('sharp');
-    return sharp(image).metadata().then(v => v.format?.replace('heif', 'avif')!);
+    const out = await ((Buffer.isBuffer(image) || typeof image === 'string') ?
+      sharp(image).metadata() :
+      new Promise<Metadata>((resolve, reject) =>
+        pipeline(image, sharp().metadata((err, metadata) => err ? reject(err) : resolve(metadata)))
+      ));
+    return {
+      width: out.width!,
+      height: out.height!,
+      format: castTo(out.format?.replace('heif', 'avif')!),
+      aspect: out.width! / out.height!
+    };
   }
 }