@sumaris-net/ngx-components 18.12.0 → 18.12.2

package/src/app/social/user-event/notification/user-event-notification.list.d.ts

@@ -0,0 +1,71 @@
+import { ChangeDetectorRef, EventEmitter, InjectionToken, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { IUserEvent, IUserEventFilter, IUserEventAction } from '../user-event.model';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { IonContent, IonItem, PopoverController } from '@ionic/angular';
+import { IUserEventService } from '../user-event.service';
+import { LocalSettingsService } from '../../../core/services/local-settings.service';
+import { FetchMoreFn, LoadResult } from '../../../shared/services/entity-service.class';
+import { SortDirection } from '@angular/material/sort';
+import * as i0 from "@angular/core";
+export declare const APP_USER_EVENT_LIST_INFINITE_SCROLL_THRESHOLD: InjectionToken<string>;
+export interface UserEventNotificationListOptions<E extends IUserEvent<any> = IUserEvent<any>, F extends IUserEventFilter<any> = IUserEventFilter<any>> {
+    debug?: boolean;
+    titleI18n?: string;
+    readEvent?: EventEmitter<E>;
+    readEvents?: EventEmitter<E[]>;
+    filter?: Partial<F>;
+    headerActions?: IUserEventAction[];
+    footerActions?: IUserEventAction[];
+}
+export declare class UserEventNotificationList<E extends IUserEvent<any> = IUserEvent<any>, F extends IUserEventFilter<any> = IUserEventFilter<any>> implements OnInit, OnDestroy, UserEventNotificationListOptions<E, F> {
+    protected cd: ChangeDetectorRef;
+    protected popoverController: PopoverController;
+    protected settings: LocalSettingsService;
+    userEventService: IUserEventService<E, IUserEventFilter<any>>;
+    infiniteScrollThresholdFromToken: string;
+    debug: boolean;
+    mobile: boolean;
+    titleI18n: string;
+    sortBy: string;
+    sortDirection: SortDirection;
+    filter: Partial<F>;
+    enableInfiniteScroll: boolean;
+    infiniteScrollThreshold: string;
+    headerActions: IUserEventAction[];
+    footerActions: IUserEventAction[];
+    set pageSize(value: number);
+    get pageSize(): number;
+    readEvent: EventEmitter<E>;
+    readEvents: EventEmitter<E[]>;
+    ionContent: IonContent;
+    ionItems: QueryList<IonItem>;
+    get canFetchMore(): boolean;
+    fetchingMore: boolean;
+    $items: BehaviorSubject<E[]>;
+    $itemCount: BehaviorSubject<number>;
+    protected _subscriptions: Subscription;
+    protected _fetchMoreFn: FetchMoreFn<LoadResult<E>>;
+    protected _fetchMoreSubscription: Subscription;
+    protected _$pageSize: BehaviorSubject<number>;
+    protected _panelElement: HTMLElement;
+    constructor(cd: ChangeDetectorRef, popoverController: PopoverController, settings: LocalSettingsService, userEventService: IUserEventService<E, IUserEventFilter<any>>, infiniteScrollThresholdFromToken: string);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    click(event: Event, userEvent: E): void;
+    isDefaultAction(action: IUserEventAction): boolean;
+    markAsRead(event: Event, userEvent: E): void;
+    markAllAsRead(event: Event): void;
+    executeAction(event: Event, action: IUserEventAction, userEvent: IUserEvent<any>): Promise<void>;
+    dismiss(): void;
+    fetchMore(event?: CustomEvent & {
+        target?: EventTarget & {
+            complete?: () => void;
+        };
+    }): Promise<void>;
+    trackByFn(index: number, item: E): number;
+    protected initInfiniteScroll(threshold?: string): Promise<void>;
+    protected markForCheck(): void;
+    protected getPanelElement(): Promise<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventNotificationList<any, any>, [null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventNotificationList<any, any>, "app-user-event-notification-list", never, { "debug": { "alias": "debug"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "titleI18n": { "alias": "titleI18n"; "required": false; }; "sortBy": { "alias": "sortBy"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "enableInfiniteScroll": { "alias": "enableInfiniteScroll"; "required": false; }; "infiniteScrollThreshold": { "alias": "infiniteScrollThreshold"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; "footerActions": { "alias": "footerActions"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, { "readEvent": "readEvent"; "readEvents": "readEvents"; }, never, never, false, never>;
+}

package/src/app/social/user-event/testing/user-event.testing.d.ts

@@ -0,0 +1,35 @@
+import { OnDestroy } from '@angular/core';
+import { Router } from '@angular/router';
+import { AlertController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { UserEventTestService } from './user-event.testing.service';
+import { UserEventNotificationIcon } from '../notification/user-event-notification.icon';
+import { UserEventTest } from './user-event.testing.model';
+import * as i0 from "@angular/core";
+export declare class UserEventTestingPage implements OnDestroy {
+    protected userEventService: UserEventTestService;
+    protected router: Router;
+    protected alertController: AlertController;
+    protected translateService: TranslateService;
+    private _timerSubscription;
+    notification: UserEventNotificationIcon;
+    get timerStarted(): boolean;
+    constructor(userEventService: UserEventTestService, router: Router, alertController: AlertController, translateService: TranslateService);
+    ngOnDestroy(): void;
+    protected customize(userEvent: UserEventTest): void;
+    addNotification(): void;
+    addError(): void;
+    addWarning(): void;
+    addDebug(): void;
+    addNotificationWithLink(): void;
+    addNotificationWithAction(): void;
+    addMany(count?: number): void;
+    startTimer(period?: number): void;
+    stopTimer(): void;
+    addRandom(value: number): void;
+    addNotificationWithDefaultAction(): void;
+    protected showMessage(text: string): Promise<void>;
+    replaceLastEvent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventTestingPage, "job-progression-testing", never, {}, {}, never, never, false, never>;
+}

package/src/app/social/user-event/testing/user-event.testing.model.d.ts

@@ -0,0 +1,42 @@
+import { Entity, EntityAsObjectOptions } from '../../../core/services/model/entity.model';
+import { Moment } from 'moment';
+import { FilterFn, IconRef } from '../../../shared/types';
+import { EventLevel, IUserEvent, IUserEventAction, IUserEventFilter } from '../user-event.model';
+import { EntityFilter } from '../../../core/services/model/filter.model';
+import { StoreObject } from '@apollo/client/core';
+export declare class UserEventTest extends Entity<UserEventTest> implements IUserEvent<UserEventTest> {
+    static fromObject: (source: any, opts?: any) => UserEventTest;
+    type: string;
+    level: EventLevel;
+    issuer: string;
+    recipient: string;
+    creationDate: Moment;
+    readDate: Moment;
+    message: string | undefined;
+    content: string | any;
+    hash: string;
+    signature: string;
+    readSignature: string;
+    avatar?: string;
+    avatarIcon?: IconRef;
+    icon?: IconRef;
+    jobId?: number;
+    actions?: IUserEventAction[];
+    constructor();
+    asObject(opts?: EntityAsObjectOptions): any;
+    fromObject(source: any): void;
+}
+export declare class UserEventTestFilter extends EntityFilter<UserEventTestFilter, UserEventTest> implements IUserEventFilter<UserEventTest> {
+    static fromObject: (source: any, opts?: any) => UserEventTestFilter;
+    types: string[];
+    levels: EventLevel[];
+    issuers: string[];
+    recipients: string[];
+    startDate: Moment;
+    includedIds: number[];
+    excludeRead: boolean;
+    jobId: number;
+    fromObject(source: any, opts?: any): void;
+    protected buildFilter(): FilterFn<UserEventTest>[];
+    asObject(opts?: EntityAsObjectOptions): StoreObject;
+}

package/src/app/social/user-event/testing/user-event.testing.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./user-event.testing";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "../../../shared/shared.module";
+import * as i5 from "../user-event.module";
+export declare class UserEventTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UserEventTestingModule, [typeof i1.UserEventTestingPage], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i4.SharedModule, typeof i5.UserEventModule], [typeof i1.UserEventTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UserEventTestingModule>;
+}

package/src/app/social/user-event/testing/user-event.testing.service.d.ts

@@ -0,0 +1,42 @@
+import { AbstractUserEventService, UserEventLoadOptions, UserEventWatchOptions } from '../user-event.service';
+import { Observable } from 'rxjs';
+import { GraphqlService } from '../../../core/graphql/graphql.service';
+import { AccountService } from '../../../core/services/account.service';
+import { NetworkService } from '../../../core/services/network.service';
+import { TranslateService } from '@ngx-translate/core';
+import { Environment } from '../../../../environments/environment.class';
+import { FetchPolicy } from '@apollo/client/core';
+import { LoadResult } from '../../../shared/services/entity-service.class';
+import { SortDirection } from '@angular/material/sort';
+import { UserEventTest, UserEventTestFilter } from './user-event.testing.model';
+import { EntitySaveOptions } from '../../../core/services/base-entity-service.class';
+import * as i0 from "@angular/core";
+export declare class UserEventTestService extends AbstractUserEventService<UserEventTest, UserEventTestFilter> {
+    protected graphql: GraphqlService;
+    protected accountService: AccountService;
+    protected network: NetworkService;
+    protected translate: TranslateService;
+    protected environment: Environment;
+    private $userEvents;
+    private $newUserEvents;
+    constructor(graphql: GraphqlService, accountService: AccountService, network: NetworkService, translate: TranslateService, environment: Environment);
+    fromObject(source: any): UserEventTest;
+    add(entity: UserEventTest): Promise<UserEventTest>;
+    replaceLast(entity: UserEventTest): Promise<void>;
+    asFilter(filter: Partial<any>): any;
+    count(filter: any, options?: {
+        fetchPolicy?: FetchPolicy;
+    }): Promise<number>;
+    delete(entity: any): Promise<any>;
+    deleteAll(data: any[], opts?: any): Promise<any>;
+    listenAllChanges(filter: any, options?: UserEventLoadOptions<UserEventTest> & {
+        interval?: number;
+    }): Observable<any[]>;
+    save(entity: any, options?: EntitySaveOptions<UserEventTest>): Promise<any>;
+    saveAll(data: any[], opts?: any): Promise<any[]>;
+    protected defaultRecipient(): any;
+    watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>, opts?: UserEventWatchOptions<UserEventTest>): Observable<LoadResult<any>>;
+    loadAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>, opts?: UserEventLoadOptions<UserEventTest>): Promise<LoadResult<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserEventTestService>;
+}

package/src/app/social/user-event/user-event.model.d.ts

@@ -0,0 +1,44 @@
+import { Moment } from 'moment';
+import { IEntity } from '../../core/services/model/entity.model';
+import { IEntityFilter } from '../../core/services/model/filter.model';
+import { AppColors, IconRef } from '../../shared/types';
+export type EventLevel = 'ERROR' | 'WARNING' | 'INFO' | 'DEBUG';
+export interface IUserEvent<E extends IEntity<E, ID>, ID = number, U = string, L = EventLevel> extends IEntity<E, ID> {
+    issuer: U;
+    recipient: U;
+    type: string;
+    level: L;
+    updateDate: Moment;
+    creationDate: Moment;
+    readDate?: Moment;
+    message?: string;
+    content?: string | any;
+    avatar?: string;
+    avatarIcon?: IconRef;
+    avatarJdenticon?: any;
+    icon?: IconRef;
+    jobId?: number;
+    actions?: IUserEventAction[];
+}
+export interface IUserEventFilter<E extends IUserEvent<E, ID, U, L>, ID = number, U = string, L = EventLevel> extends IEntityFilter<any, E> {
+    types: string[];
+    levels: L[];
+    issuers: U[];
+    recipients: U[];
+    startDate: Moment;
+    includedIds: ID[];
+    excludeRead: boolean;
+    jobId?: number;
+}
+export interface IUserEventAction {
+    name: string | any;
+    title?: string;
+    color?: AppColors;
+    iconRef?: IconRef;
+    default?: boolean;
+    executeAction: (event: IUserEvent<any>) => any | Promise<any>;
+}
+/**
+ * @deprecated use IUserEventAction instead
+ */
+export type UserEventAction = IUserEventAction;

package/src/app/social/user-event/user-event.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./notification/user-event-notification.icon";
+import * as i2 from "./notification/user-event-notification.list";
+import * as i3 from "@angular/common";
+import * as i4 from "../../shared/shared.module";
+import * as i5 from "../../core/icon/icon.module";
+import * as i6 from "../../shared/rx-state/rx-state.module";
+import * as i7 from "ngx-jdenticon";
+export declare class UserEventModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UserEventModule, [typeof i1.UserEventNotificationIcon, typeof i2.UserEventNotificationList], [typeof i3.CommonModule, typeof i4.SharedModule, typeof i5.AppIconModule, typeof i6.RxStateModule, typeof i7.NgxJdenticonModule], [typeof i1.UserEventNotificationIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UserEventModule>;
+}

package/src/app/social/user-event/user-event.service.d.ts

@@ -0,0 +1,124 @@
+import { InjectionToken, OnDestroy } from '@angular/core';
+import { FetchPolicy } from '@apollo/client/core';
+import { AccountService } from '../../core/services/account.service';
+import { GraphqlService } from '../../core/graphql/graphql.service';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { IUserEvent, IUserEventFilter } from './user-event.model';
+import { SortDirection } from '@angular/material/sort';
+import { EntitiesServiceLoadOptions, EntitiesServiceWatchOptions, IEntitiesService, LoadResult, Page } from '../../shared/services/entity-service.class';
+import { TranslateService } from '@ngx-translate/core';
+import { NetworkService } from '../../core/services/network.service';
+import { BaseGraphqlService, BaseGraphqlServiceOptions } from '../../core/services/base-graphql-service.class';
+import { Moment } from 'moment';
+import { IStartableService } from '../../shared/services/startable-service.class';
+import { DocumentNode } from 'graphql/index';
+import { EntitySaveOptions, MutableWatchQueriesUpdatePolicy } from '../../core/services/base-entity-service.class';
+import * as i0 from "@angular/core";
+export declare const APP_USER_EVENT_SERVICE: InjectionToken<IUserEventService<any, any, number, UserEventWatchOptions<any>, UserEventLoadOptions<any>>>;
+export declare interface UserEventLoadOptions<T> extends EntitiesServiceLoadOptions<T> {
+    withContent?: boolean;
+}
+export declare interface UserEventWatchOptions<T> extends EntitiesServiceWatchOptions<T> {
+    withContent?: boolean;
+}
+export interface IUserEventQueries {
+    loadAll: any;
+    loadAllWithContent: any;
+    count?: any;
+}
+export interface IUserEventMutations {
+    save: any;
+    markAsRead?: any;
+    deleteByIds: any;
+}
+export interface IUserEventSubscriptions {
+    listenAllChanges: any;
+    listenCountChanges?: any;
+}
+export interface IUserEventListener<E extends IUserEvent<E, ID>, ID = number> {
+    accept: (E: any) => boolean;
+    onReceived?: (E: any) => Promise<E> | E | undefined;
+    onRead?: (E: any) => Promise<void> | void;
+}
+export interface UserEventServiceOptions<Q extends IUserEventQueries = IUserEventQueries, M extends IUserEventMutations = IUserEventMutations, S extends IUserEventSubscriptions = IUserEventSubscriptions> extends BaseGraphqlServiceOptions {
+    queries: Q;
+    mutations?: Partial<M>;
+    subscriptions?: Partial<S>;
+    watchQueriesUpdatePolicy?: MutableWatchQueriesUpdatePolicy;
+}
+export interface IUserEventService<E extends IUserEvent<E, ID>, F extends IUserEventFilter<E, ID>, ID = number, WO extends UserEventWatchOptions<E> = UserEventWatchOptions<E>, LO extends UserEventLoadOptions<E> = UserEventLoadOptions<E>> extends IEntitiesService<E, F, WO>, IStartableService {
+    countSubject: Observable<number>;
+    add(entity: E): Promise<E>;
+    load(id: ID, opts?: LO): Promise<E>;
+    count(filter: Partial<F>, options?: {
+        fetchPolicy?: FetchPolicy;
+    }): Promise<number>;
+    listenCountChanges(filter: Partial<F>, options?: Omit<LO, 'toEntity'> & {
+        interval?: number;
+    }): Observable<number>;
+    listenAllChanges(filter: Partial<F>, options?: LO & {
+        interval?: number;
+    }): Observable<E[]>;
+    save(entity: E, options?: EntitySaveOptions<E>): Promise<E>;
+    delete(entity: E): Promise<any>;
+    markAllAsRead(entities: E[]): any;
+    registerListener(listener: IUserEventListener<E, ID>): any;
+    resetCount(): any;
+}
+export declare abstract class AbstractUserEventService<E extends IUserEvent<E, ID, any>, F extends IUserEventFilter<E, ID, any>, ID = number, WO extends UserEventWatchOptions<E> = UserEventWatchOptions<E>, LO extends UserEventLoadOptions<E> = UserEventLoadOptions<E>, Q extends IUserEventQueries = IUserEventQueries, M extends IUserEventMutations = IUserEventMutations, S extends IUserEventSubscriptions = IUserEventSubscriptions> extends BaseGraphqlService<E, F, ID> implements IUserEventService<E, F, ID, WO, LO>, OnDestroy {
+    protected graphql: GraphqlService;
+    protected accountService: AccountService;
+    protected network: NetworkService;
+    protected translate: TranslateService;
+    protected options: UserEventServiceOptions<Q, M, S>;
+    protected readonly queries: Q;
+    protected readonly mutations: Partial<M>;
+    protected readonly subscriptions: Partial<S>;
+    protected readonly _countSubject: BehaviorSubject<number>;
+    protected readonly watchQueriesUpdatePolicy: MutableWatchQueriesUpdatePolicy;
+    protected resetCountDate: Moment;
+    protected listeners: IUserEventListener<E, ID>[];
+    private _subscriptions;
+    private _listenSubscription;
+    get countSubject(): Subject<number>;
+    protected constructor(graphql: GraphqlService, accountService: AccountService, network: NetworkService, translate: TranslateService, options: UserEventServiceOptions<Q, M, S>);
+    protected ngOnStart(): Promise<void>;
+    ngOnDestroy(): void;
+    abstract asFilter(filter: Partial<F>): F;
+    abstract fromObject(source: any): E;
+    watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<F>, options?: WO): Observable<LoadResult<E>>;
+    watchPage(page: Page, filter?: Partial<F>, opts?: WO): Observable<LoadResult<E>>;
+    loadPage(page: Page, filter?: Partial<F>, opts?: LO): Promise<LoadResult<E>>;
+    load(id: ID, opts?: LO): Promise<E>;
+    add(entity: E): Promise<E>;
+    count(filter: Partial<F>, options?: {
+        fetchPolicy?: FetchPolicy;
+    }): Promise<number>;
+    listenCountChanges(filter: Partial<F>, options?: Omit<LO, 'toEntity'> & {
+        interval?: number;
+    }): Observable<number>;
+    listenAllChanges(filter: Partial<F>, opts?: LO & {
+        interval?: number;
+    }): Observable<E[]>;
+    delete(entity: E): Promise<any>;
+    deleteAll(entities: E[], opts?: any): Promise<any>;
+    save(entity: E, opts?: EntitySaveOptions<E>): Promise<E>;
+    saveAll(entities: E[], opts?: EntitySaveOptions<E>): Promise<E[]>;
+    markAllAsRead(entities: E[]): Promise<void>;
+    registerListener(listener: IUserEventListener<E, ID>): void;
+    resetCount(): void;
+    protected onLogin(): Promise<void>;
+    protected onLogout(): void;
+    protected startListenCountChanges(): void;
+    protected stopListenCountChanges(): void;
+    protected processUserEvent(source: any): Promise<E>;
+    protected defaultMarkAsRead(userEvents: E[]): Promise<void>;
+    protected defaultFilter(): F;
+    protected abstract defaultRecipient(): any;
+    protected fillDefaultProperties(entity: E): void;
+    protected unreadEvents(events: E[]): number;
+    protected copyIdAndUpdateDate(source: E, target: E): void;
+    protected getLoadQueries(): DocumentNode[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractUserEventService<any, any, any, any, any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractUserEventService<any, any, any, any, any, any, any, any>, never, never, {}, {}, never, never, false, never>;
+}

package/src/assets/manifest.json

@@ -2,7 +2,7 @@
   "name": "ngx-sumaris-components",
   "short_name": "ngx-sumaris-components",
   "manifest_version": 1,
-  "version": "18.12.0-alpha1",
+  "version": "18.12.2",
   "default_locale": "fr",
   "description": "Angular components for building beautiful and responsive Apps",
   "icons": [{

package/src/environments/environment.class.d.ts

@@ -0,0 +1,75 @@
+import { FetchPolicy } from '@apollo/client/core';
+import { StorageConfig } from '@ionic/storage';
+import { InjectionToken } from '@angular/core';
+import { CacheConfig } from 'ionic-cache/lib/interfaces/cache-config.interface';
+import { LoggingServiceConfig } from '../app/shared/logging/logging-service.config';
+export declare const ENVIRONMENT: InjectionToken<Environment>;
+export declare class Environment {
+    name: string;
+    version: string;
+    production: boolean;
+    externalEnvironmentUrl?: string;
+    baseUrl: string;
+    connectionTimeout?: number;
+    sameUrlPeer?: boolean;
+    peer?: {
+        host: string;
+        port: number;
+        useSsl?: boolean;
+        path?: string;
+    } | undefined | null;
+    defaultPeer?: {
+        host: string;
+        port: number;
+        useSsl?: boolean;
+        path?: string;
+    } | undefined | null;
+    defaultPeers?: {
+        host: string;
+        port: number;
+        useSsl?: boolean;
+        path?: string;
+    }[];
+    peerMinVersion?: string;
+    peerDefaultPrefix?: string;
+    enableSelectPeerByFeature?: boolean;
+    checkAppVersionIntervalInSeconds?: number;
+    persistCache?: boolean;
+    offline?: boolean;
+    apolloFetchPolicy?: FetchPolicy;
+    defaultLocale: string;
+    defaultLatLongFormat?: 'DD' | 'DDMM' | 'DDMMSS';
+    defaultDepartmentId?: number;
+    defaultAppName?: string;
+    defaultAndroidInstallUrl?: string;
+    defaultIOSInstallUrl?: string;
+    defaultDesktopInstallUrl?: string;
+    useHash?: boolean;
+    allowDarkMode?: boolean;
+    defaultRoute?: string;
+    enableMenu?: boolean;
+    logging?: Partial<LoggingServiceConfig>;
+    cache?: Partial<CacheConfig>;
+    storage?: Partial<StorageConfig>;
+    storageSavePeriodMs?: number;
+    sourceUrl?: string;
+    reportIssueUrl?: string;
+    forumUrl?: string;
+    helpUrl?: string;
+    privacyPolicyUrl?: string;
+    termsOfUseUrl?: string;
+    defaultAuthValues?: {
+        username?: string;
+        password?: string;
+        token?: string;
+    };
+    account?: {
+        showAccountButton?: boolean;
+        enableListenChanges?: boolean;
+        listenIntervalInSeconds?: number;
+    };
+    entityEditor?: {
+        enableListenChanges?: boolean;
+        listenIntervalInSeconds?: number;
+    };
+}

package/src/environments/environment.d.ts

@@ -0,0 +1,2 @@
+import { Environment } from './environment.class';
+export declare const environment: Environment;

package/src/environments/environment.loader.d.ts

@@ -0,0 +1,24 @@
+import { HttpClient } from '@angular/common/http';
+import { Environment } from './environment.class';
+import * as i0 from "@angular/core";
+export declare abstract class EnvironmentLoader<T extends Environment = Environment> {
+    abstract load(): Promise<T>;
+    abstract get(): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnvironmentLoader<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EnvironmentLoader<any>, never, never, {}, {}, never, never, false, never>;
+}
+export declare class EnvironmentHttpLoader<T extends Environment = Environment> extends EnvironmentLoader<T> {
+    protected http: HttpClient;
+    private readonly _logPrefix;
+    protected _debug: boolean;
+    protected _environment: T;
+    protected _loaded: boolean;
+    protected readonly _externalEnvironmentUrl: string;
+    constructor(http: HttpClient, defaultEnvironment?: T);
+    /**
+     * Get the loaded environment. Should be call after loaded
+     */
+    get(): T;
+    load(): Promise<T>;
+    protected fetch(url: string): Promise<Partial<T>>;
+}

package/.editorconfig

@@ -1,24 +0,0 @@
-# EditorConfig helps developers define and maintain consistent coding styles between different editors and IDEs
-# editorconfig.org
-
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-max_line_length = 200
-
-# We recommend you to keep these unchanged
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.ts]
-indent_style = space
-indent_size = 2
-ij_typescript_use_double_quotes = false
-ij_typescript_force_quote_style = true
-
-[*.md]
-trim_trailing_whitespace = false

package/.eslintrc.json

@@ -1,95 +0,0 @@
-{
-  "root": true,
-  "ignorePatterns": [
-    "/dist/**/*.*", "/doc/**/*.*", "/resources/**/*.*", "/scripts/**/*.*", "/www/**/*.*", "index.html"
-  ],
-  "overrides": [
-    {
-      "files": [
-        "*.ts"
-      ],
-      "parserOptions": {
-        "project": [
-          "tsconfig.json",
-          "e2e/tsconfig.json"
-        ],
-        "createDefaultProgram": true
-      },
-      "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended",
-        "plugin:@angular-eslint/recommended",
-        "plugin:@angular-eslint/template/process-inline-templates",
-        "plugin:prettier/recommended"
-      ],
-      "rules": {
-        "@typescript-eslint/no-explicit-any": "off",
-        "@angular-eslint/component-class-suffix": "off",
-        "@angular-eslint/component-selector": "off",
-        "@angular-eslint/directive-selector": "off",
-        "@angular-eslint/no-output-on-prefix": "off",
-        "@angular-eslint/no-output-rename": "warn",
-        "@angular-eslint/no-input-rename": "warn",
-        "@typescript-eslint/consistent-type-assertions": "off",
-        "@typescript-eslint/consistent-type-definitions": "error",
-        "@typescript-eslint/naming-convention": "off",
-        "@typescript-eslint/member-ordering": "off",
-        "@typescript-eslint/dot-notation": "off",
-        "prefer-arrow/prefer-arrow-functions": "off",
-        "@typescript-eslint/explicit-member-accessibility": [
-          "off",
-          {
-            "accessibility": "explicit"
-          }
-        ],
-        "@typescript-eslint/no-shadow": [
-          "off",
-          {
-            "hoist": "all"
-          }
-        ],
-        "@typescript-eslint/no-unused-vars": "warn",
-        "brace-style": [
-          "off",
-          "off"
-        ],
-        "curly": "off",
-        "dot-notation": "off",
-        "id-blacklist": "off",
-        "id-match": "off",
-        "no-empty-function": "off",
-        "no-shadow": [
-          "off",
-          {
-            "hoist": "all"
-          }
-        ],
-        "no-trailing-spaces": "off",
-        "no-undef-init": "off",
-        "no-underscore-dangle": "off",
-        "no-unused-expressions": "error",
-        "no-use-before-define": "off",
-        "no-throw-literal": "off",
-        "radix": "off",
-        "semi": "error",
-        "no-console": "off",
-        "max-len": "off"
-      }
-    },
-    {
-      "files": [
-        "*.html"
-      ],
-      "extends": [
-        "plugin:@angular-eslint/template/recommended",
-        "plugin:@angular-eslint/template/accessibility",
-        "plugin:prettier/recommended"
-      ],
-      "rules": {
-        "@angular-eslint/template/eqeqeq": "off",
-        "@angular-eslint/template/click-events-have-key-events": "warn",
-        "@angular-eslint/template/interactive-supports-focus": "warn"
-      }
-    }
-  ]
-}

package/.gitattribute

@@ -1 +0,0 @@
-*.sh text eol=lf

package/.github/CONTRIBUTING.md

@@ -1,10 +0,0 @@
-This project is now tracked on a gitlab server at:
-> https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components
-
-The current github repository is a simple clone taken up to date at each push on the main gitlab repository.
-
-All contributions should be performed on the main gitlab repository.
-
-Pull requests proposed on github would generate more work for the main contributors.
-
-Issues can be submitted on github. However, all issues created on github will be duplicated on gitlab manually and closed with a link to the gitlab issue.

package/.github/ISSUE_TEMPLATE.md

@@ -1,6 +0,0 @@
-Please note that all issues should be preferentially opened at
-https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/issues
-
-If you open issue here, it will be duplicated manually on our hosted gitlab and closed here with a link to our main repository.
-
-Thank you for your understanding.