@sumaris-net/ngx-components 18.12.0 → 18.12.2

package/src/app/shared/directives/resizable/resizable.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@angular/core';
+import { MatColumnDef } from '@angular/material/table';
+import * as i0 from "@angular/core";
+export declare class ResizableComponent {
+    readonly columnDef: MatColumnDef;
+    resizable: boolean;
+    sizeChanged: EventEmitter<number>;
+    width: string | null;
+    minWidth: string | null;
+    maxWidth: string | null;
+    private debug;
+    constructor(columnDef: MatColumnDef);
+    onResize(width: number, opts?: {
+        emitEvent: boolean;
+    }): void;
+    onFit(opts?: {
+        emitEvent: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResizableComponent, "th[resizable]", never, { "resizable": { "alias": "resizable"; "required": false; }; }, { "sizeChanged": "sizeChanged"; }, never, ["*"], false, never>;
+}

package/src/app/shared/directives/resizable/resizable.directive.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ResizableDirective {
+    private readonly document;
+    private readonly elementRef;
+    readonly resizable: Observable<number>;
+    readonly fit: Observable<MouseEvent[]>;
+    constructor(document: any, elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableDirective, "[resizable]", never, {}, { "resizable": "resizable"; "fit": "fit"; }, never, never, false, never>;
+}

package/src/app/shared/directives/resizable/resizable.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./resizable.component";
+import * as i2 from "./resizable.directive";
+export declare class ResizableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ResizableModule, [typeof i1.ResizableComponent, typeof i2.ResizableDirective], never, [typeof i1.ResizableComponent, typeof i2.ResizableDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ResizableModule>;
+}

package/src/app/shared/directives/throttled-click.directive.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ThrottledClickDirective implements OnInit, OnDestroy {
+    throttleTime: number;
+    throttledClick: EventEmitter<UIEvent>;
+    private clicks;
+    private subscription;
+    constructor();
+    clickEvent(event: UIEvent): void;
+    ngOnInit(): void;
+    emitThrottledClick(e: UIEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThrottledClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThrottledClickDirective, "[appPreventDoubleClick],[throttledClick]", never, { "throttleTime": { "alias": "throttleTime"; "required": false; }; }, { "throttledClick": "throttledClick"; }, never, never, false, never>;
+    static ngAcceptInputType_throttleTime: unknown;
+}

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

@@ -0,0 +1,29 @@
+import { EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+export interface PromiseEventPayload<R = any> {
+    success: (value?: R) => void;
+    error: (reason?: any) => void;
+}
+export type PromiseEvent<R = any, D = void> = CustomEvent<PromiseEventPayload<R> & D>;
+export declare function createPromiseEventEmitter<R = any, D = void>(): EventEmitter<PromiseEvent<R, D>>;
+export declare function createPromiseEvent<T = void, D = void>(eventType: string, promise: PromiseEventPayload<T>, initArg?: CustomEventInit<D>): PromiseEvent<T, D>;
+export declare function emitPromiseEvent<R = any, D = void>(emitter: EventEmitter<PromiseEvent<R, D>>, eventType: string, initArg?: CustomEventInit<D>): Promise<R>;
+export interface CompletableEvent extends Event {
+    target: EventTarget & {
+        complete?: () => void;
+    };
+}
+/**
+ * Listen end of scroll.
+ * <p>
+ *   The threshold distance from the bottom of the content to call the infinite output event when scrolled.
+ *   The threshold value can be either a percent, or in pixels.
+ *   For example, use the value of 10% for the infinite output event to get called when the user has scrolled
+ *   10% from the bottom of the page. Use the value 100px when the scroll is within 100 pixels from the bottom of the page.
+ * </p>
+ *
+ * @param element
+ * @param threshold default to '15%'
+ * @param dueTime
+ */
+export declare function fromScrollEndEvent(element: HTMLElement, threshold?: string, dueTime?: number): Observable<any>;

package/src/app/shared/file/csv.utils.d.ts

@@ -0,0 +1,30 @@
+import { Observable } from 'rxjs';
+import { FileEvent } from '../upload-file/upload-file.model';
+import { TranslateService } from '@ngx-translate/core';
+import { DisplayFn } from '../form/field.model';
+export declare class CsvUtils {
+    static DEFAULT_SEPARATOR: string;
+    static DEFAULT_ENCODING: string;
+    static exportToFile(rows: object[], opts?: {
+        filename?: string;
+        headers?: string[];
+        includedProperties?: string[];
+        excludedProperties?: string[];
+        formatters?: {
+            [key: string]: DisplayFn;
+        };
+        separator?: string;
+        encoding?: string;
+        type?: string;
+    }): void;
+    static parseFile(file: File, opts?: {
+        separator?: string;
+        encoding?: string;
+    }): Observable<FileEvent<string[][]>>;
+    static parseCSV(body: string, opts?: {
+        separator?: string;
+        skipEmptyLine?: boolean;
+    }): string[][];
+    static getLocalizedSeparator(translate?: TranslateService, defaultSeparator?: string): string;
+    static getLocalizedEncoding(translate: TranslateService, defaultEncoding?: string): string;
+}

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

@@ -0,0 +1,23 @@
+import { Platform } from '@ionic/angular';
+import { ImageResizeOptions } from './images.utils';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class FileService {
+    private platform;
+    private http;
+    protected environment: any;
+    private readonly _debug;
+    private _started;
+    private _imageDirectory;
+    get canUseFileSystem(): boolean;
+    constructor(platform: Platform, http: HttpClient, environment: any);
+    getImages(sources: string[], opts?: ImageResizeOptions & {
+        outputType?: 'fileUrl' | 'dataUrl';
+    }): Promise<string[]>;
+    getImage(fileUrl: string, opts?: ImageResizeOptions & {
+        outputType?: 'fileUrl' | 'dataUrl';
+    }): Promise<string>;
+    protected start(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileService>;
+}

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

@@ -0,0 +1,20 @@
+import { FileEvent, UploadFile } from '../upload-file/upload-file.model';
+import { UploadFilePopoverOptions } from '../upload-file/upload-file-popover.component';
+import { PopoverController } from '@ionic/angular';
+import { Observable } from 'rxjs';
+import { OverlayEventDetail } from '@ionic/core';
+export declare const MimeTypes: Readonly<{
+    ANDROID_APK: "application/vnd.android.package-archive";
+}>;
+export declare class FilesUtils {
+    static UTF8_BOM_CHAR: Uint8Array;
+    static showUploadPopover<T>(popoverController: PopoverController, event: Event, opts: UploadFilePopoverOptions<T>): Promise<OverlayEventDetail<UploadFile<T>[]>>;
+    static readAsText(file: File, encoding?: string): Observable<FileEvent<string>>;
+    static writeTextToFile(content: string, opts?: {
+        filename?: string;
+        encoding?: string;
+        type?: string;
+    }): void;
+    static downloadUri(uri: string, filename?: string): void;
+    static getFilenameFromUri(uri: string): string;
+}

package/src/app/shared/file/images.utils.d.ts

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import { FileEvent } from '../upload-file/upload-file.model';
+export declare const IMAGE_DEFAULTS: {
+    MAX_HEIGHT: number;
+    MAX_WIDTH: number;
+    THUMB_MAX_HEIGHT: number;
+    THUMB_MAX_WIDTH: number;
+};
+export declare interface ImageResizeOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    thumbnail?: boolean;
+}
+export declare class ImagesUtils {
+    /**
+     * Parse a string like `<path>|<credit>` into an object `{image, credit}`
+     * @param file
+     **/
+    static getImageAndCredit(file: string): {
+        image: string;
+        credits: string;
+    };
+    /**
+     * @param files
+     * @deprecated Use getRandomImageWithCredit() instead
+     **/
+    static getRandomImage(files: string[]): string | undefined;
+    static getRandomImageWithCredit(files: string[]): {
+        image: string;
+        credits: string;
+    };
+    static readAsDataURL(file: File, opts?: ImageResizeOptions): Observable<FileEvent<string>>;
+    static readAndResizeFromUrl(fileUrl: string, opts?: ImageResizeOptions): Promise<string>;
+    static resizeBase64(dataUrl: string, opts?: ImageResizeOptions): Promise<string>;
+    protected static createImageOnLoadResizeFn(resolve: any, reject: any, opts?: ImageResizeOptions): (event: any) => void;
+}

package/src/app/shared/file/json.utils.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { FileEvent } from '../upload-file/upload-file.model';
+import { TranslateService } from '@ngx-translate/core';
+export declare class JsonUtils {
+    static DEFAULT_ENCODING: string;
+    static exportToFile(content: any, opts?: {
+        filename?: string;
+        encoding?: string;
+        type?: string;
+    }): void;
+    static writeToFile(content: any, opts?: {
+        filename?: string;
+        type?: string;
+    }): File;
+    static parseFile<T = any>(file: File, opts?: {
+        encoding?: string;
+    }): Observable<FileEvent<T>>;
+    static getLocalizedEncoding(translate: TranslateService, defaultEncoding?: string): string;
+}

package/src/app/shared/file/uri.utils.d.ts

@@ -0,0 +1,8 @@
+export declare class UriUtils {
+    /**
+     * Extract the filename, from an uri (using the last slash)
+     *
+     * @param uri
+     */
+    static getFilename(uri: string): string;
+}

package/src/app/shared/file/url.utils.d.ts

@@ -0,0 +1,77 @@
+export declare abstract class UrlUtils {
+    /**
+     * Determines if a given URL is a relative URL.
+     *
+     * @param {string | null} href - The URL to check.
+     * @return {boolean} True if the URL is relative, false otherwise.
+     */
+    static isRelativeUrl(href: string | null): boolean;
+    /**
+     * Determines if a given URL is an internal URL.
+     *
+     * @param {string | null} href - The URL to be checked. Can be a string representing the URL or null.
+     * @return {boolean} Returns true if the URL is internal, otherwise false.
+     */
+    static isInternalUrl(href: string | null): boolean;
+    static isExternalUrl(href: string | null): boolean;
+    /**
+     * Removes the query string from the given URL, returning only the base URL.
+     *
+     * @param {string} url - The URL from which the query string will be stripped.
+     * @return {string} The URL without the query string.
+     */
+    static stripQuery(url: string): string;
+    /**
+     * Removes the fragment and query components from a given URL string.
+     *
+     * @param {string} url - The URL string to process.
+     * @return {string} The URL without its fragment and query components.
+     */
+    static stripFragmentAndQuery(url: string): string;
+    /**
+     * Extracts the fragment identifier from the given URL.
+     *
+     * @param {string} url - The URL from which to extract the fragment.
+     * @return {string} The fragment identifier of the URL, excluding the '#' symbol.
+     */
+    static getFragment(url: string): string;
+    static resolveRelativeUrl(baseUrl: string, relativePath: string, opts?: {
+        absoluteByDefault: boolean;
+    }): string;
+    /**
+     * Resolves a given URL by normalizing its parts, removing unnecessary path segments like "." and "..".
+     *
+     * @param {string} url - The URL to be resolved. Must be a non-empty string.
+     * @return {string} The resolved and cleaned URL string.
+     * @throws {Error} If the provided URL is missing or undefined.
+     */
+    static normalizeUrl(url: string): string;
+    /**
+     * Extracts and returns the root URL from the given complete URL string.
+     *
+     * @param {string} url - The complete URL string from which the root URL will be extracted.
+     * @return {string} The root URL including the protocol and host (and port if present).
+     * @throws {Error} Throws an error if the provided URL is missing or is in an invalid format.
+     */
+    static getRootUrl(url: string): string;
+    /**
+     * Retrieves the parent URL or directory path from the provided URL.
+     * This method handles both relative and absolute URLs.
+     *
+     * @param {string} url - The URL from which to derive the parent path.
+     *                       Must be a valid URL or relative path.
+     * @return {string} The parent URL or directory path. Throws an error if the input is invalid.
+     */
+    static getParent(url: string): string;
+    /**
+     * Cleans the provided URL by encoding it safely and replacing specific patterns.
+     *
+     * @param {string} href - The URL string to be cleaned.
+     * @return {string|null} The cleaned and encoded URL string, or null if an error occurs.
+     */
+    static cleanUrl(href: string): string;
+    static addTrailingSlash(url: string): string;
+    static addStartingSlash(url: string): string;
+    static removeStartingSlash(url: string): string;
+    static concat(basePath: string, relativePath: string): string;
+}

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

@@ -0,0 +1,4 @@
+export interface FocusableElement {
+    focus(): any;
+}
+export declare function isFocusableElement(object: any): object is FocusableElement;

package/src/app/shared/form/field.component.d.ts

@@ -0,0 +1,85 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, Injector, OnInit } from '@angular/core';
+import { ControlValueAccessor, FormGroupDirective, UntypedFormControl } from '@angular/forms';
+import { AppFloatLabelType, DisplayFn, FormFieldDefinition, FormFieldType } from './field.model';
+import { TranslateService } from '@ngx-translate/core';
+import { filterNumberInput, selectInputContentFromEvent } from '../inputs';
+import { Property } from '../types';
+import { ThemePalette } from '@angular/material/core';
+import { PredefinedColors } from '@ionic/core';
+import { MatAutocompleteField } from '../material/autocomplete/material.autocomplete';
+import { MatFormFieldAppearance, SubscriptSizing } from '@angular/material/form-field';
+import * as i0 from "@angular/core";
+export declare class AppFormField implements OnInit, ControlValueAccessor {
+    protected translate: TranslateService;
+    protected cd: ChangeDetectorRef;
+    protected injector: Injector;
+    private formGroupDir;
+    private _onChangeCallback;
+    private _onTouchedCallback;
+    private _definition;
+    protected _values: Property[];
+    protected type: FormFieldType;
+    protected numberInputStep: string;
+    set definition(value: FormFieldDefinition);
+    get definition(): FormFieldDefinition;
+    readonly: boolean;
+    disabled: boolean;
+    formControl: UntypedFormControl;
+    formControlName: string;
+    placeholder: string;
+    compact: boolean;
+    required: boolean;
+    hideRequiredMarker: boolean;
+    floatLabel: AppFloatLabelType;
+    label: string;
+    appearance: MatFormFieldAppearance;
+    subscriptSizing: SubscriptSizing;
+    tabindex: number;
+    autofocus: boolean;
+    clearable: boolean;
+    chipColor: ThemePalette | PredefinedColors;
+    classList: string;
+    debug: boolean;
+    panelClass: string;
+    panelWidth: string;
+    onKeyupEnter: EventEmitter<any>;
+    get value(): any;
+    matInput: ElementRef;
+    autocompleteField: MatAutocompleteField;
+    constructor(translate: TranslateService, cd: ChangeDetectorRef, injector: Injector, formGroupDir: FormGroupDirective);
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    markAsTouched(): void;
+    filterAlphanumericalInput(event: KeyboardEvent): void;
+    focus(): void;
+    filterNumberInput: typeof filterNumberInput;
+    selectInputContentFromEvent: typeof selectInputContentFromEvent;
+    getDisplayValueFn(definition: FormFieldDefinition): DisplayFn;
+    getColorContrast(color: string): string | undefined;
+    /**
+     * Allow to reload values, if not detected
+     *
+     * @param value
+     */
+    reloadItems(value?: any): void;
+    protected computeNumberInputStep(definition: FormFieldDefinition): string;
+    protected checkAndResolveFormControl(): void;
+    protected _onDefinitionChanged(definition: FormFieldDefinition, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected updateTabIndex(timeout?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppFormField, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppFormField, "app-form-field", never, { "definition": { "alias": "definition"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "formControl": { "alias": "formControl"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hideRequiredMarker": { "alias": "hideRequiredMarker"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "label": { "alias": "label"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "subscriptSizing": { "alias": "subscriptSizing"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "chipColor": { "alias": "chipColor"; "required": false; }; "classList": { "alias": "class"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "panelWidth": { "alias": "panelWidth"; "required": false; }; }, { "onKeyupEnter": "keyup.enter"; }, never, ["[matSuffix]", "[matSuffix]", "[matSuffix]", "[matSuffix]", "[matSuffix]", "[matSuffix]", "[matPrefix]", "[matSuffix]", "[matSuffix]", "[matPrefix]", "[matSuffix]", "[matPrefix]", "[matSuffix]", "[matSuffix]"], false, never>;
+    static ngAcceptInputType_readonly: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_compact: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_hideRequiredMarker: unknown;
+    static ngAcceptInputType_tabindex: unknown;
+    static ngAcceptInputType_autofocus: unknown;
+    static ngAcceptInputType_clearable: unknown;
+    static ngAcceptInputType_debug: unknown;
+}

package/src/app/shared/form/field.model.d.ts

@@ -0,0 +1,82 @@
+import { ObjectMap, Property } from '../types';
+import { InjectionToken, Injector } from '@angular/core';
+import { MatAutocompleteFieldConfig } from '../material/autocomplete/material.autocomplete.config';
+import { UserProfileLabel } from '../../core/services/model/person.model';
+import { FloatLabelType } from '@angular/material/form-field';
+export declare type DisplayFn = (obj: any) => string;
+export declare type EqualsFn = (o1: any, o2: any) => boolean;
+export declare type CompareFn = (o1: any, o2: any) => number;
+export declare type FormFieldType = 'integer' | 'double' | 'boolean' | 'string' | 'enum' | 'enums' | 'color' | 'peer' | 'entity' | 'entities' | 'date' | 'dateTime';
+export declare type AppFloatLabelType = FloatLabelType | 'never';
+export declare interface FormFieldDefinition<K = string, T = FormFieldType, E = any> {
+    key: K;
+    type: T;
+    label: string;
+    minValue?: number;
+    maxValue?: number;
+    maximumNumberDecimals?: number;
+    defaultValue?: any;
+    isTransient?: boolean;
+    values?: (string | Property)[] | InjectionToken<(string | Property)[]>;
+    autocomplete?: MatAutocompleteFieldConfig<E>;
+    disabled?: boolean;
+    required?: boolean;
+    extra?: {
+        [key: string]: {
+            disabled?: boolean;
+            required: boolean;
+        };
+    };
+    minProfile?: UserProfileLabel;
+    /**
+     * Use for automatic serialization/deserialization to/from string (eg. using the autocomplete suggestFn).
+     * Default value: 'id'
+     */
+    serializeAttribute?: string;
+    /**
+     * Use to serialize an entity into string (see AppPropertiesUtils.***asObject())
+     * @param value
+     */
+    serialize?: (value: E) => string;
+    /**
+     * Use to deserialize a string into an entity (see AppPropertiesUtils.***fromObject())
+     * @param value
+     */
+    deserialize?: (value: string) => E | Promise<E>;
+}
+export declare type FormFieldDefinitionMap = ObjectMap<FormFieldDefinition>;
+export declare class FormFieldDefinitionUtils {
+    /**
+     * Prepares an array of form field definitions by using the specified injector to process each definition.
+     *
+     * @param {Injector} injector - The injector used to process each form field definition.
+     * @param {FormFieldDefinition[]} defs - An array of form field definitions to be prepared.
+     * @return {FormFieldDefinition[]} An array of prepared form field definitions.
+     */
+    static prepareDefinitions(injector: Injector, defs: FormFieldDefinition[]): FormFieldDefinition[];
+    /**
+     * Prepares the definition by processing its type and optionally setting the values property.
+     *
+     * @param {Injector} injector - The injector used to get the necessary services.
+     * @param {FormFieldDefinition} def - The form field definition to be prepared.
+     * @return {FormFieldDefinition} - The prepared form field definition with updated values if the type is 'enum' or 'enums'.
+     */
+    static prepareDefinition(injector: Injector, def: FormFieldDefinition): FormFieldDefinition;
+    /**
+     * Retrieves an array of Property objects from the provided enum values.
+     *
+     * @param {Injector} injector - The Angular injector to resolve the InjectionToken.
+     * @param {(string | Property)[] | InjectionToken<(string | Property)[]>} enumValues - The enum values, which can be an array of strings, array of Property objects, or an InjectionToken that resolves to such an array.
+     * @return {Property[]} An array of Property objects.
+     */
+    static getEnumValues(injector: Injector, enumValues: (string | Property)[] | InjectionToken<(string | Property)[]>): Property[];
+    static getDisplayValueFn(definition: FormFieldDefinition): DisplayFn;
+    private static asPropertyArray;
+}
+export declare abstract class FormFieldValuesHolder {
+    getAsBoolean(data: ObjectMap, definition: FormFieldDefinition): boolean;
+    getAsInt(data: any, definition: FormFieldDefinition): number;
+    getAsNumbers(data: any, definition: FormFieldDefinition): number[];
+    getAsStrings(data: any, definition: FormFieldDefinition): string[];
+    get<T = string>(data: any, definition: FormFieldDefinition): T;
+}

package/src/app/shared/form/loading-spinner.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class AppLoadingSpinner {
+    loading: boolean;
+    color: string | undefined;
+    name: 'bubbles' | 'circles' | 'circular' | 'crescent' | 'dots' | 'lines' | 'lines-small' | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppLoadingSpinner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppLoadingSpinner, "app-loading-spinner", never, { "loading": { "alias": "loading"; "required": false; }; "color": { "alias": "color"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

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

@@ -0,0 +1,135 @@
+import { AbstractControl, UntypedFormArray, UntypedFormGroup, ValidationErrors } from '@angular/forms';
+import { WaitForOptions } from './observables';
+import { Predicate } from '@angular/core';
+export interface FormErrors {
+    [key: string]: ValidationErrors;
+}
+/**
+ * Fill a form using a source entity
+ *
+ * @param target
+ * @param entity
+ * @param opts
+ */
+export declare function copyEntity2Form(entity: any, target: UntypedFormGroup, opts?: {
+    emitEvent?: boolean;
+    onlySelf?: boolean;
+}): void;
+export declare function getFormValueFromEntity(entity: any | undefined, form: UntypedFormGroup): {
+    [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 declare function getFormErrors(control: AbstractControl, opts?: {
+    controlName?: string;
+    result?: FormErrors;
+    recursive?: boolean;
+}): FormErrors;
+export declare function getControlFromPath(form: UntypedFormGroup, path: string): AbstractControl;
+export declare function disableControls(form: UntypedFormGroup, paths: string[], opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function disableAndClearControls(form: UntypedFormGroup, paths: string[], opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function enableControls(form: UntypedFormGroup, paths: string[], opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function setControlsEnabled(form: UntypedFormGroup, enabled: boolean, paths: string[], opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function enableControl(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function disableControl(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function disableAndClearControl(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function setControlEnabled(control: AbstractControl, enabled: boolean, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function addValueInArray(arrayControl: UntypedFormArray, createControl: (value?: any) => AbstractControl, equals: (v1: any, v2: any) => boolean, isEmpty: (value: any) => boolean, value: any, options?: {
+    emitEvent: boolean;
+    insertAt?: number;
+    allowManyNullValues?: boolean;
+    allowDuplicateValue?: boolean;
+}): boolean;
+/**
+ * Set an array using given default values. Each default value will be pass to the 'createControl()' function
+ *
+ * @param arrayControl
+ * @param createControl
+ * @param defaultValues
+ * @param options
+ */
+export declare function initArrayControlsFromValues(arrayControl: UntypedFormArray, createControl: (value?: any) => AbstractControl, defaultValues: any[], options?: {
+    emitEvent?: boolean;
+}): boolean;
+export declare function resizeArray(arrayControl: UntypedFormArray, createControl: () => AbstractControl, length: number, options?: {
+    emitEvent?: boolean;
+}): boolean;
+export declare function removeValueInArray(arrayControl: UntypedFormArray, isEmpty: (value: any) => boolean, index: number): boolean;
+export declare function clearValueInArray(arrayControl: UntypedFormArray, isEmpty: (value: any) => boolean, index: number): boolean;
+export declare function markAllAsTouched(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+}): void;
+export declare function markFormGroupAsTouched(form: UntypedFormGroup, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+}): void;
+export declare function markControlAsTouched(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+}): void;
+export declare function updateValueAndValidity(form: UntypedFormGroup, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+}): void;
+export declare function markAsUntouched(form: UntypedFormGroup, opts?: {
+    onlySelf?: boolean;
+}): void;
+/**
+ * Wait end of async validation (not pending). This need to implement {pending: boolean}
+ * return false
+ */
+export declare function waitWhilePending<T extends {
+    pending: boolean;
+}>(form: T, opts?: WaitForOptions): Promise<void>;
+/**
+ * Wait form is idle (not loading). This need to implement {loading: boolean}
+ *
+ * @param form
+ * @param opts
+ */
+export declare function waitIdle<T extends {
+    loading: boolean;
+}>(form: T, opts?: WaitForOptions): Promise<void>;
+export declare function filterFormErrorsByPrefix(errors: FormErrors, ...prefixes: string[]): FormErrors;
+export declare function filterFormErrorsByPath(errors: FormErrors, filter: Predicate<string>): FormErrors;
+export declare function filterFormErrors(errors: FormErrors, filter: Predicate<[string, any]>): FormErrors;