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

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

@@ -0,0 +1,336 @@
+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;
+}
+export interface IAppForm {
+    invalid: boolean;
+    valid: boolean;
+    dirty: boolean;
+    pending: boolean;
+    error: string;
+    enabled: boolean;
+    disabled: boolean;
+    touched: boolean;
+    untouched: boolean;
+    empty?: boolean;
+    loading?: boolean;
+    ready(): Promise<void>;
+    waitIdle(opts?: WaitForOptions): Promise<any>;
+    disable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    enable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsPristine(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsUntouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsTouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAllAsTouched(opts?: {
+        emitEvent?: boolean;
+    }): any;
+    markAsDirty(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsLoading(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsLoaded(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsReady(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+}
+/**
+ * A form that do nothing
+ */
+export declare class AppNullForm implements IAppForm {
+    readonly invalid = false;
+    readonly valid = false;
+    readonly dirty = false;
+    readonly empty = true;
+    readonly pending = false;
+    readonly error: any;
+    readonly enabled = false;
+    readonly loading = false;
+    readonly touched = false;
+    get disabled(): boolean;
+    get untouched(): boolean;
+    disable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    enable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsPristine(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsUntouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsTouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAllAsTouched(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsDirty(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsLoading(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsLoaded(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsReady(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    waitIdle(opts?: WaitForOptions): Promise<any>;
+    ready(): Promise<any>;
+}
+export declare class AppFormProvider<F extends IAppForm = IAppForm> implements IAppForm {
+    private getterFn;
+    static NULL_FORM: AppNullForm;
+    constructor(getterFn: () => F);
+    private get delegate();
+    waitDelegate(opts?: WaitForOptions): Promise<F>;
+    get enabled(): boolean;
+    get disabled(): boolean;
+    get error(): string;
+    get invalid(): boolean;
+    get valid(): boolean;
+    get dirty(): boolean;
+    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?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    enable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsPristine(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsUntouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsTouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAllAsTouched(opts?: {
+        emitEvent?: boolean;
+    }): any;
+    markAsDirty(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsLoading(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsLoaded(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): any;
+    markAsReady(opts?: {
+        onlySelf?: boolean;
+        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;
+    static logFormErrors: typeof logFormErrors;
+    static getControlFromPath: typeof getControlFromPath;
+    static filterNumberInput: typeof filterNumberInput;
+    static disableControls: typeof disableControls;
+    static selectInputContent: typeof selectInputContent;
+    /**
+     * @deprecated use markAllAsTouched() instead (naming was wrong)
+     */
+    static markAsTouched: typeof markAllAsTouched;
+    /**
+     * Marks the control and all its descendant controls as touched.
+     * See also:
+     * - `markAsTouched()`
+     */
+    static markAllAsTouched: typeof markAllAsTouched;
+    static markAsUntouched: typeof markAsUntouched;
+    static waitWhilePending: typeof waitWhilePending;
+    static waitIdle: typeof waitIdle;
+    static updateValueAndValidity: typeof updateValueAndValidity;
+    static getFormErrors: typeof getFormErrors;
+    static isForm(object: any): object is IAppForm;
+    static addValueInArray: typeof addValueInArray;
+    static removeValueInArray: typeof removeValueInArray;
+    static resizeArray: typeof resizeArray;
+    static clearValueInArray: typeof clearValueInArray;
+    static calculatedSuffix: string;
+    static isControlHasInput: typeof isControlHasInput;
+    static setCalculatedValue: typeof setCalculatedValue;
+    static resetCalculatedValue: typeof resetCalculatedValue;
+}
+export declare function isControlHasInput(controls: {
+    [key: string]: AbstractControl;
+}, controlName: string): boolean;
+export declare function setCalculatedValue(controls: {
+    [key: string]: AbstractControl;
+}, controlName: string, value: number | undefined): void;
+export declare function resetCalculatedValue(controls: {
+    [key: string]: AbstractControl;
+}, controlName: string): void;

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

@@ -0,0 +1,81 @@
+import { ChangeDetectorRef, EventEmitter, Injector, OnInit } from '@angular/core';
+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 { 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: Event, item: T, index: number) => void;
+    icon: string;
+    color?: Color;
+    disabled?: Observable<boolean>;
+}
+export declare type AppListFormOptions<T> = FormArrayHelperOptions & {
+    allowMultipleSelection?: boolean;
+    buttons?: ItemButton<T>[];
+};
+export declare class AppListForm<T = any> extends AppForm<T[]> implements OnInit {
+    protected injector: Injector;
+    protected formBuilder: UntypedFormBuilder;
+    protected dateAdapter: DateAdapter<Moment>;
+    protected settings: LocalSettingsService;
+    protected cd: ChangeDetectorRef;
+    private formGroupDir;
+    helper: FormArrayHelper<T>;
+    selection: SelectionModel<T>;
+    formArrayName: string;
+    formArray: UntypedFormArray;
+    options: AppListFormOptions<T>;
+    displayWithFn: (item: any) => string;
+    equalsFn: (v1: T, v2: T) => boolean;
+    onNewItem: EventEmitter<Event>;
+    selectionChanges: EventEmitter<T[]>;
+    set value(data: T[]);
+    get value(): T[];
+    get itemControls(): UntypedFormGroup[];
+    get length(): number;
+    get empty(): boolean;
+    get touched(): boolean;
+    get untouched(): boolean;
+    get dirty(): boolean;
+    get invalid(): boolean;
+    get valid(): boolean;
+    get pending(): boolean;
+    markAsTouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAllAsTouched(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, dateAdapter: DateAdapter<Moment>, settings: LocalSettingsService, cd: ChangeDetectorRef, formGroupDir: FormGroupDirective);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    setValue(data: T[] | any): void;
+    /** Whether the number of selected elements matches the total number of rows. */
+    isAllSelected(): boolean;
+    masterToggle(opts?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    onItemClick(event: MouseEvent, item: T, opts?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    onItemButtonClick(button: ItemButton, event: MouseEvent, item: T, index: number): Promise<void>;
+    hasSelection(): boolean;
+    onNewClick(event: any): void;
+    add(value: T, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    removeAt(index: number): void;
+    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,44 @@
+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 length(): number;
+    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,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./properties.form";
+import * as i2 from "./properties.table";
+import * as i3 from "../../../shared/shared.module";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "../../table/table.module";
+export declare class AppPropertiesFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppPropertiesFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppPropertiesFormModule, [typeof i1.AppPropertiesForm, typeof i2.AppPropertiesTable], [typeof i3.SharedModule, typeof i4.TranslateModule, typeof i5.AppTableModule], [typeof i4.TranslateModule, typeof i1.AppPropertiesForm, typeof i2.AppPropertiesTable]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppPropertiesFormModule>;
+}

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

@@ -0,0 +1,78 @@
+import { AppInMemoryTable } from '../../table/memory-table.class';
+import { Injector, OnInit } from '@angular/core';
+import { Entity, EntityAsObjectOptions } from '../../services/model/entity.model';
+import { AppValidatorService } from '../../services/validator/base.validator.class';
+import { AbstractControl, UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import { FormFieldDefinition, FormFieldDefinitionMap } from '../../../shared/form/field.model';
+import { FilterFn } from '../../../shared/services/entity-service.class';
+import { Environment } from '../../../../environments/environment.class';
+import { TableElement } from '@e-is/ngx-material-table';
+import { EntityFilter } from '../../services/model/filter.model';
+import { ObjectMap } from '../../../shared/types';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import * as i0 from "@angular/core";
+interface TranslatedFormFieldDefinition extends FormFieldDefinition {
+    translatedName?: string;
+}
+export declare class PropertyEntity extends Entity<PropertyEntity, string> {
+    static fromObject: (source: any, opts?: any) => PropertyEntity;
+    definition: TranslatedFormFieldDefinition;
+    value: any;
+    fromObject(source: any): void;
+    asObject(opts?: EntityAsObjectOptions): any;
+}
+export declare class PropertyEntityFilter extends EntityFilter<PropertyEntityFilter, PropertyEntity> {
+    static fromObject: (source: any, opts?: any) => PropertyEntityFilter;
+    searchText: string;
+    notDefaultOnly: boolean;
+    fromObject(source: any): void;
+    asObject(opts?: EntityAsObjectOptions): any;
+    protected buildFilter(): FilterFn<PropertyEntity>[];
+    protected isCriteriaNotEmpty(key: string, value: any): boolean;
+}
+export declare class PropertyEntityValidator extends AppValidatorService<PropertyEntity> {
+    protected formBuilder: UntypedFormBuilder;
+    constructor(formBuilder: UntypedFormBuilder);
+    getFormGroupConfig(data?: PropertyEntity): {
+        [p: string]: any;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyEntityValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PropertyEntityValidator, never, never, {}, {}, never, never, false>;
+}
+export declare class AppPropertiesTable extends AppInMemoryTable<PropertyEntity, PropertyEntityFilter, string> implements OnInit {
+    protected injector: Injector;
+    protected formBuilder: UntypedFormBuilder;
+    protected validatorService: PropertyEntityValidator;
+    definitions: FormFieldDefinition[];
+    showToolbar: boolean;
+    filterExpansionPanel: MatExpansionPanel;
+    definitionsMapByKey: FormFieldDefinitionMap;
+    translationsByKey: ObjectMap<string>;
+    filterForm: UntypedFormGroup;
+    filterCriteriaCount: number;
+    filterPanelFloating: boolean;
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, validatorService: PropertyEntityValidator, environment: Environment);
+    ngOnInit(): void;
+    get value(): PropertyEntity[];
+    set value(data: PropertyEntity[]);
+    setValue(value: PropertyEntity[], opts?: {
+        emitEvent?: boolean;
+    }): void;
+    clearControlValue(event: Event, formControl: AbstractControl): boolean;
+    resetFilter(value?: any, opts?: {
+        emitEvent: boolean;
+    }): void;
+    setFilter(filter: PropertyEntityFilter, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    get filterIsEmpty(): boolean;
+    toggleFilterPanelFloating(): void;
+    closeFilterPanel(): void;
+    applyFilterAndClosePanel(event?: Event): void;
+    toTranslatedFormFieldDefinition: (definition: FormFieldDefinition) => TranslatedFormFieldDefinition;
+    resetProperty(event: UIEvent, row: TableElement<PropertyEntity>): void;
+    protected toValue(values: PropertyEntity[], definition: FormFieldDefinition): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppPropertiesTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppPropertiesTable, "app-properties-table", never, { "definitions": "definitions"; "showToolbar": "showToolbar"; }, {}, never, never, false>;
+}
+export {};

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,14 @@
+import { PopoverController, ToastController } from '@ionic/angular';
+import { TextPopoverOptions } from '../text-popover.component';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export declare class TextPopoverTestingPage {
+    private popoverController;
+    private toastController;
+    private translate;
+    constructor(popoverController: PopoverController, toastController: ToastController, translate: TranslateService);
+    showPopover(event: Event, opts?: Partial<TextPopoverOptions>): Promise<void>;
+    protected showSharePopoverWithButtons(event: UIEvent, opts?: Partial<TextPopoverOptions>): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextPopoverTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextPopoverTestingPage, "text-popover-testing", never, {}, {}, never, never, false>;
+}

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

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./text-popover.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 TextPopoverTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextPopoverTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TextPopoverTestingModule, [typeof i1.TextPopoverTestingPage], [typeof i2.CommonModule, typeof i3.IonicModule, typeof i4.TranslateModule, typeof i5.RouterModule], [typeof i5.RouterModule, typeof i1.TextPopoverTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TextPopoverTestingModule>;
+}

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

@@ -0,0 +1,32 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, Injector, OnInit } from '@angular/core';
+import { UntypedFormBuilder, UntypedFormControl, ValidatorFn } from '@angular/forms';
+import { CdkTextareaAutosize } from '@angular/cdk/text-field';
+import { AppForm } from '../form.class';
+import * as i0 from "@angular/core";
+export declare class TextForm extends AppForm<{
+    text: string;
+}> implements OnInit {
+    protected injector: Injector;
+    protected cd: ChangeDetectorRef;
+    protected formBuilder: UntypedFormBuilder;
+    showError: boolean;
+    placeholder: string;
+    multiline: boolean;
+    autoHeight: boolean;
+    maxLength: number;
+    autofocus: boolean;
+    validator: ValidatorFn;
+    textAreaChanges: EventEmitter<string>;
+    textArea: ElementRef;
+    textInput: ElementRef;
+    autosizeDirective: CdkTextareaAutosize;
+    control: UntypedFormControl;
+    constructor(injector: Injector, cd: ChangeDetectorRef, formBuilder: UntypedFormBuilder);
+    ngOnInit(): void;
+    textAreaChanged(event: KeyboardEvent): void;
+    containerResize(): void;
+    focusInput(): void;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextForm, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextForm, "app-text-form", never, { "showError": "showError"; "placeholder": "placeholder"; "multiline": "multiline"; "autoHeight": "autoHeight"; "maxLength": "maxLength"; "autofocus": "autofocus"; "validator": "validator"; }, { "textAreaChanges": "textAreaChanges"; }, never, never, false>;
+}