@sumaris-net/ngx-components 18.12.0 → 18.12.2

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,92 @@
+import { ChangeDetectorRef, Injector, OnInit } from '@angular/core';
+import { FormGroupDirective, UntypedFormArray, UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import { FormFieldDefinition, FormFieldDefinitionMap } from '../../../shared/form/field.model';
+import { DateAdapter, ThemePalette } from '@angular/material/core';
+import { Moment } from 'moment';
+import { AppForm } from '../form.class';
+import { Property, PropertyMap } from '../../../shared/types';
+import { PropertyValidator } from './property.validator';
+import { PredefinedColors } from '@ionic/core';
+import { FormArrayHelper, FormArrayHelperOptions } from '../array/form-array';
+import { MatFormFieldAppearance, SubscriptSizing } from '@angular/material/form-field';
+import { MatAutocompleteFieldConfig } from '../../../shared/material/autocomplete/material.autocomplete.config';
+import { LoadResult } from '../../../shared/services/entity-service.class';
+import { RxState } from '@rx-angular/state';
+import { SortDirection } from '@angular/material/sort';
+import * as i0 from "@angular/core";
+export interface AppPropertiesFormState {
+    definitions: FormFieldDefinition[];
+    definitionKeys: Property[];
+}
+export declare class AppPropertiesForm<O = any, T extends Property<O> = Property<O>, S extends AppPropertiesFormState = AppPropertiesFormState> extends AppForm<T[]> implements OnInit {
+    protected injector: Injector;
+    protected formBuilder: UntypedFormBuilder;
+    protected dateAdapter: DateAdapter<Moment>;
+    protected cd: ChangeDetectorRef;
+    protected validator: PropertyValidator;
+    private formGroupDir;
+    protected readonly _state: RxState<S>;
+    protected _definitions$: import("rxjs").Observable<S["definitions"]>;
+    protected _definitionKeys$: import("rxjs").Observable<S["definitionKeys"]>;
+    protected set _definitionKeys(value: Property[]);
+    protected get _definitionKeys(): Property[];
+    protected _definitionByKey: FormFieldDefinitionMap;
+    protected _definitionsByIndex: {
+        [index: number]: FormFieldDefinition;
+    };
+    protected _helper: FormArrayHelper<Property>;
+    protected _autocompleteConfig: MatAutocompleteFieldConfig;
+    protected _focusedControlIndex: number;
+    formArrayName: string;
+    formArray: UntypedFormArray;
+    options: FormArrayHelperOptions;
+    chipColor: ThemePalette | PredefinedColors;
+    mobile: boolean;
+    appearance: MatFormFieldAppearance;
+    subscriptSizing: SubscriptSizing;
+    showHintKey: boolean;
+    hintKeyPrefix: string;
+    showMoreButton: boolean;
+    addButtonText: string;
+    addButtonTitle: string;
+    showAddButton: boolean;
+    panelClass: string;
+    panelWidth: string;
+    /**
+     * @deprecated Use addButtonTitle instead
+     * @param value
+     */
+    set showMoreButtonTitle(value: string);
+    get showMoreButtonTitle(): string;
+    set definitions(value: FormFieldDefinition[]);
+    get definitions(): FormFieldDefinition[];
+    set value(data: T[]);
+    get value(): T[];
+    get length(): number;
+    get fieldForms(): UntypedFormGroup[];
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, dateAdapter: DateAdapter<Moment>, cd: ChangeDetectorRef, validator: PropertyValidator, formGroupDir: FormGroupDirective);
+    ngOnInit(): void;
+    protected processDefinitions(definitions: FormFieldDefinition[]): any[];
+    getDefinitionAt(index: number): FormFieldDefinition;
+    updateDefinitionAt(index: number, opts?: {
+        emitEvent?: boolean;
+    }): FormFieldDefinition;
+    removeAt(index: number): void;
+    setValue(data: PropertyMap | T[]): Promise<void>;
+    getValueAsJson(): PropertyMap;
+    clear(): void;
+    protected clearTemplateCache(): void;
+    protected suggestDefinitionKeys(value: any, filter?: any, sortBy?: string | keyof Property, sortDirection?: SortDirection, opts?: {
+        offset?: number;
+        size?: number;
+        [key: string]: any;
+    }): Promise<LoadResult<Property>>;
+    protected markForCheck(): void;
+    protected isEmptyProperty(obj: Property): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppPropertiesForm<any, any, any>, [null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppPropertiesForm<any, any, any>, "app-properties-form", never, { "formArrayName": { "alias": "formArrayName"; "required": false; }; "formArray": { "alias": "formArray"; "required": false; }; "options": { "alias": "options"; "required": false; }; "chipColor": { "alias": "chipColor"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "subscriptSizing": { "alias": "subscriptSizing"; "required": false; }; "showHintKey": { "alias": "showHintKey"; "required": false; }; "hintKeyPrefix": { "alias": "hintKeyPrefix"; "required": false; }; "showMoreButton": { "alias": "showMoreButton"; "required": false; }; "addButtonText": { "alias": "addButtonText"; "required": false; }; "addButtonTitle": { "alias": "addButtonTitle"; "required": false; }; "showAddButton": { "alias": "showAddButton"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "panelWidth": { "alias": "panelWidth"; "required": false; }; "showMoreButtonTitle": { "alias": "showMoreButtonTitle"; "required": false; }; "definitions": { "alias": "definitions"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_mobile: unknown;
+    static ngAcceptInputType_showHintKey: unknown;
+    static ngAcceptInputType_showMoreButton: unknown;
+    static ngAcceptInputType_showAddButton: unknown;
+}

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,72 @@
+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 { Environment } from '../../../../environments/environment.class';
+import { TableElement } from '@e-is/ngx-material-table';
+import { EntityFilter } from '../../services/model/filter.model';
+import { FilterFn, Property } from '../../../shared/types';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import * as i0 from "@angular/core";
+export declare class PropertyEntity extends Entity<PropertyEntity, string> implements Property {
+    static fromObject: (source: any, opts?: any) => PropertyEntity;
+    definition: FormFieldDefinition;
+    value: any;
+    get key(): string;
+    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, never>;
+}
+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;
+    filterForm: UntypedFormGroup;
+    filterCriteriaCount: number;
+    filterPanelFloating: boolean;
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, validatorService: PropertyEntityValidator, environment: Environment);
+    ngOnInit(): void;
+    get value(): PropertyEntity[];
+    set value(data: PropertyEntity[]);
+    definitionByRow: (row: TableElement<PropertyEntity>) => FormFieldDefinition;
+    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;
+    resetProperty(event: UIEvent, row: TableElement<PropertyEntity>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppPropertiesTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppPropertiesTable, "app-properties-table", never, { "definitions": { "alias": "definitions"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,59 @@
+import { Property, PropertyMap } from '../../../shared/types';
+import { FormFieldDefinition } from '../../../shared/form/field.model';
+import { EntitiesServiceLoadOptions, SuggestFn } from '../../../shared/services/entity-service.class';
+export declare class AppPropertiesUtils {
+    /**
+     * Converts an array of `Property` objects into a `PropertiesMap` object.
+     *
+     * @param {Property[]} [sources] - An optional array of properties to be converted.
+     * @param {FormFieldDefinition[]} [definitions] - An optional array of form field definitions to help with the conversion.
+     * @param {Object} [opts] - Optional configurations.
+     * @param {boolean} [opts.omitNilOrBlank] - If true, properties with nil or blank values will be omitted. Defaults to true.
+     * @return {PropertyMap} - The resulting `PropertiesMap` object.
+     */
+    static arrayAsObject<T = any>(sources?: Property<T>[], definitions?: FormFieldDefinition[], opts?: {
+        omitNilOrBlank: boolean;
+    }): PropertyMap;
+    /**
+     * Generates an array of properties from the given object, optionally applying definitions to the properties.
+     *
+     * @param {PropertyMap} [sources] - The source object from which properties are to be extracted.
+     * @param {FormFieldDefinition[]} [definitions] - An optional array of definitions to be applied to the extracted properties.
+     * @param opts
+     * @return {Property[] | Promise<Property[]>} An array of properties generated from the source object, or a promise resolving to that array.
+     */
+    static arrayFromObject<T>(sources?: PropertyMap | Property<T>[], definitions?: FormFieldDefinition[], opts?: {
+        keepOrphan?: boolean;
+    }): Property<T>[] | Promise<Property<T>[]>;
+    static sanitize(source: PropertyMap | Property[], opts?: {
+        definitions?: FormFieldDefinition[];
+        includedKeys?: string[];
+    }): PropertyMap | Property[];
+}
+export declare class AppPropertyUtils {
+    static key(key: any): string;
+    static getPropertyKey(source: Property | any): string;
+    /**
+     * Converts the given source to an object that contains a key-value pair.
+     *
+     * @param {Property<any> | any} source - The source property or any value to be converted.
+     * @param {FormFieldDefinition} [def] - The form field definition used for serialization.
+     * @param {Object} [opts] - Additional options for serialization.
+     * @param {string} [opts.defaultSerializeAttribute='id'] - The attribute to be used for default serialization.
+     * @return {{ key: string, value: string } | undefined} An object containing the serialized key-value pair, or undefined if the source is not provided.
+     */
+    static asObject(source: Property<any> | any, def?: FormFieldDefinition, opts?: {
+        defaultSerializeAttribute?: string;
+    }): {
+        key: string;
+        value: string;
+    } | undefined;
+    static fromObject<T = string>(source: Property | Property<T>, def: FormFieldDefinition, opts?: {
+        defaultSuggestFn: SuggestFn<any, any>;
+        defaultSuggestOptions?: EntitiesServiceLoadOptions;
+        defaultSerializeAttribute?: string;
+    }): Property<T> | Promise<Property<T>>;
+    private static resolveEntity;
+    private static resolveEntityBySuggest;
+    private static toString;
+}

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

@@ -0,0 +1,27 @@
+import { UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import { Property } from '../../../shared/types';
+import { AppValidatorService } from '../../services/validator/base.validator.class';
+import { FormFieldDefinition } from '../../../shared/form/field.model';
+import { AppFormArray } from '../array/form-array';
+import * as i0 from "@angular/core";
+export interface PropertyValidatorOptions {
+    definition?: FormFieldDefinition;
+    valueMaxLength?: number;
+}
+export interface PropertiesValidatorOptions {
+    definitions?: FormFieldDefinition[];
+    valueMaxLength?: number;
+}
+export declare class PropertyValidator extends AppValidatorService<Property> {
+    protected formBuilder: UntypedFormBuilder;
+    constructor(formBuilder: UntypedFormBuilder);
+    getFormArray(data?: any, opts?: PropertiesValidatorOptions): AppFormArray<Property, UntypedFormGroup>;
+    getFormGroup(data?: Property, opts?: PropertyValidatorOptions): UntypedFormGroup;
+    getFormGroupConfig(data?: Property, opts?: PropertyValidatorOptions): {
+        [p: string]: any;
+    };
+    equals(v1: Property, v2: Property): boolean;
+    isEmpty(obj: Property): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyValidator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyValidator>;
+}

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

@@ -0,0 +1,22 @@
+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 { PropertyValidator } from '../property.validator';
+import { SortDirection } from '@angular/material/sort';
+import * as i0 from "@angular/core";
+export declare class PropertiesFormTestPage implements OnInit, AfterViewInit {
+    protected formBuilder: FormBuilder;
+    protected pv: PropertyValidator;
+    propertyDefinitions: FormFieldDefinition[];
+    i18nFieldPrefix: string;
+    form: FormGroup;
+    propertiesForm: AppPropertiesForm;
+    constructor(formBuilder: FormBuilder, pv: PropertyValidator);
+    ngOnInit(): void;
+    ngAfterViewInit(): Promise<void>;
+    protected suggestEntity(value: any, filter: any, sortBy: any | string, sortDirection: SortDirection, options: any): Promise<LoadResult<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertiesFormTestPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PropertiesFormTestPage, "app-properties-form-test", never, {}, {}, never, never, false, never>;
+}

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,16 @@
+import { PopoverController, ToastController } from '@ionic/angular';
+import { TextPopoverOptions } from '../text-popover.component';
+import { TranslateService } from '@ngx-translate/core';
+import { PlatformService } from '../../../services/platform.service';
+import * as i0 from "@angular/core";
+export declare class TextPopoverTestingPage {
+    private popoverController;
+    private toastController;
+    private translate;
+    private platform;
+    constructor(popoverController: PopoverController, toastController: ToastController, translate: TranslateService, platform: PlatformService);
+    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, never>;
+}

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-popover.component.d.ts

@@ -0,0 +1,80 @@
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { PopoverController, PopoverOptions } from '@ionic/angular';
+import { Subscription } from 'rxjs';
+import { TranslateService } from '@ngx-translate/core';
+import { TextForm } from '../../../shared/material/text/text-form.component';
+import { ValidatorFn } from '@angular/forms';
+import { Color, OverlayEventDetail } from '@ionic/core';
+import * as i0 from "@angular/core";
+export interface TextPopoverOptions {
+    title?: string;
+    text?: string;
+    placeholder?: string;
+    editing?: boolean;
+    multiline?: boolean;
+    autoHeight?: boolean;
+    maxLength?: number;
+    autofocus?: boolean;
+    validator?: ValidatorFn;
+    showHeader?: boolean;
+    headerColor?: Color;
+    headerButtons?: TextPopoverButton[];
+    showFooter?: boolean;
+}
+export interface TextPopoverButton {
+    text?: string;
+    icon?: string;
+    color?: Color;
+    fill?: 'outline' | 'clear' | 'solid';
+    side?: 'start' | 'end';
+    role?: 'cancel' | string;
+    cssClass?: string | string[];
+    handler?: (value: string) => boolean | void | Promise<boolean | void>;
+}
+export declare class TextPopover implements OnInit, AfterViewInit, OnDestroy, TextPopoverOptions {
+    protected popoverController: PopoverController;
+    protected translate: TranslateService;
+    /**
+     * Displays a popover using the provided controller, event, and options.
+     *
+     * @param {PopoverController} ctrl - The popover controller used to create and manage the popover.
+     * @param {Event} event - The event that triggers the display of the popover.
+     * @param {TextPopoverOptions} opts - The options specific to the text popover component.
+     * @param {Partial<PopoverOptions>} [popoverOpts] - Optional additional options for the popover.
+     * @return {Promise<OverlayEventDetail>} A promise that resolves with the details of the overlay event once the popover is dismissed.
+     */
+    static show(ctrl: PopoverController, event: Event, opts: TextPopoverOptions, popoverOpts?: Partial<PopoverOptions>): Promise<OverlayEventDetail>;
+    form: TextForm;
+    showHeader: boolean;
+    headerColor: Color;
+    showFooter: boolean;
+    title: string;
+    text: string;
+    placeholder: string;
+    editing: boolean;
+    multiline: boolean;
+    autoHeight: boolean;
+    maxLength: number;
+    autofocus: boolean;
+    validator: ValidatorFn;
+    headerButtons: TextPopoverButton[];
+    mobile: boolean;
+    subscription: Subscription;
+    get disabled(): boolean;
+    get enabled(): boolean;
+    get valid(): boolean;
+    get value(): any;
+    constructor(popoverController: PopoverController, translate: TranslateService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onValidate(event: any): Promise<any>;
+    disable(): void;
+    enable(): void;
+    cancel(): void;
+    ngOnDestroy(): void;
+    protected clickButton(button: TextPopoverButton): Promise<boolean>;
+    protected isStartSide(button: TextPopoverButton): boolean;
+    protected isEndSide(button: TextPopoverButton): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextPopover, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextPopover, "app-text-popover", never, { "showHeader": { "alias": "showHeader"; "required": false; }; "headerColor": { "alias": "headerColor"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "title": { "alias": "title"; "required": false; }; "text": { "alias": "text"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "editing": { "alias": "editing"; "required": false; }; "multiline": { "alias": "multiline"; "required": false; }; "autoHeight": { "alias": "autoHeight"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "validator": { "alias": "validator"; "required": false; }; "headerButtons": { "alias": "headerButtons"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; }, {}, never, never, false, never>;
+}

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

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

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

@@ -0,0 +1,19 @@
+import { ChangeDetectorRef, Injector } from '@angular/core';
+import { UntypedFormBuilder } from '@angular/forms';
+import { AppForm } from '../form.class';
+import * as i0 from "@angular/core";
+export declare class AppUsernameForm extends AppForm<{
+    username: string;
+}> {
+    protected cd: ChangeDetectorRef;
+    mobile: boolean;
+    usernamePlaceHolder: string;
+    emailValidator: boolean;
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppUsernameForm, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppUsernameForm, "app-username-form", never, { "mobile": { "alias": "mobile"; "required": false; }; "usernamePlaceHolder": { "alias": "usernamePlaceHolder"; "required": false; }; "emailValidator": { "alias": "emailValidator"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_mobile: unknown;
+    static ngAcceptInputType_emailValidator: unknown;
+}

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

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

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

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class AppGraphQLModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppGraphQLModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppGraphQLModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppGraphQLModule>;
+}

package/src/app/core/graphql/graphql.service.d.ts

@@ -0,0 +1,142 @@
+import { Observable } from 'rxjs';
+import { Apollo, ExtraSubscriptionOptions, QueryRef } from 'apollo-angular';
+import { ApolloCache, ApolloClient, FetchPolicy, MutationUpdaterFunction, OperationVariables, TypePolicies, Unmasked, WatchQueryFetchPolicy } from '@apollo/client/core';
+import { ServiceError } from '../services/errors';
+import { InjectionToken } from '@angular/core';
+import { NetworkService } from '../services/network.service';
+import { EmptyObject, TrackableMutationContext } from './graphql.utils';
+import { Platform } from '@ionic/angular';
+import { IEntity } from '../services/model/entity.model';
+import { Resolvers } from '@apollo/client/core/types';
+import { HttpLink } from 'apollo-angular/http';
+import { ErrorPolicy, MutationBaseOptions } from '@apollo/client/core/watchQueryOptions';
+import { Cache } from '@apollo/client/cache/core/types/Cache';
+import { Environment } from '../../../environments/environment.class';
+import { PropertyMap } from '../../shared/types';
+import { StartableService } from '../../shared/services/startable-service.class';
+import { StorageService } from '../../shared/storage/storage.service';
+import { DocumentNode } from 'graphql';
+import * as i0 from "@angular/core";
+export interface WatchQueryOptions<V> {
+    query: any;
+    variables?: V;
+    error?: ServiceError;
+    fetchPolicy?: WatchQueryFetchPolicy;
+}
+export interface MutateQueryOptions<TData, TVariables = OperationVariables, TContext = TrackableMutationContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {
+    mutation: any;
+    variables?: TVariables;
+    error?: ServiceError;
+    context?: TContext;
+    optimisticResponse?: Unmasked<NoInfer<TData>>;
+    offlineResponse?: TData | ((context: TContext) => Promise<TData>);
+    update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
+    forceOffline?: boolean;
+}
+export declare const APP_GRAPHQL_TYPE_POLICIES: InjectionToken<TypePolicies>;
+export declare const APP_GRAPHQL_FRAGMENTS: InjectionToken<DocumentNode[]>;
+export interface ConnectionParams extends Record<string, string> {
+    authToken?: string;
+    authBasic?: string;
+}
+export declare class GraphqlService extends StartableService<ApolloClient<any>> {
+    private platform;
+    private apollo;
+    private httpLink;
+    private network;
+    private storage;
+    protected environment: Environment;
+    private typePolicies;
+    private fragments;
+    private readonly _networkStatusChanged$;
+    private httpParams;
+    private wsParams;
+    private connectionParams;
+    private readonly _defaultFetchPolicy;
+    private onNetworkError;
+    private customErrors;
+    private onResetAuth;
+    get client(): ApolloClient<any>;
+    get cache(): ApolloCache<any>;
+    get defaultFetchPolicy(): WatchQueryFetchPolicy;
+    constructor(platform: Platform, apollo: Apollo, httpLink: HttpLink, network: NetworkService, storage: StorageService, environment: Environment, typePolicies: TypePolicies, fragments: DocumentNode[]);
+    setAuthToken(token: string): Promise<void>;
+    setAuthBasic(basic: string): Promise<void>;
+    /**
+     * Allow to add a field resolver
+     *  (see doc: https://www.apollographql.com/docs/react/data/local-state/#handling-client-fields-with-resolvers)
+     *
+     * @param resolvers
+     */
+    addResolver(resolvers: Resolvers | Resolvers[]): Promise<void>;
+    query<T, V = EmptyObject>(opts: {
+        query: any;
+        variables?: V;
+        error?: ServiceError;
+        fetchPolicy?: FetchPolicy;
+    }): Promise<T>;
+    watchQueryRef<T, V = EmptyObject>(opts: WatchQueryOptions<V>): QueryRef<T, V>;
+    queryRefValuesChanges<T, V = EmptyObject>(queryRef: QueryRef<T, V>, opts: WatchQueryOptions<V>): Observable<T>;
+    watchQuery<T, V = EmptyObject>(opts: WatchQueryOptions<V>): Observable<T>;
+    mutate<T, V = EmptyObject>(opts: MutateQueryOptions<T, V>): Promise<T>;
+    subscribe<T, V = EmptyObject>(opts: {
+        query: any;
+        variables: V;
+        fetchPolicy?: FetchPolicy;
+        errorPolicy?: ErrorPolicy;
+        error?: ServiceError;
+    }, extra?: ExtraSubscriptionOptions): Observable<T>;
+    insertIntoQueryCache<T, V = EmptyObject>(cache: ApolloCache<any>, opts: Cache.ReadQueryOptions<V, any> & {
+        arrayFieldName: string;
+        totalFieldName?: string;
+        data: T;
+        sortFn?: (d1: T, d2: T) => number;
+        size?: number;
+    }): void;
+    addManyToQueryCache<T = any, V = EmptyObject>(cache: ApolloCache<any>, opts: Cache.ReadQueryOptions<V, any> & {
+        arrayFieldName: string;
+        totalFieldName?: string;
+        data: T[];
+        equalsFn?: (d1: T, d2: T) => boolean;
+        sortFn?: (d1: T, d2: T) => number;
+    }): number;
+    /**
+     * Remove from cache, and return if removed or not
+     *
+     * @param cache
+     * @param opts
+     */
+    removeFromCachedQueryById<V = EmptyObject, ID = number>(cache: ApolloCache<any>, opts: Cache.ReadQueryOptions<V, any> & {
+        arrayFieldName: string;
+        totalFieldName?: string;
+        ids: ID;
+    }): boolean;
+    /**
+     * Remove ids from cache, and return the number of items removed
+     *
+     * @param cache
+     * @param opts
+     */
+    removeFromCachedQueryByIds<V = EmptyObject, ID = number>(cache: ApolloCache<any>, opts: Cache.ReadQueryOptions<V, any> & {
+        arrayFieldName: string;
+        totalFieldName?: string;
+        ids: ID[];
+    }): number;
+    updateToQueryCache<T extends IEntity<any>, V = EmptyObject>(cache: ApolloCache<any>, opts: Cache.ReadQueryOptions<V, any> & {
+        arrayFieldName: string;
+        totalFieldName?: string;
+        data: T;
+        equalsFn?: (d1: T, d2: T) => boolean;
+    }): void;
+    clearCache(client?: ApolloClient<any>): Promise<void>;
+    registerCustomError(error: PropertyMap): void;
+    protected ngOnStart(): Promise<ApolloClient<any>>;
+    protected ngOnStop(): Promise<void>;
+    protected resetClient(client?: ApolloClient<any>): Promise<void>;
+    private toApolloError;
+    private createAppErrorByCode;
+    private getI18nErrorMessageByCode;
+    private toAppError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphqlService, [null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GraphqlService>;
+}