@sumaris-net/ngx-components 18.14.0 → 18.14.1

package/src/app/shared/storage/storage-explorer.component.d.ts

@@ -0,0 +1,59 @@
+import { ChangeDetectorRef, InjectionToken, OnInit } from '@angular/core';
+import { AlertController, IonModal, ToastController } from '@ionic/angular';
+import { BehaviorSubject } from 'rxjs';
+import { IStorage } from './storage.utils';
+import { IDebugDataService } from '../debug/debug-service.class';
+import { TranslateService } from '@ngx-translate/core';
+import { Environment } from '../../../environments/environment.class';
+import { Log, LogUtils } from '../logging/logger.model';
+import { MomentDateAdapter } from '@angular/material-moment-adapter';
+import { LogLevel } from '../logging/log-level.model';
+import { PlatformService } from '../../core/services/platform.service';
+import * as i0 from "@angular/core";
+interface StorageItemInfo {
+    key: string;
+    type: 'array' | 'object' | 'string' | 'number';
+    total: number;
+}
+export declare const APP_STORAGE_EXPLORER_PROTECTED_KEYS: InjectionToken<string[]>;
+export declare class StorageExplorerComponent implements OnInit {
+    protected platform: PlatformService;
+    protected toastController: ToastController;
+    protected alertCtrl: AlertController;
+    protected translate: TranslateService;
+    protected dateAdapter: MomentDateAdapter;
+    protected cd: ChangeDetectorRef;
+    protected readonly storage: IStorage;
+    protected readonly environment: Environment;
+    protected readonly debugDataService: IDebugDataService;
+    private readonly _protectedKeys;
+    private _logPrefix;
+    protected $loading: BehaviorSubject<boolean>;
+    protected $items: BehaviorSubject<StorageItemInfo[]>;
+    protected _logKey: string;
+    protected data: any;
+    protected logs: Log[];
+    protected key: string;
+    mobile: boolean;
+    showSendButton: boolean;
+    sendDataModal: IonModal;
+    viewDataModal: IonModal;
+    constructor(platform: PlatformService, toastController: ToastController, alertCtrl: AlertController, translate: TranslateService, dateAdapter: MomentDateAdapter, cd: ChangeDetectorRef, storage: IStorage, environment: Environment, debugDataService: IDebugDataService, _protectedKeys: string[]);
+    ngOnInit(): void;
+    sendDataClick(event: Event, key: string): Promise<void>;
+    viewDataClick(event: Event, key: string): Promise<void>;
+    sendData(key: string): Promise<void>;
+    downloadAsJson(key: string): Promise<void>;
+    copyToClipboard(key: string): Promise<void>;
+    protected start(): Promise<void>;
+    protected refresh(): Promise<void>;
+    protected toString(key: string, data: any, html?: boolean): string;
+    protected toLogs(data: any): Log[];
+    protected clear(key: string): Promise<void>;
+    protected trackByFn(index: number, item: StorageItemInfo): any;
+    protected levelToColor(level: LogLevel): string;
+    protected levelToString: typeof LogUtils.levelToString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageExplorerComponent, [null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StorageExplorerComponent, "app-storage-explorer", never, { "mobile": { "alias": "mobile"; "required": false; }; "showSendButton": { "alias": "showSendButton"; "required": false; }; }, {}, never, never, false, never>;
+}
+export {};

package/src/app/shared/storage/storage-explorer.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./storage-explorer.component";
+import * as i2 from "@ionic/angular";
+import * as i3 from "@angular/common";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "../rx-state/rx-state.module";
+import * as i6 from "../pipes/pipes.module";
+import * as i7 from "../material/material.module";
+export declare class StorageExplorerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageExplorerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StorageExplorerModule, [typeof i1.StorageExplorerComponent], [typeof i2.IonicModule, typeof i3.CommonModule, typeof i4.TranslateModule, typeof i5.RxStateModule, typeof i6.SharedPipesModule, typeof i7.SharedMaterialModule], [typeof i1.StorageExplorerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StorageExplorerModule>;
+}

package/src/app/shared/storage/storage-explorer.testing-routing.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/router";
+import * as i3 from "./storage-explorer.module";
+export declare class StorageExplorerTestingRoutingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageExplorerTestingRoutingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StorageExplorerTestingRoutingModule, never, [typeof i1.CommonModule, typeof i2.RouterModule, typeof i3.StorageExplorerModule], [typeof i2.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StorageExplorerTestingRoutingModule>;
+}

package/src/app/shared/storage/storage-explorer.testing.module.d.ts

@@ -0,0 +1,10 @@
+import { TestingPage } from '../testing/tests.page';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/router";
+export declare const SHARED_STORAGE_TESTING_PAGES: TestingPage[];
+export declare class StorageExplorerTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageExplorerTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StorageExplorerTestingModule, never, [typeof i1.CommonModule, typeof i2.RouterModule], [typeof i2.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StorageExplorerTestingModule>;
+}

package/src/app/shared/storage/storage.service.d.ts

@@ -0,0 +1,22 @@
+import { Storage } from '@ionic/storage-angular';
+import { IStorage } from './storage.utils';
+import { StartableService } from '../services/startable-service.class';
+import { Platform } from '@ionic/angular';
+import { Environment } from '../../../environments/environment.class';
+import * as i0 from "@angular/core";
+export declare class StorageService extends StartableService<Storage> implements IStorage<Storage> {
+    private storage;
+    private environment;
+    get driver(): string | undefined;
+    constructor(platform: Platform, storage: Storage, environment: Environment);
+    protected ngOnStart(): Promise<Storage>;
+    protected migrate(storage: Storage): Promise<void>;
+    set(key: string, value: any): Promise<any>;
+    get(key: string): Promise<any>;
+    remove(key: string): Promise<any>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+    forEach(iteratorCallback: (value: any, key: string, iterationNumber: number) => any): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
+}

package/src/app/shared/storage/storage.utils.d.ts

@@ -0,0 +1,19 @@
+import { InjectionToken } from '@angular/core';
+export interface IStorage<T = any> {
+    readonly driver: string;
+    ready(): Promise<T>;
+    set(key: string, value: any): Promise<void>;
+    get(key: string): Promise<any>;
+    remove(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+    forEach(iteratorCallback: (value: any, key: string, iterationNumber: number) => any): Promise<void>;
+}
+export declare const StorageDrivers: {
+    SQLLite: string;
+    SecureStorage: string;
+    WebSQL: string;
+    IndexedDB: string;
+    LocalStorage: string;
+};
+export declare const APP_STORAGE: InjectionToken<IStorage<any>>;

package/src/app/shared/testing/maskito.test.d.ts

@@ -0,0 +1,10 @@
+import { UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class MaskitoTestPage {
+    protected formBuilder: UntypedFormBuilder;
+    form: UntypedFormGroup;
+    labelMask: (string | RegExp)[];
+    constructor(formBuilder: UntypedFormBuilder);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaskitoTestPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MaskitoTestPage, "app-maskito-test", never, {}, {}, never, never, false, never>;
+}

package/src/app/shared/testing/observable.test.d.ts

@@ -0,0 +1,25 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import { FirstOptions, WaitForOptions } from '../observables';
+import { Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ObservableTestPage implements OnDestroy {
+    _stopSubject: Subject<void>;
+    $value: Subject<any>;
+    runningTaskCount: number;
+    taskId: number;
+    options: Partial<FirstOptions>;
+    resultDiv: ElementRef;
+    constructor();
+    ngOnDestroy(): void;
+    setOptions(opts: any): void;
+    setOptionsError(errorMessage: any): void;
+    firstNotNilPromise(opts?: FirstOptions): Promise<void>;
+    waitForTrue(opts?: WaitForOptions): Promise<void>;
+    execute<T, O extends WaitForOptions = WaitForOptions>(fn: (o: Observable<any>, opts: O) => Promise<T>, opts?: O, logPrefix?: string): Promise<void>;
+    emit(value: any): void;
+    stop(): void;
+    log(message: string, ...args: any): void;
+    appendLog(message: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObservableTestPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ObservableTestPage, "app-observable-test", never, {}, {}, never, never, false, never>;
+}

package/src/app/shared/testing/tests.page.d.ts

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export declare interface TestingPage {
+    label: string;
+    page?: string;
+    divider?: boolean;
+}
+export declare const APP_TESTING_PAGES: InjectionToken<TestingPage[]>;
+export declare class SharedTestsPage {
+    protected route: ActivatedRoute;
+    protected router: Router;
+    protected translate: TranslateService;
+    pages: TestingPage[];
+    constructor(route: ActivatedRoute, router: Router, translate: TranslateService, pages: TestingPage[]);
+    openPage(page: any): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedTestsPage, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SharedTestsPage, "app-tests-page", never, {}, {}, never, never, false, never>;
+}

package/src/app/shared/toast/toast.testing.d.ts

@@ -0,0 +1,15 @@
+import { Injector } from '@angular/core';
+import { ShowToastOptions } from './toasts';
+import * as i0 from "@angular/core";
+export declare class ToastTestingPage {
+    private injector;
+    protected options: ShowToastOptions;
+    constructor(injector: Injector);
+    showToast(opts?: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
+    showInfo(opts?: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
+    showWarning(opts?: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
+    showError(opts?: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
+    toggleCloseButton(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastTestingPage, "toast-testing", never, {}, {}, never, never, false, never>;
+}

package/src/app/shared/toast/toast.testing.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./toast.testing";
+import * as i2 from "@angular/common";
+import * as i3 from "@ionic/angular";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "@angular/router";
+import * as i6 from "@angular/forms";
+export declare class ToastTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ToastTestingModule, [typeof i1.ToastTestingPage], [typeof i2.CommonModule, typeof i3.IonicModule, typeof i4.TranslateModule, typeof i5.RouterModule, typeof i6.FormsModule], [typeof i5.RouterModule, typeof i1.ToastTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ToastTestingModule>;
+}

package/src/app/shared/toast/toasts.d.ts

@@ -0,0 +1,16 @@
+import { ToastController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { OverlayEventDetail, ToastOptions } from '@ionic/core';
+import { Injector } from '@angular/core';
+export declare interface ShowToastOptions extends ToastOptions {
+    type?: 'error' | 'warning' | 'info';
+    messageParams?: any;
+    showCloseButton?: boolean;
+    onWillPresent?: (toast: HTMLIonToastElement) => void;
+}
+export declare class Toasts {
+    static counter: number;
+    static stackSize: number;
+    static showSimple<T = any>(injector: Injector, opts: ShowToastOptions): Promise<OverlayEventDetail<T>>;
+    static show<T = any>(toastController: ToastController, translate: TranslateService, opts: ShowToastOptions): Promise<OverlayEventDetail<T>>;
+}

package/src/app/shared/toolbar/modal-toolbar.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { Hotkeys } from '../hotkeys/hotkeys.service';
+import { IconRef } from '../types';
+import * as i0 from "@angular/core";
+export declare class ModalToolbarComponent implements OnInit, OnDestroy {
+    private hotkeys;
+    private _subscription;
+    modalName: string;
+    title: string;
+    color: string;
+    showSpinner: boolean;
+    canValidate: boolean;
+    validateIcon: IconRef;
+    cancel: EventEmitter<Event>;
+    validate: EventEmitter<Event>;
+    constructor(hotkeys: Hotkeys);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalToolbarComponent, "app-modal-toolbar", never, { "modalName": { "alias": "modalName"; "required": false; }; "title": { "alias": "title"; "required": false; }; "color": { "alias": "color"; "required": false; }; "showSpinner": { "alias": "showSpinner"; "required": false; }; "canValidate": { "alias": "canValidate"; "required": false; }; "validateIcon": { "alias": "validateIcon"; "required": false; }; }, { "cancel": "cancel"; "validate": "validate"; }, never, ["[slot=start]", "ion-title", "ion-buttons[slot=end]", "ion-button[slot=end]"], false, never>;
+}

package/src/app/shared/toolbar/toolbar.d.ts

@@ -0,0 +1,70 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { IProgressBarService } from '../services/progress-bar.service';
+import { ActivatedRoute, Router } from '@angular/router';
+import { IonMenuToggle, IonRouterOutlet, IonSearchbar, NavController } from '@ionic/angular';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { HammerTapEvent } from '../gesture/hammer.utils';
+import { AppColors } from '../types';
+import { SearchbarChangeEventDetail as ISearchbarSearchbarChangeEventDetail } from '@ionic/core/dist/types/components/searchbar/searchbar-interface';
+import { ProgressBarMode } from '@angular/material/progress-bar';
+import * as i0 from "@angular/core";
+export declare abstract class ToolbarToken {
+    abstract onBackClick: Observable<Event>;
+    abstract doBackClick(event: Event): any;
+    abstract goBack(): Promise<boolean>;
+    abstract canGoBack: boolean;
+}
+export declare const TOOLBAR_HEADER_ID = "app-toolbar-header";
+export declare class ToolbarComponent implements ToolbarToken, OnInit, OnDestroy {
+    private route;
+    private router;
+    private navController;
+    private routerOutlet;
+    private cd;
+    protected progressBarService: IProgressBarService;
+    private _closeTapCount;
+    private _validateTapCount;
+    private _defaultBackHref;
+    private _backHref;
+    protected readonly progressBarMode$: BehaviorSubject<ProgressBarMode>;
+    protected showSearchBar: boolean;
+    set progressBarMode(value: ProgressBarMode);
+    get progressBarMode(): ProgressBarMode;
+    title: string;
+    color: AppColors;
+    class: string;
+    id: string;
+    set backHref(value: string);
+    get backHref(): string;
+    set defaultBackHref(value: string);
+    get defaultBackHref(): string;
+    hasValidate: boolean;
+    hasClose: boolean;
+    hasSearch: boolean;
+    canGoBack: boolean;
+    canShowMenu: boolean;
+    onValidate: EventEmitter<Event>;
+    onClose: EventEmitter<Event>;
+    onValidateAndClose: EventEmitter<Event>;
+    onBackClick: EventEmitter<Event>;
+    onSearch: EventEmitter<CustomEvent<ISearchbarSearchbarChangeEventDetail>>;
+    searchbar: IonSearchbar;
+    menuToggle: IonMenuToggle;
+    constructor(route: ActivatedRoute, router: Router, navController: NavController, routerOutlet: IonRouterOutlet, cd: ChangeDetectorRef, progressBarService: IProgressBarService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    toggleSearchBar(): Promise<void>;
+    doBackClick(event: Event): void;
+    goBack(): Promise<boolean>;
+    tapClose(event: HammerTapEvent): void;
+    tapValidate(event: HammerTapEvent): void;
+    protected ionSearchBarChanged(event: Event): void;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, [null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "app-toolbar", never, { "progressBarMode": { "alias": "progressBarMode"; "required": false; }; "title": { "alias": "title"; "required": false; }; "color": { "alias": "color"; "required": false; }; "class": { "alias": "class"; "required": false; }; "id": { "alias": "id"; "required": false; }; "backHref": { "alias": "backHref"; "required": false; }; "defaultBackHref": { "alias": "defaultBackHref"; "required": false; }; "hasValidate": { "alias": "hasValidate"; "required": false; }; "hasClose": { "alias": "hasClose"; "required": false; }; "hasSearch": { "alias": "hasSearch"; "required": false; }; "canGoBack": { "alias": "canGoBack"; "required": false; }; "canShowMenu": { "alias": "canShowMenu"; "required": false; }; }, { "onValidate": "onValidate"; "onClose": "onClose"; "onValidateAndClose": "onValidateAndClose"; "onBackClick": "onBackClick"; "onSearch": "onSearch"; }, never, ["[slot=start]", "ion-title, ion-segment", "ion-buttons[slot=end]", "[slot=end]"], false, never>;
+    static ngAcceptInputType_hasValidate: unknown;
+    static ngAcceptInputType_hasClose: unknown;
+    static ngAcceptInputType_hasSearch: unknown;
+    static ngAcceptInputType_canGoBack: unknown;
+    static ngAcceptInputType_canShowMenu: unknown;
+}

package/src/app/shared/toolbar/toolbar.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./toolbar";
+import * as i2 from "./modal-toolbar";
+import * as i3 from "@angular/common";
+import * as i4 from "@ionic/angular";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "@angular/platform-browser";
+import * as i7 from "../pipes/pipes.module";
+import * as i8 from "../rx-state/rx-state.module";
+import * as i9 from "@angular/material/progress-bar";
+import * as i10 from "@angular/material/icon";
+export declare class SharedToolbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedToolbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedToolbarModule, [typeof i1.ToolbarComponent, typeof i2.ModalToolbarComponent], [typeof i3.CommonModule, typeof i4.IonicModule, typeof i5.TranslateModule, typeof i6.HammerModule, typeof i7.SharedPipesModule, typeof i8.RxStateModule, typeof i9.MatProgressBarModule, typeof i10.MatIconModule], [typeof i1.ToolbarComponent, typeof i2.ModalToolbarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SharedToolbarModule>;
+}

package/src/app/shared/types.d.ts

@@ -0,0 +1,36 @@
+import { ThemePalette } from '@angular/material/core';
+import { PredefinedColors } from '@ionic/core';
+import { Predicate } from '@angular/core';
+export declare type KeyType = string | number;
+export declare type KeyValueType<T> = {
+    [key in KeyType]: T;
+};
+export declare type KeysEnum<T> = {
+    [P in keyof Required<T>]: boolean;
+};
+export declare interface ObjectMap<T = any> {
+    [key: string]: T;
+}
+export declare interface ObjectMapEntry<T = any> {
+    key: string;
+    value?: T;
+}
+export declare type PropertyMap<T = string> = ObjectMap<T>;
+/**
+ * Same as PropertyMap
+ * @deprecated Use PropertyMap instead
+ */
+export declare type PropertiesMap<T = string> = PropertyMap<T>;
+export declare type Property<T = string> = ObjectMapEntry<T>;
+export declare type PropertiesArray = Property[];
+export declare type AppColors = PredefinedColors | ThemePalette | string;
+export declare interface IconRef {
+    icon?: string;
+    matIcon?: string;
+    matSvgIcon?: string;
+    color?: AppColors;
+}
+export declare type FilterFn<T> = Predicate<T>;
+export declare type FilterFnFactory<T, F> = (filter: F) => FilterFn<T>;
+export declare type Function<P, R> = (value: P) => R;
+export declare type BiFunction<P1, P2, R> = (v1: P1, v2: P2) => R;

package/src/app/shared/upload-file/testing/upload-file.testing.d.ts

@@ -0,0 +1,21 @@
+import { PopoverController } from '@ionic/angular';
+import { UploadFilePopoverOptions } from '../upload-file-popover.component';
+import { Observable } from 'rxjs';
+import { FileEvent } from '../upload-file.model';
+import * as i0 from "@angular/core";
+export declare class UploadFileTestingPage {
+    private popoverController;
+    constructor(popoverController: PopoverController);
+    showPopover(event: Event, opts?: Partial<UploadFilePopoverOptions<any>>): Promise<void>;
+    /**
+     * Simulate a upload function, with progression
+     *
+     * @param file
+     */
+    uploadFile(file: File): Observable<FileEvent<{
+        finalName: string;
+    }>>;
+    deleteFile(file: File): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadFileTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadFileTestingPage, "upload-file-testing", never, {}, {}, never, never, false, never>;
+}

package/src/app/shared/upload-file/testing/upload-file.testing.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./upload-file.testing";
+import * as i2 from "@angular/common";
+import * as i3 from "@ionic/angular";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "@angular/router";
+export declare class UploadFileTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadFileTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UploadFileTestingModule, [typeof i1.UploadFileTestingPage], [typeof i2.CommonModule, typeof i3.IonicModule, typeof i4.TranslateModule, typeof i5.RouterModule], [typeof i5.RouterModule, typeof i1.UploadFileTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UploadFileTestingModule>;
+}

package/src/app/shared/upload-file/upload-file-popover.component.d.ts

@@ -0,0 +1,41 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { PopoverController } from '@ionic/angular';
+import { UploadFileComponent } from './upload-file.component';
+import { FileDeleteFn, FileUploadFn, UploadFile } from './upload-file.model';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export interface UploadFilePopoverOptions<T> {
+    title?: string;
+    uploadFn: FileUploadFn<T>;
+    deleteFn?: FileDeleteFn<any>;
+    instantUpload?: boolean;
+    uniqueFile?: boolean;
+    fileExtension?: string;
+    maxParallelUpload?: number;
+    autoHideDropArea?: boolean;
+}
+export declare class UploadFilePopover implements UploadFilePopoverOptions<any> {
+    protected popoverController: PopoverController;
+    protected translate: TranslateService;
+    protected cd: ChangeDetectorRef;
+    uploader: UploadFileComponent;
+    fileExtension: string;
+    title: string;
+    uniqueFile: boolean;
+    instantUpload: boolean;
+    uploadFn: FileUploadFn<any>;
+    deleteFn: FileDeleteFn<any>;
+    maxParallelUpload: number;
+    autoHideDropArea: boolean;
+    importing: boolean;
+    error: string;
+    get files(): UploadFile<any>[];
+    get disabled(): boolean;
+    get valid(): boolean;
+    constructor(popoverController: PopoverController, translate: TranslateService, cd: ChangeDetectorRef);
+    onValidate(event: any): Promise<any>;
+    cancel(): Promise<boolean>;
+    protected resetError(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadFilePopover, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadFilePopover, "app-upload-file-popover", never, { "fileExtension": { "alias": "fileExtension"; "required": false; }; "title": { "alias": "title"; "required": false; }; "uniqueFile": { "alias": "uniqueFile"; "required": false; }; "instantUpload": { "alias": "instantUpload"; "required": false; }; "uploadFn": { "alias": "uploadFn"; "required": false; }; "deleteFn": { "alias": "deleteFn"; "required": false; }; "maxParallelUpload": { "alias": "maxParallelUpload"; "required": false; }; "autoHideDropArea": { "alias": "autoHideDropArea"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/shared/upload-file/upload-file.component.d.ts

@@ -0,0 +1,50 @@
+import { ChangeDetectorRef, ElementRef } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { FileDeleteFn, FileUploadFn, UploadFile } from './upload-file.model';
+import { WaitForOptions } from '../observables';
+import * as i0 from "@angular/core";
+export declare class UploadFileComponent {
+    protected cd: ChangeDetectorRef;
+    protected translate: TranslateService;
+    fileDropEl: ElementRef;
+    fileExtension: string;
+    uniqueFile: boolean;
+    instantUpload: boolean;
+    uploadFn: FileUploadFn<any>;
+    deleteFn: FileDeleteFn<any>;
+    maxParallelUpload: number;
+    autoHideDropArea: boolean;
+    files: UploadFile<any>[];
+    uploading: boolean;
+    get processingFiles(): UploadFile<any>[];
+    get processedFiles(): UploadFile<any>[];
+    get processingFilesCount(): number;
+    constructor(cd: ChangeDetectorRef, translate: TranslateService);
+    /**
+     * on file drop handler
+     */
+    onFileDropped(event: any): void;
+    /**
+     * handle file from browsing
+     */
+    fileBrowseHandler(files: any): void;
+    /**
+     * Delete file from files list
+     *
+     * @param index (File index)
+     */
+    deleteFile(index: number): Promise<void>;
+    /**
+     * Convert Files list to normal array list
+     *
+     * @param files (Files List)
+     */
+    prepareFilesList(files: FileList | File[]): void;
+    /**
+     * Execute upload
+     */
+    uploadFiles(files?: File[]): Promise<UploadFile<any>[]>;
+    waitIdle(opts?: WaitForOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadFileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadFileComponent, "app-upload-file", never, { "fileExtension": { "alias": "fileExtension"; "required": false; }; "uniqueFile": { "alias": "uniqueFile"; "required": false; }; "instantUpload": { "alias": "instantUpload"; "required": false; }; "uploadFn": { "alias": "uploadFn"; "required": false; }; "deleteFn": { "alias": "deleteFn"; "required": false; }; "maxParallelUpload": { "alias": "maxParallelUpload"; "required": false; }; "autoHideDropArea": { "alias": "autoHideDropArea"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/shared/upload-file/upload-file.model.d.ts

@@ -0,0 +1,30 @@
+import { Observable } from 'rxjs';
+import { HttpEvent, HttpEventType, HttpProgressEvent, HttpResponse } from '@angular/common/http';
+export declare class UploadFile<T> extends File {
+    progress?: number;
+    deleting?: boolean;
+    error?: string;
+    response?: FileResponse<T> | HttpResponse<T>;
+}
+export type FileUploadFn<T> = (file: File) => Observable<FileEvent<T> | HttpEvent<T>>;
+export type FileDeleteFn<T> = (file: UploadFile<T>) => Promise<boolean>;
+export interface FileProgressEvent {
+    type: HttpEventType.DownloadProgress | HttpEventType.UploadProgress;
+    loaded: number;
+    total?: number;
+    statusText?: string;
+}
+export declare class FileResponse<T> {
+    readonly body: T | null;
+    readonly type = HttpEventType.Response;
+    readonly status: number;
+    readonly statusText: string;
+    constructor(init?: {
+        body?: T | null;
+        statusText?: string;
+        status?: number;
+    });
+}
+export declare type FileEvent<T> = HttpProgressEvent | HttpResponse<T> | FileProgressEvent | FileResponse<T>;
+export declare function isProgressEvent(event: HttpEvent<any> | FileEvent<any>): event is HttpProgressEvent | FileProgressEvent;
+export declare function isResponseEvent<T>(event: HttpEvent<T> | FileEvent<T>): event is HttpResponse<T> | FileResponse<T>;

package/src/app/shared/validator/form-error-adapter.class.d.ts

@@ -0,0 +1,33 @@
+import { InjectionToken } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { AbstractControl } from '@angular/forms';
+import { ObjectMap } from '../types';
+import { FormErrors } from '../forms';
+import { TranslateContextService } from '../services/translate-context.service';
+import * as i0 from "@angular/core";
+export declare const APP_FORM_ERROR_I18N_KEYS: InjectionToken<ObjectMap<string>>;
+export interface IFormPathTranslatorOptions {
+    i18nPrefix?: string;
+    i18nSuffix?: string;
+    [key: string]: any;
+}
+export interface IFormPathTranslator<O extends IFormPathTranslatorOptions = IFormPathTranslatorOptions> {
+    translateFormPath: (path: string, opts?: O) => string;
+}
+export interface FormErrorTranslateOptions extends IFormPathTranslatorOptions {
+    pathTranslator?: IFormPathTranslator;
+    separator?: string;
+    recursive?: boolean;
+}
+export declare class FormErrorTranslator implements IFormPathTranslator {
+    private translate;
+    private translateContext;
+    private readonly errorI18nKeys;
+    constructor(translate: TranslateService, translateContext: TranslateContextService, errorI18nKeys: ObjectMap<string>);
+    translateFormErrors(control: AbstractControl, opts?: FormErrorTranslateOptions): string;
+    translateErrors(errors: FormErrors, opts?: FormErrorTranslateOptions): string;
+    translateFormPath(path: string, opts?: FormErrorTranslateOptions): string;
+    translateError(errorKey: string, errorContent?: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormErrorTranslator, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormErrorTranslator>;
+}