@flusys/nestjs-storage 7.1.0 → 8.0.0

package/fesm/utils/image-compressor.util.js

@@ -1,114 +0,0 @@
-import * as sharpModule from 'sharp';
-// Handle ESM/CJS interop - sharp exports differently in each module system
-const sharp = sharpModule.default || sharpModule;
-/**
- * Image Compression Utility
- * Handles image compression and format conversion using sharp
- */ export class ImageCompressor {
-    /**
-   * Dynamically compresses an image based on its format and provided options.
-   * - Preserves original format if not overridden
-   * - Adjusts compression settings for each codec
-   */ static async compress(buffer, mimetype, options = {}) {
-        const { maxWidth = 1280, maxHeight = 1280, quality = 85, format = 'original' } = options;
-        // Skip processing for SVG
-        if (mimetype === 'image/svg+xml') {
-            return {
-                buffer,
-                format: mimetype
-            };
-        }
-        // Initialize sharp with improved error handling
-        const image = sharp(buffer, {
-            failOnError: false,
-            density: 300
-        });
-        // Apply initial resize
-        image.resize({
-            width: maxWidth,
-            height: maxHeight,
-            fit: 'inside',
-            withoutEnlargement: true
-        });
-        // Determine target format
-        let targetFormat = format !== 'original' ? format : mimetype.split('/')[1];
-        // Format-specific optimizations
-        switch(targetFormat.toLowerCase()){
-            case 'jpeg':
-            case 'jpg':
-                image.jpeg({
-                    quality,
-                    mozjpeg: true,
-                    chromaSubsampling: '4:4:4'
-                });
-                break;
-            case 'png':
-                image.png({
-                    compressionLevel: 9,
-                    adaptiveFiltering: true,
-                    palette: true,
-                    quality,
-                    colors: 256,
-                    dither: 1.0
-                });
-                break;
-            case 'webp':
-                image.webp({
-                    quality,
-                    smartSubsample: true,
-                    effort: 6,
-                    lossless: quality === 100
-                });
-                break;
-            case 'avif':
-                image.avif({
-                    quality,
-                    effort: 6,
-                    chromaSubsampling: '4:4:4'
-                });
-                break;
-            case 'tiff':
-                image.tiff({
-                    quality,
-                    compression: 'lzw',
-                    predictor: 'horizontal',
-                    pyramid: true
-                });
-                break;
-            case 'gif':
-                image.gif({
-                    colours: 256,
-                    effort: 10,
-                    dither: 1
-                });
-                break;
-            case 'jp2':
-                image.jp2({
-                    quality,
-                    lossless: quality === 100
-                });
-                break;
-            default:
-                // Fallback to WebP for best compression/quality ratio
-                targetFormat = 'webp';
-                image.webp({
-                    quality,
-                    smartSubsample: true,
-                    effort: 6
-                });
-                break;
-        }
-        try {
-            const compressedBuffer = await image.toBuffer();
-            return {
-                buffer: compressedBuffer,
-                format: `image/${targetFormat}`
-            };
-        } catch  {
-            return {
-                buffer,
-                format: mimetype
-            };
-        }
-    }
-}

package/fesm/utils/image-compressor.util.spec.js

@@ -1,162 +0,0 @@
-const mockToBuffer = jest.fn();
-const mockJpeg = jest.fn();
-const mockPng = jest.fn();
-const mockWebp = jest.fn();
-const mockAvif = jest.fn();
-const mockTiff = jest.fn();
-const mockGif = jest.fn();
-const mockJp2 = jest.fn();
-const mockResize = jest.fn();
-function buildChainableImage() {
-    const image = {};
-    image.resize = mockResize.mockReturnValue(image);
-    image.jpeg = mockJpeg.mockReturnValue(image);
-    image.png = mockPng.mockReturnValue(image);
-    image.webp = mockWebp.mockReturnValue(image);
-    image.avif = mockAvif.mockReturnValue(image);
-    image.tiff = mockTiff.mockReturnValue(image);
-    image.gif = mockGif.mockReturnValue(image);
-    image.jp2 = mockJp2.mockReturnValue(image);
-    image.toBuffer = mockToBuffer;
-    return image;
-}
-const mockSharpFactory = jest.fn();
-jest.mock('sharp', ()=>{
-    const factory = (...args)=>mockSharpFactory(...args);
-    return {
-        __esModule: true,
-        default: factory
-    };
-});
-import { ImageCompressor } from './image-compressor.util';
-describe('ImageCompressor', ()=>{
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        mockSharpFactory.mockImplementation(()=>buildChainableImage());
-        mockToBuffer.mockResolvedValue(Buffer.from('compressed-image-data'));
-    });
-    it('returns the buffer unchanged for image/svg+xml without invoking sharp', async ()=>{
-        const buffer = Buffer.from('<svg></svg>');
-        const result = await ImageCompressor.compress(buffer, 'image/svg+xml');
-        expect(result.buffer).toBe(buffer);
-        expect(result.format).toBe('image/svg+xml');
-        expect(mockSharpFactory).not.toHaveBeenCalled();
-    });
-    it('resizes using default maxWidth/maxHeight when no options are provided', async ()=>{
-        await ImageCompressor.compress(Buffer.from('jpeg-bytes'), 'image/jpeg');
-        expect(mockResize).toHaveBeenCalledWith(expect.objectContaining({
-            width: 1280,
-            height: 1280,
-            fit: 'inside',
-            withoutEnlargement: true
-        }));
-    });
-    it('resizes using custom maxWidth/maxHeight when provided', async ()=>{
-        await ImageCompressor.compress(Buffer.from('jpeg-bytes'), 'image/jpeg', {
-            maxWidth: 500,
-            maxHeight: 600
-        });
-        expect(mockResize).toHaveBeenCalledWith(expect.objectContaining({
-            width: 500,
-            height: 600
-        }));
-    });
-    it('preserves the original format (derived from mimetype) when format is "original"', async ()=>{
-        const result = await ImageCompressor.compress(Buffer.from('png-bytes'), 'image/png', {
-            format: 'original'
-        });
-        expect(mockPng).toHaveBeenCalled();
-        expect(result.format).toBe('image/png');
-    });
-    it('applies jpeg-specific compression options with quality', async ()=>{
-        await ImageCompressor.compress(Buffer.from('bytes'), 'image/jpeg', {
-            quality: 70
-        });
-        expect(mockJpeg).toHaveBeenCalledWith(expect.objectContaining({
-            quality: 70,
-            mozjpeg: true
-        }));
-    });
-    it('applies png-specific compression options', async ()=>{
-        await ImageCompressor.compress(Buffer.from('bytes'), 'image/png', {
-            quality: 90
-        });
-        expect(mockPng).toHaveBeenCalledWith(expect.objectContaining({
-            quality: 90,
-            colors: 256
-        }));
-    });
-    it('applies webp-specific options and sets lossless=true only when quality is 100', async ()=>{
-        await ImageCompressor.compress(Buffer.from('bytes'), 'image/webp', {
-            quality: 100,
-            format: 'webp'
-        });
-        expect(mockWebp).toHaveBeenCalledWith(expect.objectContaining({
-            quality: 100,
-            lossless: true
-        }));
-    });
-    it('applies webp-specific options with lossless=false for quality < 100', async ()=>{
-        await ImageCompressor.compress(Buffer.from('bytes'), 'image/webp', {
-            quality: 80,
-            format: 'webp'
-        });
-        expect(mockWebp).toHaveBeenCalledWith(expect.objectContaining({
-            quality: 80,
-            lossless: false
-        }));
-    });
-    it('applies avif-specific compression options', async ()=>{
-        await ImageCompressor.compress(Buffer.from('bytes'), 'image/avif', {
-            format: 'avif'
-        });
-        expect(mockAvif).toHaveBeenCalled();
-    });
-    it('applies tiff-specific compression options', async ()=>{
-        await ImageCompressor.compress(Buffer.from('bytes'), 'image/tiff', {
-            format: 'tiff'
-        });
-        expect(mockTiff).toHaveBeenCalled();
-    });
-    it('applies gif-specific compression options', async ()=>{
-        await ImageCompressor.compress(Buffer.from('bytes'), 'image/gif', {
-            format: 'gif'
-        });
-        expect(mockGif).toHaveBeenCalled();
-    });
-    it('applies jp2-specific compression options', async ()=>{
-        await ImageCompressor.compress(Buffer.from('bytes'), 'image/jp2', {
-            format: 'jp2'
-        });
-        expect(mockJp2).toHaveBeenCalled();
-    });
-    it('falls back to webp for an unrecognized target format', async ()=>{
-        const result = await ImageCompressor.compress(Buffer.from('bytes'), 'image/unknownformat', {
-            format: 'original'
-        });
-        expect(mockWebp).toHaveBeenCalled();
-        expect(result.format).toBe('image/webp');
-    });
-    it('returns the compressed buffer and content-type prefixed format on success', async ()=>{
-        mockToBuffer.mockResolvedValue(Buffer.from('final-bytes'));
-        const result = await ImageCompressor.compress(Buffer.from('bytes'), 'image/jpeg', {
-            format: 'jpeg'
-        });
-        expect(result.buffer).toEqual(Buffer.from('final-bytes'));
-        expect(result.format).toBe('image/jpeg');
-    });
-    it('falls back to the original buffer and mimetype when sharp processing throws', async ()=>{
-        const originalBuffer = Buffer.from('original-bytes');
-        mockToBuffer.mockRejectedValue(new Error('corrupt image'));
-        const result = await ImageCompressor.compress(originalBuffer, 'image/png');
-        expect(result.buffer).toBe(originalBuffer);
-        expect(result.format).toBe('image/png');
-    });
-    it('initializes sharp with failOnError=false and a density hint', async ()=>{
-        await ImageCompressor.compress(Buffer.from('bytes'), 'image/jpeg');
-        expect(mockSharpFactory).toHaveBeenCalledWith(expect.any(Buffer), expect.objectContaining({
-            failOnError: false,
-            density: 300
-        }));
-    });
-});