smartjimp/ts/smartjimp.classes.smartjimp.ts

import * as plugins from './plugins.js';
import * as pluginsTyped from './plugins.typed.js';

export interface IAssetVariation {
  format?: 'avif' | 'webp' | 'png' | 'jpeg';
  width?: number;
  height?: number;
  invert?: boolean;
  progressive?: boolean;
  quality?: number;
}

export interface ISmartJimpOptions {
  mode: 'sharp' | 'jimp';
}

export class SmartJimp {
  public levelCache = new plugins.levelcache.LevelCache({
    cacheId: 'mastercache',
    maxMemoryStorageInMB: 100,
    maxDiskStorageInMB: 5000,
  });

  public options: ISmartJimpOptions;
  constructor(optionsArg: ISmartJimpOptions) {
    this.options = optionsArg;
  }

  /**
   * get a key that is unique for a wanted asset variation
   */
  private getCacheKey(
    sourceTypeArg: 'streamfile' | 'smartfile',
    sourceIdArg: string,
    assetVariationArg?: IAssetVariation
  ) {
    return `${sourceTypeArg}_${sourceIdArg}_${
      assetVariationArg
        ? `${assetVariationArg.width || 'auto'}x${assetVariationArg.height || 'auto'}`
        : 'original'
    }`;
  }

  sharpMod: typeof pluginsTyped.sharpType.default;
  public async getSharpMod(): Promise<
    typeof pluginsTyped.sharpType.default
  > {
    if (!this.sharpMod) {
      this.sharpMod = (await import('sharp')).default;
    }
    return this.sharpMod;
  }

  jimpMod: typeof pluginsTyped.jimpType;
  public async getJimpMod(): Promise<typeof pluginsTyped.jimpType> {
    if (!this.jimpMod) {
      this.jimpMod = await import('jimp');
    }
    return this.jimpMod;
  }

  public async computeAssetVariation(assetBufferArg: Buffer, assetVariationArg: IAssetVariation) {
    if (this.options.mode === 'sharp') {
      const sharp = await this.getSharpMod();
      if (!assetVariationArg) {
        return assetBufferArg;
      }
      let sharpImage = sharp(assetBufferArg);
      sharpImage = sharpImage.resize(assetVariationArg.width, assetVariationArg.height);
      const resultResize = sharpImage.resize(assetVariationArg.width, assetVariationArg.height);
      if (assetVariationArg.invert) {
        // TODO: implement invert
      }
      switch (assetVariationArg.format) {
        case 'avif':
          const avifOptions: any = {};
          if (assetVariationArg.quality !== undefined) {
            avifOptions.quality = assetVariationArg.quality;
          }
          sharpImage = resultResize.avif(avifOptions);
          break;
        case 'webp':
          const webpOptions: any = {};
          if (assetVariationArg.quality !== undefined) {
            webpOptions.quality = assetVariationArg.quality;
          }
          sharpImage = resultResize.webp(webpOptions);
          break;
        case 'png':
          const pngOptions: any = {};
          if (assetVariationArg.quality !== undefined) {
            pngOptions.quality = assetVariationArg.quality;
          }
          sharpImage = resultResize.png(pngOptions);
          break;
        case 'jpeg':
          const jpegOptions: any = { 
            progressive: assetVariationArg.progressive || false 
          };
          if (assetVariationArg.quality !== undefined) {
            jpegOptions.quality = assetVariationArg.quality;
          }
          sharpImage = resultResize.jpeg(jpegOptions);
          break;
        default:
          // Default to JPEG
          const defaultJpegOptions: any = { 
            progressive: assetVariationArg.progressive || false 
          };
          if (assetVariationArg.quality !== undefined) {
            defaultJpegOptions.quality = assetVariationArg.quality;
          }
          sharpImage = resultResize.jpeg(defaultJpegOptions);
      }
      return sharpImage.toBuffer();
    } else if (this.options.mode === 'jimp') {
      const jimpMod = await this.getJimpMod();
      let jimpImage = await jimpMod.Jimp.read(assetBufferArg);
      if (assetVariationArg.width || assetVariationArg.height) {
        const resizeOptions: any = {};
        if (assetVariationArg.width) resizeOptions.w = assetVariationArg.width;
        if (assetVariationArg.height) resizeOptions.h = assetVariationArg.height;
        jimpImage.resize(resizeOptions);
      }
      if (assetVariationArg.invert) {
         jimpImage.invert();
      }
      // Note: Jimp does not support progressive JPEG encoding
      // Progressive option is ignored in jimp mode
      const jpegOptions: any = {};
      if (assetVariationArg.quality !== undefined) {
        jpegOptions.quality = assetVariationArg.quality;
      }
      
      switch (assetVariationArg.format) {
        case 'png':
          return await jimpImage.getBuffer("image/png");
        case 'webp':
        case 'avif':
          console.log(`Jimp doesn't support ${assetVariationArg.format}, falling back to JPEG`);
          // Fall through to JPEG
        case 'jpeg':
        default:
          // Default to JPEG
          return await jimpImage.getBuffer("image/jpeg", jpegOptions);
      }
    }
  }

  public async getFromSmartfile(
    smartfileArg: plugins.smartfile.SmartFile,
    wantedDimensionsArg?: IAssetVariation
  ) {
    const cacheKey = this.getCacheKey(
      'smartfile',
      await smartfileArg.getHash(),
      wantedDimensionsArg
    );
    const existingCacheEntry = await this.levelCache.retrieveCacheEntryByKey(cacheKey);
    if (existingCacheEntry) {
      return existingCacheEntry.contents;
    } else {
      const computedAssetBuffer = await this.computeAssetVariation(
        smartfileArg.contentBuffer,
        wantedDimensionsArg
      );
      this.levelCache.storeCacheEntryByKey(
        cacheKey,
        new plugins.levelcache.CacheEntry({
          contents: computedAssetBuffer,
          ttl: 600000,
        })
      );
      return computedAssetBuffer;
    }
  }

  public async createAvifImageFromBuffer(bufferArg: Buffer) {
    const sharp = await this.getSharpMod();
    const sharpImage = sharp(bufferArg);
    const result = await sharpImage.avif().toBuffer();
    return result;
  }
}