@digitalascetic/ngx-pica/fesm2022/digitalascetic-ngx-pica.mjs

Angular (LTS) module to resize images files in browser

import * as i0 from '@angular/core';
import { Injectable, NgModule } from '@angular/core';
import { Subject } from 'rxjs';
import { switchMap } from 'rxjs/operators';
import imageCompression from 'browser-image-compression';

var NgxPicaErrorType;
(function (NgxPicaErrorType) {
    NgxPicaErrorType["NO_FILES_RECEIVED"] = "NO_FILES_RECEIVED";
    NgxPicaErrorType["READ_ERROR"] = "IMAGE_COULD_NOT_BE_LOADED";
    NgxPicaErrorType["NOT_BE_ABLE_TO_COMPRESS_ENOUGH"] = "NOT_BE_ABLE_TO_COMPRESS_ENOUGH";
})(NgxPicaErrorType || (NgxPicaErrorType = {}));

class NgxPicaService {
    MAX_STEPS = 20;
    resizeImages(files, width, height, useWebWorker) {
        const resizedImage = new Subject();
        const totalFiles = files.length;
        if (totalFiles > 0) {
            const nextFile = new Subject();
            let index = 0;
            const subscription = nextFile
                .pipe(switchMap((file) => this.resizeImage(file, width, height, useWebWorker)))
                .subscribe({
                next: imageResized => {
                    index++;
                    resizedImage.next(imageResized);
                    if (index < totalFiles) {
                        nextFile.next(files[index]);
                    }
                    else {
                        resizedImage.complete();
                        subscription.unsubscribe();
                    }
                },
                error: (err) => {
                    const ngxPicaError = {
                        file: files[index],
                        err: err
                    };
                    resizedImage.error(ngxPicaError);
                }
            });
            nextFile.next(files[index]);
        }
        else {
            const ngxPicaError = {
                err: NgxPicaErrorType.NO_FILES_RECEIVED
            };
            resizedImage.error(ngxPicaError);
            resizedImage.complete();
        }
        return resizedImage.asObservable();
    }
    resizeImage(file, width, height, useWebWorker = true) {
        const resizedImage = new Subject();
        const maxWidthOrHeight = width > height ? height : width;
        imageCompression.getExifOrientation(file)
            .then(orientation => {
            imageCompression(file, {
                maxWidthOrHeight: maxWidthOrHeight,
                exifOrientation: orientation,
                useWebWorker: useWebWorker,
                maxIteration: this.MAX_STEPS
            }).then(resizedFile => {
                resizedImage.next(resizedFile);
                resizedImage.complete();
            }).catch(err => resizedImage.error({ err: NgxPicaErrorType.READ_ERROR, file: file, original_error: err }));
        })
            .catch(err => {
            imageCompression(file, {
                maxWidthOrHeight: maxWidthOrHeight,
                maxIteration: this.MAX_STEPS
            }).then(resizedFile => {
                resizedImage.next(resizedFile);
                resizedImage.complete();
            }).catch(err => resizedImage.error({ err: NgxPicaErrorType.READ_ERROR, file: file, original_error: err }));
        });
        return resizedImage.asObservable();
    }
    compressImages(files, sizeInMB, useWebWorker) {
        const compressedImage = new Subject();
        const totalFiles = files.length;
        if (totalFiles > 0) {
            const nextFile = new Subject();
            let index = 0;
            const subscription = nextFile
                .pipe(switchMap((file) => this.compressImage(file, sizeInMB, useWebWorker)))
                .subscribe({
                next: imageCompressed => {
                    index++;
                    compressedImage.next(imageCompressed);
                    if (index < totalFiles) {
                        nextFile.next(files[index]);
                    }
                    else {
                        compressedImage.complete();
                        subscription.unsubscribe();
                    }
                },
                error: err => {
                    const ngxPicaError = {
                        file: files[index],
                        err: err
                    };
                    compressedImage.error(ngxPicaError);
                }
            });
            nextFile.next(files[index]);
        }
        else {
            const ngxPicaError = {
                err: NgxPicaErrorType.NO_FILES_RECEIVED
            };
            compressedImage.error(ngxPicaError);
            compressedImage.complete();
        }
        return compressedImage.asObservable();
    }
    compressImage(file, sizeInMB, useWebWorker = true) {
        const compressedImage = new Subject();
        if (this.bytesToMB(file.size) <= sizeInMB) {
            setTimeout(() => {
                compressedImage.next(file);
                compressedImage.complete();
            });
        }
        else {
            imageCompression.getExifOrientation(file)
                .then(orientation => {
                imageCompression(file, {
                    maxSizeMB: sizeInMB,
                    useWebWorker: useWebWorker,
                    exifOrientation: orientation,
                    alwaysKeepResolution: true,
                    maxIteration: this.MAX_STEPS
                })
                    .then(compressedFile => {
                    compressedImage.next(compressedFile);
                    compressedImage.complete();
                })
                    .catch(err => compressedImage.error({ err: NgxPicaErrorType.READ_ERROR, file: file, original_error: err }));
            })
                .catch(err => {
                imageCompression(file, {
                    maxSizeMB: sizeInMB,
                    alwaysKeepResolution: true,
                    maxIteration: this.MAX_STEPS
                })
                    .then(compressedFile => {
                    compressedImage.next(compressedFile);
                    compressedImage.complete();
                })
                    .catch(err2 => compressedImage.error({ err: NgxPicaErrorType.READ_ERROR, file: file, original_error: err2 }));
            });
        }
        return compressedImage.asObservable();
    }
    bytesToMB(bytes) {
        return bytes / 1048576;
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaService });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaService, decorators: [{
            type: Injectable
        }] });

class NgxPicaImageService {
    imageExtensions = [
        'ase',
        'art',
        'bmp',
        'blp',
        'cd5',
        'cit',
        'cpt',
        'cr2',
        'cut',
        'dds',
        'dib',
        'djvu',
        'egt',
        'exif',
        'gif',
        'gpl',
        'grf',
        'icns',
        'ico',
        'iff',
        'jng',
        'jpeg',
        'jpg',
        'jfif',
        'jp2',
        'jps',
        'lbm',
        'max',
        'miff',
        'mng',
        'msp',
        'nitf',
        'ota',
        'pbm',
        'pc1',
        'pc2',
        'pc3',
        'pcf',
        'pcx',
        'pdn',
        'pgm',
        'PI1',
        'PI2',
        'PI3',
        'pict',
        'pct',
        'pnm',
        'pns',
        'ppm',
        'psb',
        'psd',
        'pdd',
        'psp',
        'px',
        'pxm',
        'pxr',
        'qfx',
        'raw',
        'rle',
        'sct',
        'sgi',
        'rgb',
        'int',
        'bw',
        'tga',
        'tiff',
        'tif',
        'vtf',
        'xbm',
        'xcf',
        'xpm',
        '3dv',
        'amf',
        'ai',
        'awg',
        'cgm',
        'cdr',
        'cmx',
        'dxf',
        'e2d',
        'egt',
        'eps',
        'fs',
        'gbr',
        'odg',
        'svg',
        'stl',
        'vrml',
        'x3d',
        'sxd',
        'v2d',
        'vnd',
        'wmf',
        'emf',
        'art',
        'xar',
        'png',
        'webp',
        'jxr',
        'hdp',
        'wdp',
        'cur',
        'ecw',
        'iff',
        'lbm',
        'liff',
        'nrrd',
        'pam',
        'pcx',
        'pgf',
        'sgi',
        'rgb',
        'rgba',
        'bw',
        'int',
        'inta',
        'sid',
        'ras',
        'sun',
        'tga'
    ];
    isImage(file) {
        const fileExtension = file.name.toLowerCase().substring(file.name.lastIndexOf('.') + 1);
        return (this.imageExtensions.indexOf(fileExtension) !== -1);
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaImageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaImageService });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaImageService, decorators: [{
            type: Injectable
        }] });

class NgxPicaModule {
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaModule });
    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaModule, providers: [
            { provide: NgxPicaService, useClass: NgxPicaService },
            { provide: NgxPicaImageService, useClass: NgxPicaImageService },
        ] });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NgxPicaModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        { provide: NgxPicaService, useClass: NgxPicaService },
                        { provide: NgxPicaImageService, useClass: NgxPicaImageService },
                    ]
                }]
        }] });

/*
 * Public API Surface of ngx-pica
 */

/**
 * Generated bundle index. Do not edit.
 */

export { NgxPicaErrorType, NgxPicaImageService, NgxPicaModule, NgxPicaService };
//# sourceMappingURL=digitalascetic-ngx-pica.mjs.map