@sumaris-net/ngx-components 18.14.0 → 18.14.1

package/src/app/core/form/array/form-array.d.ts

@@ -0,0 +1,137 @@
+import { Entity } from '../../services/model/entity.model';
+import { AbstractControl, AbstractControlOptions, UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, ValidatorFn } from '@angular/forms';
+export interface FormArrayHelperOptions {
+    allowEmptyArray: boolean;
+    allowManyNullValues?: boolean;
+    allowDuplicatedValues?: boolean;
+    validators?: ValidatorFn[];
+}
+export declare class FormArrayHelper<T = Entity<any>, C extends AbstractControl = AbstractControl> {
+    private readonly _formArray;
+    private createControl;
+    private equals;
+    private isEmpty;
+    static getOrCreateArray(formBuilder: UntypedFormBuilder, form: UntypedFormGroup, arrayName: string): UntypedFormArray;
+    private _allowEmptyArray;
+    private _allowManyNullValues;
+    private _allowDuplicatedValues;
+    private readonly _validators;
+    get allowEmptyArray(): boolean;
+    set allowEmptyArray(value: boolean);
+    get allowManyNullValues(): boolean;
+    set allowManyNullValues(value: boolean);
+    get allowDuplicatedValues(): boolean;
+    set allowDuplicatedValues(value: boolean);
+    get formArray(): UntypedFormArray;
+    constructor(_formArray: UntypedFormArray, createControl: (value?: T) => C, equals: (v1: T, v2: T) => boolean, isEmpty: (value: T) => boolean, options?: FormArrayHelperOptions);
+    /**
+     * @param value
+     * @param options
+     */
+    add(value?: T, options?: {
+        emitEvent: boolean;
+        insertAt?: number;
+    }): boolean;
+    removeAt(index: number): boolean;
+    resize(length: number, options?: {
+        emitEvent?: boolean;
+    }): boolean;
+    clearAt(index: number): boolean;
+    isLast(index: number): boolean;
+    removeAllEmpty(): void;
+    size(): number;
+    at(index: number): C;
+    /**
+     * Resize the FormArray, then set values
+     *
+     * @param values
+     * @param options
+     */
+    setValue(values: T[], options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Resize the FormArray, then patch values
+     *
+     * @param values
+     * @param options
+     */
+    patchValue(values: T[], options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    disable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    enable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    forEach(ite: (control: C) => void): void;
+    protected setAllowEmptyArray(value: boolean): void;
+}
+export declare interface AppFormArrayOptions extends AbstractControlOptions {
+    allowEmptyArray?: boolean;
+    allowReuseControls?: boolean;
+    allowManyNullValues?: boolean;
+    allowDuplicateValue?: boolean;
+}
+export declare class AppFormArray<T = Entity<any>, C extends AbstractControl = AbstractControl> extends UntypedFormArray {
+    createControl: (value?: T) => C;
+    private equals;
+    private isEmpty;
+    private readonly options;
+    get allowEmptyArray(): boolean;
+    set allowEmptyArray(value: boolean);
+    get allowManyNullValues(): boolean;
+    set allowManyNullValues(value: boolean);
+    get allowDuplicateValue(): boolean;
+    set allowDuplicateValue(value: boolean);
+    constructor(createControl: (value?: T) => C, equals: (v1: T, v2: T) => boolean, isEmpty: (value: T) => boolean, options?: AppFormArrayOptions | undefined | null);
+    /**
+     * WIll rebuild the array, using the given values
+     *
+     * @param values
+     * @param options
+     */
+    setValue(values: any[], options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    patchValue(values: any[] | null | undefined, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    resize(length: number, options?: {
+        emitEvent?: boolean;
+    }): boolean;
+    disable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    enable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    forEach(ite: (control: C) => void): void;
+    /**
+     * @param value
+     * @param options
+     */
+    add(value?: T, options?: {
+        emitEvent: boolean;
+        insertAt?: number;
+    }): void;
+    removeAt(index: number, options?: {
+        emitEvent: boolean;
+    }): boolean;
+    clearAt(index: number, options?: {
+        emitEvent: boolean;
+    }): void;
+    isLast(index: number): boolean;
+    removeAllEmpty(): void;
+    clone(): AppFormArray<T, C>;
+    protected setAllowEmptyArray(value: boolean): void;
+}

package/src/app/core/form/array/testing/form-array-test.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./form-array.test";
+import * as i2 from "@angular/common";
+import * as i3 from "../../../../shared/shared.module";
+import * as i4 from "../../../core.module";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "@angular/router";
+export declare class FormArrayTestModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormArrayTestModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormArrayTestModule, [typeof i1.ArrayFormTestPage], [typeof i2.CommonModule, typeof i3.SharedModule, typeof i4.CoreModule, typeof i5.TranslateModule], [typeof i1.ArrayFormTestPage, typeof i6.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormArrayTestModule>;
+}

package/src/app/core/form/array/testing/form-array.test.d.ts

@@ -0,0 +1,26 @@
+import { ChangeDetectorRef, Injector, OnDestroy, OnInit } from '@angular/core';
+import { UntypedFormBuilder, UntypedFormControl } from '@angular/forms';
+import { PlatformService } from '../../../services/platform.service';
+import { AppForm } from '../../form.class';
+import { AppFormArray } from '../form-array';
+import * as i0 from "@angular/core";
+export declare class ArrayFormTestPage extends AppForm<any> implements OnInit, OnDestroy {
+    protected formBuilder: UntypedFormBuilder;
+    protected platform: PlatformService;
+    protected injection: Injector;
+    protected cd: ChangeDetectorRef;
+    private subscription;
+    get defaultFormArray(): AppFormArray<any, any>;
+    get notEmptyFormArray(): AppFormArray<any, any>;
+    get nullValuesFormArray(): AppFormArray<any, any>;
+    get duplicatedValuesFormArray(): AppFormArray<any, any>;
+    get valueToAddControl(): UntypedFormControl;
+    constructor(formBuilder: UntypedFormBuilder, platform: PlatformService, injection: Injector, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    loadData(): Promise<void>;
+    protected setFormArrayValue(formArray: AppFormArray<any, any>, values: string | string[]): void;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayFormTestPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayFormTestPage, "app-array-test", never, {}, {}, never, never, false, never>;
+}

package/src/app/core/form/buttons/form-buttons-bar.component.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { Hotkeys } from '../../../shared/hotkeys/hotkeys.service';
+import { MenuService } from '../../menu/menu.service';
+import { PredefinedColors } from '@ionic/core';
+import * as i0 from "@angular/core";
+export declare abstract class FormButtonsBarToken {
+    abstract onCancel: EventEmitter<Event>;
+    abstract onSave: EventEmitter<Event>;
+    abstract onNext: EventEmitter<Event>;
+    abstract onBack: EventEmitter<Event>;
+}
+export declare class FormButtonsBarComponent implements FormButtonsBarToken, OnDestroy {
+    protected menu: MenuService;
+    private _subscription;
+    disabled: boolean;
+    disabledCancel: boolean;
+    disabledEscape: boolean;
+    classList: string;
+    saveButtonColor: PredefinedColors;
+    backText: string;
+    cancelText: string;
+    nextText: string;
+    showBack: boolean;
+    showCancel: boolean;
+    showNext: boolean;
+    showSave: boolean;
+    onCancel: EventEmitter<Event>;
+    onSave: EventEmitter<Event>;
+    onNext: EventEmitter<Event>;
+    onBack: EventEmitter<Event>;
+    onSaveAndClose: EventEmitter<Event>;
+    onSaveAndNext: EventEmitter<Event>;
+    constructor(hotkeys: Hotkeys, menu: MenuService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormButtonsBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormButtonsBarComponent, "app-form-buttons-bar", never, { "disabled": { "alias": "disabled"; "required": false; }; "disabledCancel": { "alias": "disabledCancel"; "required": false; }; "disabledEscape": { "alias": "disabledEscape"; "required": false; }; "classList": { "alias": "classList"; "required": false; }; "saveButtonColor": { "alias": "saveButtonColor"; "required": false; }; "backText": { "alias": "backText"; "required": false; }; "cancelText": { "alias": "cancelText"; "required": false; }; "nextText": { "alias": "nextText"; "required": false; }; "showBack": { "alias": "showBack"; "required": false; }; "showCancel": { "alias": "showCancel"; "required": false; }; "showNext": { "alias": "showNext"; "required": false; }; "showSave": { "alias": "showSave"; "required": false; }; }, { "onCancel": "onCancel"; "onSave": "onSave"; "onNext": "onNext"; "onBack": "onBack"; "onSaveAndClose": "onSaveAndClose"; "onSaveAndNext": "onSaveAndNext"; }, never, ["*", "[slot=end]", "[slot=afterSave]"], false, never>;
+}

package/src/app/core/form/buttons/form-buttons-bar.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./form-buttons-bar.component";
+import * as i2 from "../../../shared/shared.module";
+import * as i3 from "@ngx-translate/core";
+export declare class AppFormButtonsBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppFormButtonsBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppFormButtonsBarModule, [typeof i1.FormButtonsBarComponent], [typeof i2.SharedModule, typeof i3.TranslateModule], [typeof i3.TranslateModule, typeof i1.FormButtonsBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppFormButtonsBarModule>;
+}

package/src/app/core/form/entity/editor.class.d.ts

@@ -0,0 +1,84 @@
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute, Params, Router } from '@angular/router';
+import { AlertController, IonContent, NavController, ToastController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject } from 'rxjs';
+import { FormButtonsBarToken } from '../buttons/form-buttons-bar.component';
+import { CanLeave, CanSave, IAppForm, IAppFormGetter } from '../form.utils';
+import { ShowToastOptions } from '../../../shared/toast/toasts';
+import { ToolbarToken } from '../../../shared/toolbar/toolbar';
+import { AppFormContainer, IAppFormContainer } from '../form-container.class';
+import * as i0 from "@angular/core";
+export interface IAppEditor<T> extends IAppFormContainer<T>, CanSave, CanLeave {
+    save(event?: Event, options?: any): Promise<boolean>;
+    cancel(event?: Event): Promise<void>;
+}
+export declare abstract class AppEditor<T = any, ID = number, O = any> extends AppFormContainer<T> implements IAppEditor<T>, OnInit, OnDestroy, AfterViewInit {
+    protected route: ActivatedRoute;
+    protected router: Router;
+    protected navController: NavController;
+    protected alertCtrl: AlertController;
+    protected translate: TranslateService;
+    protected toastController: ToastController;
+    readonly savingSubject: BehaviorSubject<boolean>;
+    submitted: boolean;
+    queryParams: Params;
+    i18nContext: {
+        prefix: string;
+        suffix: string;
+    };
+    get saving(): boolean;
+    toolbar: ToolbarToken | null;
+    formButtonsBar: FormButtonsBarToken | null;
+    content: IonContent;
+    abstract get isNewData(): boolean;
+    protected constructor(route: ActivatedRoute, // Modal editor give 'null'
+    router: Router, navController: NavController, alertCtrl: AlertController, translate: TranslateService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * @deprecated Use addForm(path, form)
+     * @param form
+     */
+    addChildForm(form: IAppForm | IAppFormGetter): void;
+    /**
+     * @deprecated Use addForms()
+     * @param forms
+     */
+    addChildForms(forms: (IAppForm | IAppFormGetter)[]): void;
+    /**
+     * @deprecated Use removeForm()
+     * @param form
+     */
+    removeChildForm(form: IAppForm | IAppFormGetter): IAppForm | IAppFormGetter;
+    markAsSaving(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsSaved(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    cancel(event?: Event): Promise<void>;
+    /**
+     * Unload the page (remove all data). Useful when reusing angular cache a cancelled page
+     *
+     * @param opts
+     */
+    unload(opts?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    reloadWithConfirmation(confirm?: boolean): Promise<void>;
+    goBack(event?: Event): Promise<void | boolean>;
+    abstract load(id?: ID, options?: O): Promise<void>;
+    abstract save(event?: Event, options?: any): Promise<boolean>;
+    abstract reload(): Promise<void>;
+    protected scrollToTop(duration?: number): Promise<void>;
+    protected saveIfDirtyAndConfirm(event?: Event, opts?: {
+        emitEvent?: boolean;
+        confirmed?: boolean;
+    }): Promise<boolean>;
+    protected saveDirtyChildren(): Promise<boolean>;
+    protected showToast(opts: ShowToastOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppEditor<any, any, any>, [{ optional: true; }, null, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppEditor<any, any, any>, never, never, {}, {}, never, never, false, never>;
+}

package/src/app/core/form/entity/entity-editor-modal.class.d.ts

@@ -0,0 +1,126 @@
+import { AfterViewInit, ChangeDetectorRef, Injector, OnDestroy, OnInit } from '@angular/core';
+import { ModalController } from '@ionic/angular';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { LocalSettingsService } from '../../services/local-settings.service';
+import { Entity } from '../../services/model/entity.model';
+import { UsageMode } from '../../services/model/settings.model';
+import { FormGroup } from '@angular/forms';
+import { AppTabEditor, AppTabEditorOptions } from './tab-editor.class';
+import { AppErrorWithDetails } from '../../services/errors';
+import { DateFormatService } from '../../../shared/pipes/date-format.pipe';
+import { WaitForOptions } from '../../../shared/observables';
+import { FormErrorTranslator } from '../../../shared/validator/form-error-adapter.class';
+import * as i0 from "@angular/core";
+export interface IEntityEditorModalOptions<T extends Entity<T, ID> = Entity<any, any>, ID = number> {
+    isNew: boolean;
+    data: T;
+    disabled: boolean;
+    onAfterModalInit?: <M extends AppEntityEditorModal<T, ID>>(modal: M) => void | Promise<void>;
+    onDelete?: (event: Event, data: T) => Promise<boolean>;
+    usageMode: UsageMode;
+    mobile: boolean;
+    i18nSuffix?: string;
+}
+export declare class AppEntityEditorModalOptions extends AppTabEditorOptions {
+    i18nPrefix?: string;
+}
+export declare abstract class AppEntityEditorModal<T extends Entity<T, ID>, ID = number, O extends AppEntityEditorModalOptions = AppEntityEditorModalOptions> extends AppTabEditor<T, ID> implements OnInit, OnDestroy, AfterViewInit, IEntityEditorModalOptions<T, ID> {
+    protected dataType: new () => T;
+    protected _logPrefix: string;
+    protected _isNew: boolean;
+    protected readonly dateFormat: DateFormatService;
+    protected readonly cd: ChangeDetectorRef;
+    protected readonly settings: LocalSettingsService;
+    protected readonly modalCtrl: ModalController;
+    protected errorTranslator: FormErrorTranslator;
+    readonly savingSubject: BehaviorSubject<boolean>;
+    readonly titleSubject: BehaviorSubject<string>;
+    data: T;
+    mobile: boolean;
+    usageMode: UsageMode;
+    onAfterModalInit: <M extends AppEntityEditorModal<T, ID>>(modal: M) => void | Promise<void>;
+    onDelete: (event: Event, data: T) => Promise<boolean>;
+    i18nSuffix: string;
+    /**
+     * @deprecated
+     */
+    protected get $title(): Subject<string>;
+    set isNew(value: boolean);
+    get isNew(): boolean;
+    /**
+     * @deprecated use isNew instead
+     */
+    get isNewData(): boolean;
+    /**
+     * @deprecated use isNew instead
+     */
+    set isNewData(value: boolean);
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    get isOnFieldMode(): boolean;
+    protected constructor(injector: Injector, dataType: new () => T, options?: O);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    waitIdle(opts?: WaitForOptions): Promise<void>;
+    load(): Promise<void>;
+    reload(): Promise<void>;
+    unload(opts?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    updateView(data: T, opts?: {
+        emitEvent?: boolean;
+        openTabIndex?: number;
+    }): Promise<void>;
+    /**
+     * Enable or disable state
+     */
+    updateViewState(data: T, opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    saveAndClose(event?: Event | Event): Promise<boolean>;
+    close(event: Event | Event): Promise<void>;
+    /**
+     * Save the editor, by calling the dataService.save().
+     * Ensure that editor if valid. If not, display an error
+     *
+     * @param event
+     * @param opts
+     */
+    save(event?: Event | Event, opts?: any): Promise<boolean>;
+    /**
+     * Save data (if dirty and valid), and return it. Otherwise, return nil value.
+     */
+    saveAndGetDataIfValid(): Promise<T | undefined>;
+    delete(event?: Event | Event): Promise<boolean>;
+    resetError(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    setError(err: string | AppErrorWithDetails, opts?: {
+        emitEvent?: boolean;
+        detailsCssClass?: string;
+    }): void;
+    abstract setValue(data: T): Promise<void> | void;
+    protected abstract registerForms(): void;
+    protected abstract computeTitle(data: T): Promise<string>;
+    protected abstract get form(): FormGroup;
+    protected abstract getFirstInvalidTabIndex(): number;
+    protected waitWhilePending(opts?: WaitForOptions): Promise<void>;
+    protected getValue(): Promise<T>;
+    protected getJsonValueToSave(): Promise<any>;
+    /**
+     * Compute the title
+     *
+     * @param data
+     */
+    protected updateTitle(data?: T): Promise<void>;
+    protected scrollToTop(duration?: number): Promise<void>;
+    protected markForCheck(): void;
+    /**
+     * Open the first tab that is invalid
+     */
+    private openFirstInvalidTab;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppEntityEditorModal<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppEntityEditorModal<any, any, any>, never, never, { "data": { "alias": "data"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "usageMode": { "alias": "usageMode"; "required": false; }; "onAfterModalInit": { "alias": "onAfterModalInit"; "required": false; }; "onDelete": { "alias": "onDelete"; "required": false; }; "i18nSuffix": { "alias": "i18nSuffix"; "required": false; }; "isNew": { "alias": "isNew"; "required": false; }; "isNewData": { "alias": "isNewData"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/core/form/entity/entity-editor.class.d.ts

@@ -0,0 +1,204 @@
+import { AfterViewInit, ChangeDetectorRef, EventEmitter, Injector, OnDestroy, OnInit } from '@angular/core';
+import { IonRouterOutlet } from '@ionic/angular';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { AddToPageHistoryOptions, LocalSettingsService } from '../../services/local-settings.service';
+import { Entity } from '../../services/model/entity.model';
+import { UsageMode } from '../../services/model/settings.model';
+import { FormGroup } from '@angular/forms';
+import { AppTabEditor, AppTabEditorOptions, IAppTabEditor } from './tab-editor.class';
+import { AppErrorWithDetails } from '../../services/errors';
+import { EntityServiceLoadOptions, IEntityService } from '../../../shared/services/entity-service.class';
+import { DateFormatService } from '../../../shared/pipes/date-format.pipe';
+import { Environment } from '../../../../environments/environment.class';
+import { HistoryPageReference } from '../../services/model/history.model';
+import { WaitForOptions } from '../../../shared/observables';
+import { FormErrorTranslator } from '../../../shared/validator/form-error-adapter.class';
+import * as i0 from "@angular/core";
+export interface IAppEntityEditor<T> extends IAppTabEditor<T> {
+    usageMode: UsageMode;
+    isNewData: boolean;
+}
+export declare class AppEditorOptions extends AppTabEditorOptions {
+    autoLoad?: boolean;
+    autoLoadDelay?: number;
+    pathIdAttribute?: string;
+    enableListenChanges?: boolean;
+    listenIntervalInSeconds?: number;
+    /**
+     * Change page route (window URL) when saving for the first time
+     */
+    autoUpdateRoute?: boolean;
+    /**
+     * Open the next tab, after saving for the first time
+     */
+    autoOpenNextTab?: boolean;
+    i18nPrefix?: string;
+}
+export declare abstract class AppEntityEditor<T extends Entity<T, ID>, S extends IEntityService<T, ID> = IEntityService<T, any>, ID = number, LO extends EntityServiceLoadOptions = EntityServiceLoadOptions> extends AppTabEditor<T, ID, LO> implements OnInit, OnDestroy, AfterViewInit, IAppEntityEditor<T> {
+    protected dataType: new () => T;
+    protected dataService?: S;
+    data: T;
+    previousDataId: ID;
+    defaultBackHref: string;
+    historyIcon: {
+        icon?: string;
+        matIcon?: string;
+    };
+    readonly titleSubject: BehaviorSubject<string>;
+    readonly onUpdateView: EventEmitter<T>;
+    /**
+     *  @deprecated
+     */
+    protected get $title(): Subject<string>;
+    protected readonly cd: ChangeDetectorRef;
+    protected readonly dateFormat: DateFormatService;
+    protected readonly settings: LocalSettingsService;
+    protected readonly environment: Environment;
+    protected readonly routerOutlet: IonRouterOutlet;
+    protected errorTranslator: FormErrorTranslator;
+    private _usageMode;
+    private readonly _enableListenChanges;
+    private readonly _listenIntervalInSeconds;
+    private readonly _pathIdAttribute;
+    private readonly _autoLoad;
+    private readonly _autoLoadDelay;
+    private readonly _autoUpdateRoute;
+    private _autoOpenNextTab;
+    private _listenChangesSubscription;
+    get usageMode(): UsageMode;
+    set usageMode(value: UsageMode);
+    get isOnFieldMode(): boolean;
+    get isNewData(): boolean;
+    get service(): S;
+    get autoOpenNextTab(): boolean;
+    set autoOpenNextTab(value: boolean);
+    protected get pathIdAttribute(): string;
+    protected constructor(injector: Injector, dataType: new () => T, dataService?: S, options?: AppEditorOptions);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    waitIdle(opts?: WaitForOptions): Promise<void>;
+    /**
+     * Load data from id, using the dataService
+     *
+     * @param id
+     * @param opts
+     */
+    load(id?: ID, opts?: EntityServiceLoadOptions & {
+        emitEvent?: boolean;
+        openTabIndex?: number;
+        updateRoute?: boolean;
+        [key: string]: any;
+    }): Promise<void>;
+    canUserWrite(data: T, opts?: any): boolean;
+    startListenChanges(): void;
+    stopListenChanges(): void;
+    ready(opts?: WaitForOptions): Promise<void>;
+    updateView(data: T | null, opts?: {
+        emitEvent?: boolean;
+        openTabIndex?: number;
+        updateRoute?: boolean;
+    }): Promise<void>;
+    /**
+     * Enable or disable state
+     */
+    updateViewState(data: T, opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Update the route location, and open the next tab
+     */
+    updateTabAndRoute(data: T, opts?: {
+        openTabIndex?: number;
+    }): Promise<void>;
+    /**
+     * Update the route location, and open the next tab
+     */
+    updateTabIndex(tabIndex?: number): void;
+    saveAndClose(event: Event, options?: any): Promise<boolean>;
+    close(event: Event): Promise<boolean | void>;
+    /**
+     * Save the editor, by calling the dataService.save().
+     * Ensure that editor if valid. If not, display an error
+     *
+     * @param event
+     * @param opts
+     */
+    save(event?: Event, opts?: any): Promise<boolean>;
+    /**
+     * Save data (if dirty and valid), and return it. Otherwise, return nil value.
+     */
+    saveAndGetDataIfValid(): Promise<T | undefined>;
+    delete(event?: Event): Promise<boolean>;
+    reload(): Promise<void>;
+    unload(opts?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    goBack(event?: Event): Promise<void | boolean>;
+    resetError(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    setError(err: string | AppErrorWithDetails, opts?: {
+        emitEvent?: boolean;
+        detailsCssClass?: string;
+    }): void;
+    /**
+     * Load data from the snapshot route
+     *
+     * @protected
+     */
+    protected loadFromRoute(): Promise<void>;
+    /**
+     * Return undefined to keep same tab
+     *
+     * @protected
+     */
+    protected computeNextTabIndex(): number | undefined;
+    protected onBeforeEntityLoad(): Promise<void>;
+    protected onNewEntity(data: T, options?: EntityServiceLoadOptions): Promise<void>;
+    protected onEntityLoaded(data: T, options?: EntityServiceLoadOptions): Promise<void>;
+    protected onEntitySaved(data: T): Promise<void>;
+    protected onEntityDeleted(data: T): Promise<void>;
+    protected computeUsageMode(data: T): UsageMode;
+    protected waitWhilePending(opts?: WaitForOptions): Promise<void>;
+    getValue(): Promise<T>;
+    protected getJsonValueToSave(): Promise<any>;
+    /**
+     * Compute the title
+     *
+     * @param data
+     */
+    protected updateTitle(data?: T): Promise<void>;
+    protected addToPageHistory(page: HistoryPageReference, opts?: AddToPageHistoryOptions): Promise<void>;
+    protected computePageHistory(title: string): Promise<HistoryPageReference>;
+    protected removePageHistory(opts?: {
+        emitEvent?: boolean;
+    }): Promise<any>;
+    protected computePageUrl(id: ID | 'new'): string | any[];
+    protected getParentPageUrl(withQueryParams?: boolean): string;
+    protected listenChanges(id: ID, opts?: any): Observable<T | undefined>;
+    protected markForCheck(): void;
+    /**
+     * Update the route, without reloading the component
+     *
+     * @param data
+     * @param queryParams
+     * @protected
+     */
+    protected updateRoute(data?: T, queryParams?: any): Promise<boolean>;
+    /**
+     * Open the first tab that is invalid
+     */
+    private openFirstInvalidTab;
+    protected abstract computeTitle(data: T): Promise<string>;
+    protected abstract get form(): FormGroup;
+    protected abstract getFirstInvalidTabIndex(): number;
+    protected abstract registerForms(): void;
+    abstract setValue(data: T, opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): Promise<void> | void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppEntityEditor<any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppEntityEditor<any, any, any, any>, never, never, {}, {}, never, never, false, never>;
+}

package/src/app/core/form/entity/entity-metadata.component.d.ts

@@ -0,0 +1,13 @@
+import { Entity } from '../../services/model/entity.model';
+import { Moment } from 'moment';
+import * as i0 from "@angular/core";
+export declare class EntityMetadataComponent {
+    value: Entity<any> & {
+        creationDate?: Date | Moment;
+        recorderDepartment?: any;
+        recorderPerson?: any;
+    };
+    showRecorder: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityMetadataComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityMetadataComponent, "app-entity-metadata", never, { "value": { "alias": "value"; "required": false; }; "showRecorder": { "alias": "showRecorder"; "required": false; }; }, {}, never, ["[recorderSuffix]", "[afterRecorder]", "*"], false, never>;
+}

package/src/app/core/form/entity/entity.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./entity-metadata.component";
+import * as i2 from "../../../shared/shared.module";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "ngx-jdenticon";
+export declare class AppEntityFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppEntityFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppEntityFormModule, [typeof i1.EntityMetadataComponent], [typeof i2.SharedModule, typeof i3.TranslateModule, typeof i4.NgxJdenticonModule], [typeof i3.TranslateModule, typeof i1.EntityMetadataComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppEntityFormModule>;
+}