@sumaris-net/ngx-components 2.6.4-alpha5 → 2.6.4-alpha6

package/esm2020/src/app/shared/image/gallery/testing/gallery.service.testing.mjs

@@ -0,0 +1,90 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { BehaviorSubject } from 'rxjs';
+import { StartableService } from '../../../services/startable-service.class';
+import { isNil, isNotNil, removeDuplicatesFromArray } from '../../../functions';
+import { Entity, EntityUtils } from '../../../../core/services/model/entity.model';
+import { EntityClass } from '../../../../core/services/model/entity.decorators';
+import { EntityFilter } from '../../../../core/services/model/filter.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+// @dynamic
+let ImageAttachment = class ImageAttachment extends Entity {
+    constructor() {
+        super(...arguments);
+        this.dataUrl = null;
+        this.url = null;
+        this.title = null;
+    }
+    fromObject(source, opts) {
+        super.fromObject(source, opts);
+        this.url = source.url;
+        this.dataUrl = source.dataUrl;
+        this.title = source.title;
+    }
+};
+ImageAttachment = __decorate([
+    EntityClass({ typename: 'ImageAttachmentVO' })
+], ImageAttachment);
+export { ImageAttachment };
+// @dynamic
+let ImageAttachmentFilter = class ImageAttachmentFilter extends EntityFilter {
+};
+ImageAttachmentFilter = __decorate([
+    EntityClass({ typename: 'ImageAttachmentFilterVO' })
+], ImageAttachmentFilter);
+export { ImageAttachmentFilter };
+export class ImageAttachmentService extends StartableService {
+    constructor(platform) {
+        super(platform);
+        this.platform = platform;
+        this.$images = new BehaviorSubject([
+            ImageAttachment.fromObject({ id: 0, url: 'https://test.sumaris.net/assets/img/bg/ray-1.jpg', title: 'ray #1' }),
+            ImageAttachment.fromObject({ id: 1, url: 'https://test.sumaris.net/assets/img/bg/ray-2.jpg', title: 'ray #2' })
+        ]);
+        console.debug('[gallery-testing-service] Create service');
+    }
+    ngOnStart() {
+        return Promise.resolve(undefined);
+    }
+    watchAll(offset, size, sortBy, sortDirection, filter, opts) {
+        console.debug('[gallery-testing-service] Watching images...');
+        return this.$images
+            .pipe(map(images => {
+            let data = (images || []).map(ImageAttachment.fromObject);
+            data = EntityUtils.sort(data, sortBy, sortDirection);
+            console.debug(`[gallery-testing-service] Loaded ${data.length} images...`);
+            return { data, total: data.length };
+        }));
+    }
+    async saveAll(entities, opts) {
+        console.debug('[gallery-service-testing] Saving images...' + JSON.stringify(entities));
+        if (!entities)
+            return [];
+        const existingImages = this.$images.value;
+        let currentId = existingImages.reduce((res, image) => Math.max(res, +image?.id || 0), 0);
+        entities.filter(item => isNil(item.id))
+            .forEach(item => {
+            item.id = ++currentId;
+        });
+        this.$images.next(removeDuplicatesFromArray([
+            ...existingImages,
+            ...entities
+        ], 'id'));
+    }
+    async deleteAll(entities, opts) {
+        const deletedIds = (entities || []).map(item => item.id).filter(isNotNil);
+        const filteredData = (this.$images.value).filter(item => !deletedIds.includes(item.id));
+        this.$images.next(filteredData);
+    }
+    asFilter(filter) {
+        return ImageAttachmentFilter.fromObject(filter);
+    }
+}
+ImageAttachmentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageAttachmentService, deps: [{ token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
+ImageAttachmentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageAttachmentService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageAttachmentService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Platform }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gallery.service.testing.js","sourceRoot":"","sources":["../../../../../../../../src/app/shared/image/gallery/testing/gallery.service.testing.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\n\nimport {SortDirection} from '@angular/material/sort';\nimport {map} from 'rxjs/operators';\nimport {BehaviorSubject, Observable} from 'rxjs';\nimport {StartableService} from '../../../services/startable-service.class';\nimport {EntitiesServiceWatchOptions, IEntitiesService, LoadResult} from '../../../services/entity-service.class';\nimport {Platform} from '@ionic/angular';\nimport {isNil, isNotNil, removeDuplicatesFromArray} from '../../../functions';\nimport {Entity, EntityUtils} from '../../../../core/services/model/entity.model';\nimport {EntityClass} from '../../../../core/services/model/entity.decorators';\nimport {Image} from '../../image.model';\nimport {EntityFilter} from '../../../../core/services/model/filter.model';\n\n\n// @dynamic\n@EntityClass({ typename: 'ImageAttachmentVO' })\nexport class ImageAttachment extends Entity<ImageAttachment> implements Image {\n\n  static fromObject: (source: any, opts?: any) => ImageAttachment;\n\n  dataUrl: string = null;\n  url: string = null;\n  title: string = null;\n\n  fromObject(source: any, opts?: any) {\n    super.fromObject(source, opts);\n    this.url = source.url;\n    this.dataUrl = source.dataUrl;\n    this.title = source.title;\n  }\n}\n\n// @dynamic\n@EntityClass({ typename: 'ImageAttachmentFilterVO' })\nexport class ImageAttachmentFilter extends EntityFilter<ImageAttachmentFilter, ImageAttachment> {\n\n  static fromObject: (source: any, opts?: any) => ImageAttachmentFilter;\n\n}\n\n@Injectable()\nexport class ImageAttachmentService extends StartableService\n  implements IEntitiesService<ImageAttachment, ImageAttachmentFilter> {\n\n  $images = new BehaviorSubject<Partial<ImageAttachment>[]>([\n    ImageAttachment.fromObject({id: 0, url: 'https://test.sumaris.net/assets/img/bg/ray-1.jpg', title: 'ray #1'}),\n    ImageAttachment.fromObject({id: 1, url: 'https://test.sumaris.net/assets/img/bg/ray-2.jpg', title: 'ray #2'})\n  ]);\n\n  constructor(protected platform: Platform\n  ) {\n    super(platform);\n    console.debug('[gallery-testing-service] Create service');\n  }\n\n  protected ngOnStart(): Promise<any> {\n    return Promise.resolve(undefined);\n  }\n\n  watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: ImageAttachmentFilter, opts?: EntitiesServiceWatchOptions & { query?: any }): Observable<LoadResult<ImageAttachment>> {\n    console.debug('[gallery-testing-service] Watching images...');\n    return this.$images\n      .pipe(\n        map(images => {\n          let data = (images || []).map(ImageAttachment.fromObject);\n\n          data = EntityUtils.sort(data, sortBy, sortDirection);\n\n          console.debug(`[gallery-testing-service] Loaded ${data.length} images...`);\n\n          return {data, total: data.length};\n        })\n      );\n  }\n\n  async saveAll(entities: ImageAttachment[], opts?: any): Promise<any[]> {\n    console.debug('[gallery-service-testing] Saving images...' + JSON.stringify(entities));\n    if (!entities) return [];\n\n    const existingImages = this.$images.value;\n    let currentId = existingImages.reduce((res, image) => Math.max(res, +image?.id || 0), 0);\n    entities.filter(item => isNil(item.id))\n      .forEach(item => {\n        item.id = ++currentId;\n    });\n    this.$images.next(removeDuplicatesFromArray([\n      ...existingImages,\n      ...entities\n    ], 'id'));\n  }\n\n  async deleteAll(entities: ImageAttachment[], opts?: any): Promise<any> {\n    const deletedIds = (entities||[]).map(item => item.id).filter(isNotNil);\n    const filteredData = (this.$images.value).filter(item => !deletedIds.includes(item.id));\n    this.$images.next(filteredData);\n  }\n\n  asFilter(filter: any) {\n    return ImageAttachmentFilter.fromObject(filter);\n  }\n}\n"]}

package/esm2020/src/app/shared/image/gallery/testing/gallery.testing.mjs

@@ -0,0 +1,39 @@
+import { Component } from '@angular/core';
+import { ImageAttachment, ImageAttachmentService, } from './gallery.service.testing';
+import { EntitiesTableDataSource } from '../../../../core/table/entities-table-datasource.class';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./gallery.service.testing";
+import * as i2 from "@ionic/angular";
+import * as i3 from "../image-gallery.component";
+export class GalleryTestPage {
+    constructor(dataService) {
+        this.dataService = dataService;
+        this._subscription = new Subscription();
+        this.dataSource = new EntitiesTableDataSource(ImageAttachment, this.dataService, null, {
+            saveBeforeDelete: true,
+            saveOnlyDirtyRows: false
+        });
+    }
+    ngOnInit() {
+        this._subscription.add(this.dataSource.watchAll(0, 100, null, null, null)
+            .subscribe());
+    }
+    ngOnDestroy() {
+        this._subscription.unsubscribe();
+    }
+    save() {
+        this.dataSource.save();
+    }
+}
+GalleryTestPage.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: GalleryTestPage, deps: [{ token: i1.ImageAttachmentService }], target: i0.ɵɵFactoryTarget.Component });
+GalleryTestPage.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: GalleryTestPage, selector: "app-gallery-test-page", providers: [
+        { provide: ImageAttachmentService, useClass: ImageAttachmentService }
+    ], ngImport: i0, template: "<ion-header>\n  <ion-toolbar color=\"primary\">\n\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Image gallery</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content>\n  <app-image-gallery [dataSource]=\"dataSource\" (onAfterAddRows)=\"save()\">\n  </app-image-gallery>\n</ion-content>\n", dependencies: [{ kind: "component", type: i2.IonBackButton, selector: "ion-back-button", inputs: ["color", "defaultHref", "disabled", "icon", "mode", "routerAnimation", "text", "type"] }, { kind: "component", type: i2.IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: i2.IonContent, selector: "ion-content", inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i2.IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: i2.IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: i2.IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "directive", type: i2.IonBackButtonDelegate, selector: "ion-back-button", inputs: ["defaultHref", "routerAnimation"] }, { kind: "component", type: i3.AppImageGalleryComponent, selector: "app-image-gallery", inputs: ["cardColor", "debug", "disabled", "readOnly", "mobile", "mode", "confirmBeforeDelete", "showToolbar", "showFabButton", "showTitle", "showAddCardButton", "addButtonColor", "dataSource"], outputs: ["onBeforeDeleteRows", "onAfterAddRows"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: GalleryTestPage, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-gallery-test-page', providers: [
+                        { provide: ImageAttachmentService, useClass: ImageAttachmentService }
+                    ], template: "<ion-header>\n  <ion-toolbar color=\"primary\">\n\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Image gallery</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content>\n  <app-image-gallery [dataSource]=\"dataSource\" (onAfterAddRows)=\"save()\">\n  </app-image-gallery>\n</ion-content>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ImageAttachmentService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/shared/image/gallery/testing/gallery.testing.module.mjs

@@ -0,0 +1,56 @@
+import { NgModule } from '@angular/core';
+import { TranslateModule } from '@ngx-translate/core';
+import { RouterModule } from '@angular/router';
+import { GalleryTestPage } from './gallery.testing';
+import { CommonModule } from '@angular/common';
+import { IonicModule } from '@ionic/angular';
+import { ImageGalleryModule } from '../image-gallery.module';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@angular/router";
+const routes = [
+    {
+        path: 'gallery',
+        pathMatch: 'full',
+        component: GalleryTestPage
+    },
+];
+export class ImageGalleryTestingModule {
+}
+ImageGalleryTestingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageGalleryTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ImageGalleryTestingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: ImageGalleryTestingModule, declarations: [
+        // Components
+        GalleryTestPage], imports: [CommonModule,
+        IonicModule,
+        ImageGalleryModule, i1.TranslateModule, i2.RouterModule, i1.TranslateModule], exports: [RouterModule,
+        // Components
+        GalleryTestPage] });
+ImageGalleryTestingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageGalleryTestingModule, imports: [CommonModule,
+        IonicModule,
+        ImageGalleryModule,
+        TranslateModule.forChild(),
+        RouterModule.forChild(routes),
+        TranslateModule.forChild(), RouterModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageGalleryTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        IonicModule,
+                        ImageGalleryModule,
+                        TranslateModule.forChild(),
+                        RouterModule.forChild(routes),
+                        TranslateModule.forChild(),
+                    ],
+                    declarations: [
+                        // Components
+                        GalleryTestPage
+                    ],
+                    exports: [
+                        RouterModule,
+                        // Components
+                        GalleryTestPage
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/shared/image/image.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL3NoYXJlZC9pbWFnZS9pbWFnZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBJbWFnZSB7XG4gIGRhdGFVcmw6IHN0cmluZztcbiAgdXJsOiBzdHJpbmc7XG4gIHRpdGxlPzogc3RyaW5nO1xufVxuXG4iXX0=

package/esm2020/src/app/shared/image/image.module.mjs

@@ -0,0 +1,29 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ImageGalleryModule } from './gallery/image-gallery.module';
+import * as i0 from "@angular/core";
+export class ImageModule {
+}
+ImageModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ImageModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: ImageModule, imports: [CommonModule,
+        ImageGalleryModule], exports: [
+        // Sub module
+        ImageGalleryModule] });
+ImageModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageModule, imports: [CommonModule,
+        ImageGalleryModule, 
+        // Sub module
+        ImageGalleryModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        ImageGalleryModule
+                    ],
+                    exports: [
+                        // Sub module
+                        ImageGalleryModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9zaGFyZWQvaW1hZ2UvaW1hZ2UubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBQyxrQkFBa0IsRUFBQyxNQUFNLGdDQUFnQyxDQUFDOztBQVlsRSxNQUFNLE9BQU8sV0FBVzs7d0dBQVgsV0FBVzt5R0FBWCxXQUFXLFlBUnBCLFlBQVk7UUFDWixrQkFBa0I7UUFHbEIsYUFBYTtRQUNiLGtCQUFrQjt5R0FHVCxXQUFXLFlBUnBCLFlBQVk7UUFDWixrQkFBa0I7UUFHbEIsYUFBYTtRQUNiLGtCQUFrQjsyRkFHVCxXQUFXO2tCQVZ2QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3dCQUNaLGtCQUFrQjtxQkFDbkI7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLGFBQWE7d0JBQ2Isa0JBQWtCO3FCQUNuQjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQge0ltYWdlR2FsbGVyeU1vZHVsZX0gZnJvbSAnLi9nYWxsZXJ5L2ltYWdlLWdhbGxlcnkubW9kdWxlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZSxcbiAgICBJbWFnZUdhbGxlcnlNb2R1bGVcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIC8vIFN1YiBtb2R1bGVcbiAgICBJbWFnZUdhbGxlcnlNb2R1bGVcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBJbWFnZU1vZHVsZSB7XG59XG4iXX0=

package/esm2020/src/app/shared/image/image.service.mjs

@@ -0,0 +1,98 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { StartableService } from '../services/startable-service.class';
+import { ENVIRONMENT } from '../../../environments/environment.class';
+import { FilesUtils } from '../file/file.utils';
+import { ImagesUtils } from '../file/images.utils';
+import { isEmptyArray } from '../functions';
+import { Capacitor } from '@capacitor/core';
+import { Camera, CameraResultType } from '@capacitor/camera';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/services/platform.service";
+import * as i2 from "../../core/services/local-settings.service";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "@ionic/angular";
+import * as i5 from "../../../environments/environment.class";
+export class ImageService extends StartableService {
+    constructor(platform, settings, translate, popoverController, 
+    //              protected camera: Camera,
+    actionSheetController, environment) {
+        super(platform);
+        this.platform = platform;
+        this.settings = settings;
+        this.translate = translate;
+        this.popoverController = popoverController;
+        this.actionSheetController = actionSheetController;
+        this.environment = environment;
+        this.defaultMaxHeight = 1024;
+        this.defaultMaxWidth = 1024;
+        this._debug = !environment.production;
+        if (this._debug)
+            console.debug(`[image] Creating service`);
+    }
+    async ngOnStart() {
+        try {
+            const camera = Capacitor.isPluginAvailable('Camera');
+            console.info(`[image] Starting... {camera: ${camera}}`);
+        }
+        catch (err) {
+            console.error('Cannot check Camera plugin: ' + (err?.message || err));
+        }
+    }
+    async add(event, opts) {
+        if (!this.started)
+            await this.ready();
+        // If desktop: open upload popover
+        if (!this.platform.isCordova()) {
+            return this.addUploadedImages(event, opts);
+        }
+        console.info(`[image-service] Adding image...`);
+        try {
+            const data = await Camera.getPhoto({
+                height: this.defaultMaxHeight,
+                width: this.defaultMaxWidth,
+                promptLabelCancel: this.translate.instant('COMMON.BTN_CANCEL'),
+                promptLabelPicture: this.translate.instant('IMAGE.BTN_CAMERA_SOURCE'),
+                resultType: CameraResultType.DataUrl,
+                ...opts
+            });
+            if (!data)
+                return undefined;
+            return [{
+                    dataUrl: data.dataUrl
+                }];
+        }
+        catch (err) {
+            console.info(`[image-service] Error while adding image: ${err?.message || err} -> ${err?.originalStack || ''}`);
+            return undefined;
+        }
+    }
+    async addUploadedImages(event, opts) {
+        const { data } = await FilesUtils.showUploadPopover(this.popoverController, event, {
+            uniqueFile: true,
+            fileExtension: '.png, .jpg',
+            instantUpload: true,
+            uploadFn: (file) => ImagesUtils.readAsDataURL(file, {
+                maxWidth: this.defaultMaxWidth,
+                maxHeight: this.defaultMaxHeight,
+                ...opts
+            })
+        });
+        if (isEmptyArray(data))
+            return; // No files uploaded: skip
+        return (data || [])
+            .map(file => file.response.body) // Get response body = data as base64
+            .map(dataUrl => ({ dataUrl }));
+    }
+}
+ImageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageService, deps: [{ token: i1.PlatformService }, { token: i2.LocalSettingsService }, { token: i3.TranslateService }, { token: i4.PopoverController }, { token: i4.ActionSheetController }, { token: ENVIRONMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ImageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.PlatformService }, { type: i2.LocalSettingsService }, { type: i3.TranslateService }, { type: i4.PopoverController }, { type: i4.ActionSheetController }, { type: i5.Environment, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }, {
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image.service.js","sourceRoot":"","sources":["../../../../../../src/app/shared/image/image.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { ActionSheetController, PopoverController } from '@ionic/angular';\n\nimport { TranslateService } from '@ngx-translate/core';\nimport { StartableService } from '../services/startable-service.class';\nimport { ENVIRONMENT, Environment } from '../../../environments/environment.class';\nimport { PlatformService } from '../../core/services/platform.service';\nimport { LocalSettingsService } from '../../core/services/local-settings.service';\nimport { FilesUtils } from '../file/file.utils';\nimport { ImagesUtils } from '../file/images.utils';\nimport { isEmptyArray } from '../functions';\n\nimport { Image } from './image.model';\nimport { Capacitor } from '@capacitor/core';\nimport { Camera, CameraResultType } from '@capacitor/camera';\n\n\n@Injectable({providedIn: 'root'})\nexport class ImageService extends StartableService {\n\n  private defaultMaxHeight = 1024;\n  private defaultMaxWidth = 1024;\n\n  constructor(protected platform: PlatformService,\n              protected settings: LocalSettingsService,\n              protected translate: TranslateService,\n              protected popoverController: PopoverController,\n//              protected camera: Camera,\n              protected actionSheetController: ActionSheetController,\n              @Inject(ENVIRONMENT) @Optional() protected environment?: Environment\n  ) {\n    super(platform);\n    this._debug = !environment.production;\n    if (this._debug) console.debug(`[image] Creating service`);\n  }\n\n  protected async ngOnStart(): Promise<any> {\n    try {\n      const camera = Capacitor.isPluginAvailable('Camera');\n      console.info(`[image] Starting... {camera: ${camera}}`);\n    } catch(err) {\n      console.error('Cannot check Camera plugin: ' + (err?.message || err));\n    }\n  }\n\n  async add(event?: Event, opts?: {maxHeight?: number; mawWidth?: number; quality?: number}): Promise<Image[]|undefined> {\n    if (!this.started) await this.ready();\n\n    // If desktop: open upload popover\n    if (!this.platform.isCordova()) {\n      return this.addUploadedImages(event, opts);\n    }\n\n    console.info(`[image-service] Adding image...`);\n\n    try {\n      const data = await Camera.getPhoto({\n        height: this.defaultMaxHeight,\n        width: this.defaultMaxWidth,\n        promptLabelCancel: this.translate.instant('COMMON.BTN_CANCEL'),\n        promptLabelPicture: this.translate.instant('IMAGE.BTN_CAMERA_SOURCE'),\n        resultType: CameraResultType.DataUrl,\n        ...opts\n      });\n      if (!data) return undefined;\n\n      return [<Image>{\n        dataUrl: data.dataUrl\n      }];\n    }\n    catch (err) {\n      console.info(`[image-service] Error while adding image: ${err?.message || err} -> ${err?.originalStack || ''}`);\n      return undefined;\n    }\n  }\n\n  protected async addUploadedImages(event?: Event, opts?: {maxHeight?: number; mawWidth?: number; quality?: number}): Promise<Image[]|undefined> {\n    const { data } = await FilesUtils.showUploadPopover(this.popoverController, event, {\n      uniqueFile: true,\n      fileExtension: '.png, .jpg',\n      instantUpload: true,\n      uploadFn: (file) => ImagesUtils.readAsDataURL(file, {\n        maxWidth: this.defaultMaxWidth,\n        maxHeight: this.defaultMaxHeight,\n        ...opts\n      })\n    });\n\n    if (isEmptyArray(data)) return; // No files uploaded: skip\n    return (data || [])\n      .map(file => file.response.body) // Get response body = data as base64\n      .map(dataUrl => <Image>{dataUrl});\n  }\n}\n"]}