@sumaris-net/ngx-components 1.2.7 → 1.2.14

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>;
+}

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

@@ -1,25 +1,29 @@
 import { EventEmitter, Injector, OnDestroy, OnInit } from '@angular/core';
-import { FormGroup } from '@angular/forms';
-import { BehaviorSubject, Subscription } from 'rxjs';
+import { UntypedFormGroup } from '@angular/forms';
+import { BehaviorSubject, Subject, Subscription } from 'rxjs';
 import { IAppForm } from './form.utils';
 import { LocalSettingsService } from '../services/local-settings.service';
-import { MatAutocompleteConfigHolder, MatAutocompleteFieldAddOptions, MatAutocompleteFieldConfig } from '../../shared/material/autocomplete/material.autocomplete';
 import { WaitForOptions } from '../../shared/observables';
 import { FormErrorTranslator, FormErrorTranslatorOptions, IFormControlPathTranslator } from '../../shared/validator/form-error-adapter.class';
 import { TranslateService } from '@ngx-translate/core';
+import { MatAutocompleteConfigHolder, MatAutocompleteFieldAddOptions, MatAutocompleteFieldConfig } from '../../shared/material/autocomplete/material.autocomplete.config';
+import * as i0 from "@angular/core";
 export declare abstract class AppForm<T> implements IAppForm, OnInit, OnDestroy, IFormControlPathTranslator {
-    autocompleteHelper: MatAutocompleteConfigHolder;
-    autocompleteFields: {
-        [key: string]: MatAutocompleteFieldConfig;
-    };
-    error: string;
-    protected translate: TranslateService;
-    protected settings: LocalSettingsService;
-    protected errorTranslator: FormErrorTranslator;
+    private _subscription;
+    private _form;
     protected _enable: boolean;
-    protected _$ready: BehaviorSubject<boolean>;
-    protected _$loading: BehaviorSubject<boolean>;
+    protected errorTranslator: FormErrorTranslator;
     protected i18nFieldPrefix: string;
+    protected readonly translate: TranslateService;
+    protected readonly settings: LocalSettingsService;
+    protected readonly destroySubject: Subject<void>;
+    readonly autocompleteHelper: MatAutocompleteConfigHolder;
+    readonly autocompleteFields: {
+        [key: string]: MatAutocompleteFieldConfig;
+    };
+    readonly readySubject: BehaviorSubject<boolean>;
+    readonly loadingSubject: BehaviorSubject<boolean>;
+    readonly errorSubject: BehaviorSubject<string>;
     /**
      *  @deprecated
      */
@@ -28,12 +32,18 @@ export declare abstract class AppForm<T> implements IAppForm, OnInit, OnDestroy,
      *  @deprecated
      */
     protected get _loading(): boolean;
-    private _subscription;
-    private _form;
-    debug: boolean;
-    tabindex: number;
-    errorTranslatorOptions: FormErrorTranslatorOptions;
+    /**
+     *  @deprecated
+     */
+    protected get _$ready(): BehaviorSubject<boolean>;
+    /**
+     *  @deprecated
+     */
+    protected get _$loading(): BehaviorSubject<boolean>;
+    get error(): string;
+    set error(error: string);
     get loading(): boolean;
+    get loaded(): boolean;
     get value(): any;
     set value(data: any);
     get dirty(): boolean;
@@ -41,6 +51,7 @@ export declare abstract class AppForm<T> implements IAppForm, OnInit, OnDestroy,
     get pending(): boolean;
     get valid(): boolean;
     get empty(): boolean;
+    get touched(): boolean;
     get untouched(): boolean;
     get enabled(): boolean;
     get disabled(): boolean;
@@ -52,16 +63,27 @@ export declare abstract class AppForm<T> implements IAppForm, OnInit, OnDestroy,
         onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
-    set form(value: FormGroup);
-    get form(): FormGroup;
+    get destroyed(): boolean;
+    debug: boolean;
+    tabindex: number;
+    errorTranslatorOptions: FormErrorTranslatorOptions;
+    set form(value: UntypedFormGroup);
+    get form(): UntypedFormGroup;
     onCancel: EventEmitter<any>;
     onSubmit: EventEmitter<any>;
-    protected constructor(injector: Injector, form?: FormGroup);
+    protected constructor(injector: Injector, form?: UntypedFormGroup);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    cancel(): void;
-    doSubmit(event: any): void;
-    setForm(form: FormGroup): void;
+    cancel(): Promise<void>;
+    /**
+     *
+     * @param event
+     * @param opts allow to skip validation check, using {checkValid: false}
+     */
+    doSubmit(event: any, opts?: {
+        checkValid?: boolean;
+    }): Promise<void>;
+    setForm(form: UntypedFormGroup): void;
     setValue(data: T, opts?: {
         emitEvent?: boolean;
         onlySelf?: boolean;
@@ -94,11 +116,9 @@ export declare abstract class AppForm<T> implements IAppForm, OnInit, OnDestroy,
         emitEvent?: boolean;
     }): void;
     markAsLoading(opts?: {
-        onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
     markAsLoaded(opts?: {
-        onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
     markAsReady(opts?: {
@@ -111,7 +131,7 @@ export declare abstract class AppForm<T> implements IAppForm, OnInit, OnDestroy,
      */
     ready(opts?: WaitForOptions): Promise<void>;
     /**
-     * Wait form is idle (not loading)
+     * Wait form is not busy (=loaded)
      * @param opts
      */
     waitIdle(opts?: WaitForOptions): Promise<void>;
@@ -120,9 +140,16 @@ export declare abstract class AppForm<T> implements IAppForm, OnInit, OnDestroy,
         emitEvent?: boolean;
     }): void;
     translateControlPath(path: string): any;
-    protected getFormError(form: FormGroup, opts?: FormErrorTranslatorOptions): string;
+    protected getFormError(form: UntypedFormGroup, opts?: FormErrorTranslatorOptions): string;
     protected getI18nFieldName(path: string): string;
-    protected registerSubscription(sub: Subscription): Subscription;
-    protected registerAutocompleteField<T = any, F = any>(fieldName: string, opts?: MatAutocompleteFieldAddOptions<T, F>): MatAutocompleteFieldConfig<T, F>;
+    protected registerSubscription(sub: Subscription): void;
+    protected unregisterSubscription(sub: Subscription): void;
+    protected registerAutocompleteField<E = any, EF = any>(fieldName: string, opts?: MatAutocompleteFieldAddOptions<E, EF>): MatAutocompleteFieldConfig<E, EF>;
+    protected setError(value: string, opts?: {
+        emitEvent?: boolean;
+    }): void;
     protected markForCheck(): void;
+    private setLoading;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppForm<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppForm<any>, never, never, { "debug": "debug"; "tabindex": "tabindex"; "errorTranslatorOptions": "errorTranslatorOptions"; "form": "form"; }, { "onCancel": "onCancel"; "onSubmit": "onSubmit"; }, never, never, false>;
 }

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

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../../shared/shared.module";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "./entity/entity.module";
+import * as i4 from "./list/list.module";
+import * as i5 from "./properties/properties.module";
+import * as i6 from "./text-popover/text-popover.module";
+import * as i7 from "./buttons/form-buttons-bar.module";
+export declare class AppFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppFormModule, never, [typeof i1.SharedModule, typeof i2.TranslateModule, typeof i3.AppEntityFormModule, typeof i4.AppListFormModule, typeof i5.AppPropertiesFormModule, typeof i6.AppTextPopoverModule, typeof i7.AppFormButtonsBarModule], [typeof i2.TranslateModule, typeof i3.AppEntityFormModule, typeof i4.AppListFormModule, typeof i5.AppPropertiesFormModule, typeof i6.AppTextPopoverModule, typeof i7.AppFormButtonsBarModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppFormModule>;
+}

package/src/app/core/form/form.utils.d.ts

@@ -1,7 +1,8 @@
-import { AbstractControl, FormArray, FormBuilder, FormGroup, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { AbstractControl, AbstractControlOptions, UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, ValidatorFn } from '@angular/forms';
 import { Entity } from '../services/model/entity.model';
 import { filterNumberInput, selectInputContent } from '../../shared/inputs';
 import { WaitForOptions } from '../../shared/observables';
+import { addValueInArray, clearValueInArray, copyEntity2Form, disableControls, getControlFromPath, getFormErrors, getFormValueFromEntity, logFormErrors, markAllAsTouched, markAsUntouched, removeValueInArray, resizeArray, updateValueAndValidity, waitIdle, waitWhilePending } from '../../shared/forms';
 export declare type IAppFormGetter = () => IAppForm;
 export declare interface OnReady {
     ngOnReady(): any;
@@ -14,6 +15,8 @@ export interface IAppForm {
     error: string;
     enabled: boolean;
     disabled: boolean;
+    touched: boolean;
+    untouched: boolean;
     empty?: boolean;
     loading?: boolean;
     ready(): Promise<void>;
@@ -70,7 +73,9 @@ export declare class AppNullForm implements IAppForm {
     readonly error: any;
     readonly enabled = false;
     readonly loading = false;
+    readonly touched = false;
     get disabled(): boolean;
+    get untouched(): boolean;
     disable(opts?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
@@ -128,6 +133,8 @@ export declare class AppFormProvider<F extends IAppForm = IAppForm> implements I
     get empty(): boolean;
     get pending(): boolean;
     get loading(): boolean;
+    get touched(): boolean;
+    get untouched(): boolean;
     ready(): Promise<any>;
     waitIdle(opts?: WaitForOptions): Promise<any>;
     disable(opts?: {
@@ -170,6 +177,121 @@ export declare class AppFormProvider<F extends IAppForm = IAppForm> implements I
         emitEvent?: boolean;
     }): any;
 }
+export interface FormArrayHelperOptions {
+    allowEmptyArray: 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 readonly _validators;
+    get allowEmptyArray(): boolean;
+    set allowEmptyArray(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;
+    }): 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;
+}
+export declare class AppFormArray<T extends Entity<T>, C extends AbstractControl> extends UntypedFormArray {
+    private createControl;
+    private equals;
+    private isEmpty;
+    private options?;
+    get allowEmptyArray(): boolean;
+    set allowEmptyArray(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;
+    }): void;
+    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;
+    }): void;
+    removeAt(index: number, options?: {
+        emitEvent: boolean;
+    }): void;
+    clearAt(index: number, options?: {
+        emitEvent: boolean;
+    }): void;
+    isLast(index: number): boolean;
+    removeAllEmpty(): void;
+    protected setAllowEmptyArray(value: boolean): void;
+}
 export declare class AppFormUtils {
     static copyEntity2Form: typeof copyEntity2Form;
     static getFormValueFromEntity: typeof getFormValueFromEntity;
@@ -203,82 +325,6 @@ export declare class AppFormUtils {
     static setCalculatedValue: typeof setCalculatedValue;
     static resetCalculatedValue: typeof resetCalculatedValue;
 }
-/**
- * Fill a form using a source entity
- *
- * @param target
- * @param entity
- * @param opts
- */
-export declare function copyEntity2Form(entity: any, target: FormGroup, opts?: {
-    emitEvent?: boolean;
-    onlySelf?: boolean;
-}): void;
-export declare function getFormValueFromEntity(entity: any | undefined, form: FormGroup): {
-    [key: string]: any;
-};
-/**
- * Transform an entity into a simple object, compatible with the given form
- *
- * @param source an entity (or subentity)
- * @param control
- * @param path
- */
-export declare function adaptValueToControl(source: any | undefined, control: AbstractControl, path?: string): any;
-export declare function logFormErrors(control: AbstractControl, logPrefix?: string, path?: string): void;
-export interface FormErrors {
-    [key: string]: ValidationErrors;
-}
-export declare function getFormErrors(control: AbstractControl, opts?: {
-    controlName?: string;
-    result?: FormErrors;
-    recursive?: boolean;
-}): FormErrors;
-export declare function getControlFromPath(form: FormGroup, path: string): AbstractControl;
-export declare function disableControls(form: FormGroup, paths: string[], opts?: {
-    onlySelf?: boolean;
-    emitEvent?: boolean;
-}): void;
-export declare function addValueInArray(arrayControl: FormArray, createControl: (value?: any) => AbstractControl, equals: (v1: any, v2: any) => boolean, isEmpty: (value: any) => boolean, value: any, options?: {
-    emitEvent: boolean;
-}): boolean;
-export declare function resizeArray(arrayControl: FormArray, createControl: () => AbstractControl, length: number): boolean;
-export declare function removeValueInArray(arrayControl: FormArray, isEmpty: (value: any) => boolean, index: number): boolean;
-export declare function clearValueInArray(arrayControl: FormArray, isEmpty: (value: any) => boolean, index: number): boolean;
-export declare function markAllAsTouched(control: AbstractControl, opts?: {
-    onlySelf?: boolean;
-    emitEvent?: boolean;
-}): void;
-export declare function markFormGroupAsTouched(form: FormGroup, opts?: {
-    onlySelf?: boolean;
-    emitEvent?: boolean;
-}): void;
-export declare function markControlAsTouched(control: AbstractControl, opts?: {
-    onlySelf?: boolean;
-    emitEvent?: boolean;
-}): void;
-export declare function updateValueAndValidity(form: FormGroup, opts?: {
-    onlySelf?: boolean;
-    emitEvent?: boolean;
-}): void;
-export declare function markAsUntouched(form: FormGroup, opts?: {
-    onlySelf?: boolean;
-}): void;
-/**
- * Wait end of async validation (not pending)
- * return false
- */
-export declare function waitWhilePending<T extends IAppForm | {
-    pending: boolean;
-}>(form: T, opts?: WaitForOptions): Promise<void>;
-/**
- * Wait form is idle (not loading). This need to implement IAppForm.loading
- * @param form
- * @param opts
- */
-export declare function waitIdle<T extends IAppForm | {
-    loading: boolean;
-}>(form: T, opts?: WaitForOptions): Promise<void>;
 export declare function isControlHasInput(controls: {
     [key: string]: AbstractControl;
 }, controlName: string): boolean;
@@ -288,40 +334,3 @@ export declare function setCalculatedValue(controls: {
 export declare function resetCalculatedValue(controls: {
     [key: string]: AbstractControl;
 }, controlName: string): void;
-export interface FormArrayHelperOptions {
-    allowEmptyArray: 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: FormBuilder, form: FormGroup, arrayName: string): FormArray;
-    private _allowEmptyArray;
-    private readonly _validators;
-    get allowEmptyArray(): boolean;
-    set allowEmptyArray(value: boolean);
-    get formArray(): FormArray;
-    constructor(_formArray: FormArray, createControl: (value?: T) => C, equals: (v1: T, v2: T) => boolean, isEmpty: (value: T) => boolean, options?: FormArrayHelperOptions);
-    add(value?: T, options?: {
-        emitEvent: boolean;
-    }): boolean;
-    removeAt(index: number): boolean;
-    resize(length: number): boolean;
-    clearAt(index: number): boolean;
-    isLast(index: number): boolean;
-    removeAllEmpty(): void;
-    size(): number;
-    at(index: number): C;
-    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;
-}

package/src/app/core/form/{list.form.d.ts → list/list.form.d.ts}

@@ -1,16 +1,17 @@
 import { ChangeDetectorRef, EventEmitter, Injector, OnInit } from '@angular/core';
-import { AbstractControl, FormArray, FormBuilder, FormGroup, FormGroupDirective } from '@angular/forms';
+import { AbstractControl, UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, FormGroupDirective } from '@angular/forms';
 import { DateAdapter } from '@angular/material/core';
 import { Moment } from 'moment';
-import { LocalSettingsService } from '../services/local-settings.service';
-import { AppForm } from './form.class';
-import { FormArrayHelper, FormArrayHelperOptions } from './form.utils';
+import { LocalSettingsService } from '../../services/local-settings.service';
+import { AppForm } from '../form.class';
+import { FormArrayHelper, FormArrayHelperOptions } from '../form.utils';
 import { SelectionModel } from '@angular/cdk/collections';
 import { Observable } from 'rxjs';
 import { Color } from '@ionic/core';
+import * as i0 from "@angular/core";
 export declare interface ItemButton<T = any> {
     title?: string;
-    click: (event: UIEvent, item: T, index: number) => void;
+    click: (event: Event, item: T, index: number) => void;
     icon: string;
     color?: Color;
     disabled?: Observable<boolean>;
@@ -21,7 +22,7 @@ export declare type AppListFormOptions<T> = FormArrayHelperOptions & {
 };
 export declare class AppListForm<T = any> extends AppForm<T[]> implements OnInit {
     protected injector: Injector;
-    protected formBuilder: FormBuilder;
+    protected formBuilder: UntypedFormBuilder;
     protected dateAdapter: DateAdapter<Moment>;
     protected settings: LocalSettingsService;
     protected cd: ChangeDetectorRef;
@@ -29,15 +30,15 @@ export declare class AppListForm<T = any> extends AppForm<T[]> implements OnInit
     helper: FormArrayHelper<T>;
     selection: SelectionModel<T>;
     formArrayName: string;
-    formArray: FormArray;
+    formArray: UntypedFormArray;
     options: AppListFormOptions<T>;
     displayWithFn: (item: any) => string;
     equalsFn: (v1: T, v2: T) => boolean;
-    onNewItem: EventEmitter<UIEvent>;
+    onNewItem: EventEmitter<Event>;
     selectionChanges: EventEmitter<T[]>;
     set value(data: T[]);
     get value(): T[];
-    get itemControls(): FormGroup[];
+    get itemControls(): UntypedFormGroup[];
     get length(): number;
     get empty(): boolean;
     get touched(): boolean;
@@ -53,7 +54,7 @@ export declare class AppListForm<T = any> extends AppForm<T[]> implements OnInit
     markAllAsTouched(opts?: {
         emitEvent?: boolean;
     }): void;
-    constructor(injector: Injector, formBuilder: FormBuilder, dateAdapter: DateAdapter<Moment>, settings: LocalSettingsService, cd: ChangeDetectorRef, formGroupDir: FormGroupDirective);
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, dateAdapter: DateAdapter<Moment>, settings: LocalSettingsService, cd: ChangeDetectorRef, formGroupDir: FormGroupDirective);
     ngOnInit(): void;
     ngOnDestroy(): void;
     setValue(data: T[] | any): void;
@@ -67,7 +68,7 @@ export declare class AppListForm<T = any> extends AppForm<T[]> implements OnInit
     }): Promise<void>;
     onItemButtonClick(button: ItemButton, event: MouseEvent, item: T, index: number): Promise<void>;
     hasSelection(): boolean;
-    onNewClick(event: UIEvent): void;
+    onNewClick(event: any): void;
     add(value: T, opts?: {
         emitEvent?: boolean;
     }): void;
@@ -75,4 +76,6 @@ export declare class AppListForm<T = any> extends AppForm<T[]> implements OnInit
     displayWith(value: T): string;
     protected createControl(data?: any): AbstractControl;
     protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppListForm<any>, [null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppListForm<any>, "app-list-form", never, { "formArrayName": "formArrayName"; "formArray": "formArray"; "options": "options"; "displayWithFn": "displayWith"; "equalsFn": "equals"; }, { "onNewItem": "onNewItem"; "selectionChanges": "selectionChanges"; }, never, never, false>;
 }

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

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

package/src/app/core/form/properties/properties.form.d.ts

@@ -0,0 +1,43 @@
+import { ChangeDetectorRef, Injector, OnInit } from '@angular/core';
+import { UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, FormGroupDirective } from '@angular/forms';
+import { FormFieldDefinition, FormFieldDefinitionMap } from '../../../shared/form/field.model';
+import { DateAdapter, ThemePalette } from '@angular/material/core';
+import { Moment } from 'moment';
+import { LocalSettingsService } from '../../services/local-settings.service';
+import { AppForm } from '../form.class';
+import { FormArrayHelper, FormArrayHelperOptions } from '../form.utils';
+import { Property } from '../../../shared/types';
+import { PropertyValidator } from './property.validator';
+import { PredefinedColors } from '@ionic/core';
+import * as i0 from "@angular/core";
+export declare class AppPropertiesForm<T = Property> extends AppForm<T[]> implements OnInit {
+    protected formBuilder: UntypedFormBuilder;
+    protected dateAdapter: DateAdapter<Moment>;
+    protected settings: LocalSettingsService;
+    protected cd: ChangeDetectorRef;
+    protected validator: PropertyValidator;
+    private formGroupDir;
+    definitionsMapByKey: FormFieldDefinitionMap;
+    definitionsByIndex: {
+        [index: number]: FormFieldDefinition;
+    };
+    helper: FormArrayHelper<Property>;
+    formArrayName: string;
+    formArray: UntypedFormArray;
+    options: FormArrayHelperOptions;
+    definitions: FormFieldDefinition[];
+    chipColor: ThemePalette | PredefinedColors;
+    set value(data: T[]);
+    get value(): T[];
+    get fieldForms(): UntypedFormGroup[];
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, dateAdapter: DateAdapter<Moment>, settings: LocalSettingsService, cd: ChangeDetectorRef, validator: PropertyValidator, formGroupDir: FormGroupDirective);
+    ngOnInit(): void;
+    getDefinitionAt(index: number): FormFieldDefinition;
+    updateDefinitionAt(index: number): FormFieldDefinition;
+    removeAt(index: number): void;
+    isUnknownField(fieldForm: UntypedFormGroup): boolean;
+    setValue(data: T[] | any): void;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppPropertiesForm<any>, [null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppPropertiesForm<any>, "app-properties-form", never, { "formArrayName": "formArrayName"; "formArray": "formArray"; "options": "options"; "definitions": "definitions"; "chipColor": "chipColor"; }, {}, never, never, false>;
+}

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

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

package/src/app/core/form/properties/property.validator.d.ts

@@ -0,0 +1,13 @@
+import { UntypedFormBuilder } from '@angular/forms';
+import { Property } from '../../../shared/types';
+import { AppValidatorService } from '../../services/validator/base.validator.class';
+import * as i0 from "@angular/core";
+export declare class PropertyValidator extends AppValidatorService<Property> {
+    protected formBuilder: UntypedFormBuilder;
+    constructor(formBuilder: UntypedFormBuilder);
+    getFormGroupConfig(data?: Property): {
+        [p: string]: any;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PropertyValidator, never, never, {}, {}, never, never, false>;
+}

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

@@ -0,0 +1,19 @@
+import { AfterViewInit, OnInit } from '@angular/core';
+import { FormFieldDefinition } from '../../../../shared/form/field.model';
+import { AppPropertiesForm } from '../properties.form';
+import { LoadResult } from '../../../../shared/services/entity-service.class';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class PropertiesFormTestPage implements OnInit, AfterViewInit {
+    protected formBuilder: FormBuilder;
+    propertyDefinitions: FormFieldDefinition[];
+    i18nFieldPrefix: string;
+    form: FormGroup;
+    propertiesForm: AppPropertiesForm;
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    protected suggestEntity(value: any, filter: any): Promise<LoadResult<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertiesFormTestPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PropertiesFormTestPage, "app-properties-form-test", never, {}, {}, never, never, false>;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./properties-form.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 PropertiesFormTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertiesFormTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PropertiesFormTestingModule, [typeof i1.PropertiesFormTestPage], [typeof i2.CommonModule, typeof i3.SharedModule, typeof i4.CoreModule, typeof i5.TranslateModule], [typeof i6.RouterModule, typeof i1.PropertiesFormTestPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PropertiesFormTestingModule>;
+}

package/src/app/core/form/text-popover/testing/text-popover.testing.d.ts

@@ -0,0 +1,10 @@
+import { PopoverController } from '@ionic/angular';
+import { TextPopoverOptions } from '../text-popover.component';
+import * as i0 from "@angular/core";
+export declare class TextPopoverTestingPage {
+    private popoverController;
+    constructor(popoverController: PopoverController);
+    showPopover(event: Event, opts?: Partial<TextPopoverOptions>): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextPopoverTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextPopoverTestingPage, "text-popover-testing", never, {}, {}, never, never, false>;
+}