@sumaris-net/ngx-components 18.12.0 → 18.12.1

package/esm2022/src/environments/environment.class.mjs

@@ -0,0 +1,65 @@
+import { InjectionToken } from '@angular/core';
+export const ENVIRONMENT = new InjectionToken('ENV');
+export class Environment {
+    name;
+    version;
+    production;
+    // An URL to load external environment file (e.g. 'assets/environments/environment.json'
+    externalEnvironmentUrl;
+    baseUrl;
+    connectionTimeout;
+    sameUrlPeer;
+    // The peer to use (if defined)
+    peer;
+    // A peer to use at startup (useful on a web site deployment)
+    defaultPeer;
+    // A list of peers, to select as peer, in settings
+    defaultPeers;
+    // Min compatible version for the peer
+    peerMinVersion;
+    // Default peer prefix, when fix peer url manually (default: 'https://')
+    peerDefaultPrefix;
+    // Allow to select a peer by feature
+    enableSelectPeerByFeature;
+    // Interval to check if web page must be reload, in millis
+    checkAppVersionIntervalInSeconds;
+    // Enable cache persistence ?
+    persistCache;
+    // Force offline mode ? /!\ For DEV only
+    offline;
+    // Apollo (graphQL) config
+    apolloFetchPolicy;
+    // Default values
+    defaultLocale;
+    defaultLatLongFormat;
+    defaultDepartmentId;
+    defaultAppName;
+    defaultAndroidInstallUrl;
+    defaultIOSInstallUrl;
+    defaultDesktopInstallUrl;
+    // Route and style
+    useHash; // Configure Angular router to use '#' in URL (need by web-ext artifact)
+    allowDarkMode;
+    defaultRoute; // Configure the default route ('/' by default)
+    enableMenu; // Enable by default
+    // Logging
+    logging;
+    // Storage
+    cache;
+    storage;
+    storageSavePeriodMs;
+    // About
+    sourceUrl;
+    reportIssueUrl;
+    forumUrl; // TODO allow a map by locale ? ex: { [lang: string]: string };
+    helpUrl; // TODO allow a map by locale ?
+    privacyPolicyUrl; // TODO allow a map by locale ?
+    termsOfUseUrl; // TODO allow a map by locale ?
+    // Default authentication /!\ For DEV only
+    // (see values in the test database - XML files in Pod's module)
+    defaultAuthValues;
+    // Account
+    account;
+    entityEditor;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQuY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZW52aXJvbm1lbnRzL2Vudmlyb25tZW50LmNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFJL0MsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLElBQUksY0FBYyxDQUFjLEtBQUssQ0FBQyxDQUFDO0FBRWxFLE1BQU0sT0FBTyxXQUFXO0lBQ3RCLElBQUksQ0FBUztJQUNiLE9BQU8sQ0FBUztJQUNoQixVQUFVLENBQVU7SUFFcEIsd0ZBQXdGO0lBQ3hGLHNCQUFzQixDQUFVO0lBQ2hDLE9BQU8sQ0FBUztJQUNoQixpQkFBaUIsQ0FBVTtJQUUzQixXQUFXLENBQVc7SUFFdEIsK0JBQStCO0lBQy9CLElBQUksQ0FBc0Y7SUFFMUYsNkRBQTZEO0lBQzdELFdBQVcsQ0FBc0Y7SUFFakcsa0RBQWtEO0lBQ2xELFlBQVksQ0FBcUU7SUFFakYsc0NBQXNDO0lBQ3RDLGNBQWMsQ0FBVTtJQUV4Qix3RUFBd0U7SUFDeEUsaUJBQWlCLENBQVU7SUFFM0Isb0NBQW9DO0lBQ3BDLHlCQUF5QixDQUFXO0lBRXBDLDBEQUEwRDtJQUMxRCxnQ0FBZ0MsQ0FBVTtJQUUxQyw2QkFBNkI7SUFDN0IsWUFBWSxDQUFXO0lBRXZCLHdDQUF3QztJQUN4QyxPQUFPLENBQVc7SUFFbEIsMEJBQTBCO0lBQzFCLGlCQUFpQixDQUFlO0lBRWhDLGlCQUFpQjtJQUNqQixhQUFhLENBQVM7SUFDdEIsb0JBQW9CLENBQTRCO0lBQ2hELG1CQUFtQixDQUFVO0lBQzdCLGNBQWMsQ0FBVTtJQUN4Qix3QkFBd0IsQ0FBVTtJQUNsQyxvQkFBb0IsQ0FBVTtJQUM5Qix3QkFBd0IsQ0FBVTtJQUVsQyxrQkFBa0I7SUFDbEIsT0FBTyxDQUFXLENBQUMsd0VBQXdFO0lBQzNGLGFBQWEsQ0FBVztJQUN4QixZQUFZLENBQVUsQ0FBQywrQ0FBK0M7SUFDdEUsVUFBVSxDQUFXLENBQUMsb0JBQW9CO0lBRTFDLFVBQVU7SUFDVixPQUFPLENBQWlDO0lBRXhDLFVBQVU7SUFDVixLQUFLLENBQXdCO0lBQzdCLE9BQU8sQ0FBMEI7SUFDakMsbUJBQW1CLENBQVU7SUFFN0IsUUFBUTtJQUNSLFNBQVMsQ0FBVTtJQUNuQixjQUFjLENBQVU7SUFFeEIsUUFBUSxDQUFVLENBQUMsK0RBQStEO0lBQ2xGLE9BQU8sQ0FBVSxDQUFDLCtCQUErQjtJQUNqRCxnQkFBZ0IsQ0FBVSxDQUFDLCtCQUErQjtJQUMxRCxhQUFhLENBQVUsQ0FBQywrQkFBK0I7SUFFdkQsMENBQTBDO0lBQzFDLGdFQUFnRTtJQUNoRSxpQkFBaUIsQ0FJZjtJQUVGLFVBQVU7SUFDVixPQUFPLENBTUw7SUFFRixZQUFZLENBS1Y7Q0FDSCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZldGNoUG9saWN5IH0gZnJvbSAnQGFwb2xsby9jbGllbnQvY29yZSc7XG5pbXBvcnQgeyBTdG9yYWdlQ29uZmlnIH0gZnJvbSAnQGlvbmljL3N0b3JhZ2UnO1xuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENhY2hlQ29uZmlnIH0gZnJvbSAnaW9uaWMtY2FjaGUvbGliL2ludGVyZmFjZXMvY2FjaGUtY29uZmlnLmludGVyZmFjZSc7XG5pbXBvcnQgeyBMb2dnaW5nU2VydmljZUNvbmZpZyB9IGZyb20gJy4uL2FwcC9zaGFyZWQvbG9nZ2luZy9sb2dnaW5nLXNlcnZpY2UuY29uZmlnJztcblxuZXhwb3J0IGNvbnN0IEVOVklST05NRU5UID0gbmV3IEluamVjdGlvblRva2VuPEVudmlyb25tZW50PignRU5WJyk7XG5cbmV4cG9ydCBjbGFzcyBFbnZpcm9ubWVudCB7XG4gIG5hbWU6IHN0cmluZztcbiAgdmVyc2lvbjogc3RyaW5nO1xuICBwcm9kdWN0aW9uOiBib29sZWFuO1xuXG4gIC8vIEFuIFVSTCB0byBsb2FkIGV4dGVybmFsIGVudmlyb25tZW50IGZpbGUgKGUuZy4gJ2Fzc2V0cy9lbnZpcm9ubWVudHMvZW52aXJvbm1lbnQuanNvbidcbiAgZXh0ZXJuYWxFbnZpcm9ubWVudFVybD86IHN0cmluZztcbiAgYmFzZVVybDogc3RyaW5nO1xuICBjb25uZWN0aW9uVGltZW91dD86IG51bWJlcjtcblxuICBzYW1lVXJsUGVlcj86IGJvb2xlYW47XG5cbiAgLy8gVGhlIHBlZXIgdG8gdXNlIChpZiBkZWZpbmVkKVxuICBwZWVyPzogeyBob3N0OiBzdHJpbmc7IHBvcnQ6IG51bWJlcjsgdXNlU3NsPzogYm9vbGVhbjsgcGF0aD86IHN0cmluZyB9IHwgdW5kZWZpbmVkIHwgbnVsbDtcblxuICAvLyBBIHBlZXIgdG8gdXNlIGF0IHN0YXJ0dXAgKHVzZWZ1bCBvbiBhIHdlYiBzaXRlIGRlcGxveW1lbnQpXG4gIGRlZmF1bHRQZWVyPzogeyBob3N0OiBzdHJpbmc7IHBvcnQ6IG51bWJlcjsgdXNlU3NsPzogYm9vbGVhbjsgcGF0aD86IHN0cmluZyB9IHwgdW5kZWZpbmVkIHwgbnVsbDtcblxuICAvLyBBIGxpc3Qgb2YgcGVlcnMsIHRvIHNlbGVjdCBhcyBwZWVyLCBpbiBzZXR0aW5nc1xuICBkZWZhdWx0UGVlcnM/OiB7IGhvc3Q6IHN0cmluZzsgcG9ydDogbnVtYmVyOyB1c2VTc2w/OiBib29sZWFuOyBwYXRoPzogc3RyaW5nIH1bXTtcblxuICAvLyBNaW4gY29tcGF0aWJsZSB2ZXJzaW9uIGZvciB0aGUgcGVlclxuICBwZWVyTWluVmVyc2lvbj86IHN0cmluZztcblxuICAvLyBEZWZhdWx0IHBlZXIgcHJlZml4LCB3aGVuIGZpeCBwZWVyIHVybCBtYW51YWxseSAoZGVmYXVsdDogJ2h0dHBzOi8vJylcbiAgcGVlckRlZmF1bHRQcmVmaXg/OiBzdHJpbmc7XG5cbiAgLy8gQWxsb3cgdG8gc2VsZWN0IGEgcGVlciBieSBmZWF0dXJlXG4gIGVuYWJsZVNlbGVjdFBlZXJCeUZlYXR1cmU/OiBib29sZWFuO1xuXG4gIC8vIEludGVydmFsIHRvIGNoZWNrIGlmIHdlYiBwYWdlIG11c3QgYmUgcmVsb2FkLCBpbiBtaWxsaXNcbiAgY2hlY2tBcHBWZXJzaW9uSW50ZXJ2YWxJblNlY29uZHM/OiBudW1iZXI7XG5cbiAgLy8gRW5hYmxlIGNhY2hlIHBlcnNpc3RlbmNlID9cbiAgcGVyc2lzdENhY2hlPzogYm9vbGVhbjtcblxuICAvLyBGb3JjZSBvZmZsaW5lIG1vZGUgPyAvIVxcIEZvciBERVYgb25seVxuICBvZmZsaW5lPzogYm9vbGVhbjtcblxuICAvLyBBcG9sbG8gKGdyYXBoUUwpIGNvbmZpZ1xuICBhcG9sbG9GZXRjaFBvbGljeT86IEZldGNoUG9saWN5O1xuXG4gIC8vIERlZmF1bHQgdmFsdWVzXG4gIGRlZmF1bHRMb2NhbGU6IHN0cmluZztcbiAgZGVmYXVsdExhdExvbmdGb3JtYXQ/OiAnREQnIHwgJ0RETU0nIHwgJ0RETU1TUyc7XG4gIGRlZmF1bHREZXBhcnRtZW50SWQ/OiBudW1iZXI7XG4gIGRlZmF1bHRBcHBOYW1lPzogc3RyaW5nO1xuICBkZWZhdWx0QW5kcm9pZEluc3RhbGxVcmw/OiBzdHJpbmc7XG4gIGRlZmF1bHRJT1NJbnN0YWxsVXJsPzogc3RyaW5nO1xuICBkZWZhdWx0RGVza3RvcEluc3RhbGxVcmw/OiBzdHJpbmc7XG5cbiAgLy8gUm91dGUgYW5kIHN0eWxlXG4gIHVzZUhhc2g/OiBib29sZWFuOyAvLyBDb25maWd1cmUgQW5ndWxhciByb3V0ZXIgdG8gdXNlICcjJyBpbiBVUkwgKG5lZWQgYnkgd2ViLWV4dCBhcnRpZmFjdClcbiAgYWxsb3dEYXJrTW9kZT86IGJvb2xlYW47XG4gIGRlZmF1bHRSb3V0ZT86IHN0cmluZzsgLy8gQ29uZmlndXJlIHRoZSBkZWZhdWx0IHJvdXRlICgnLycgYnkgZGVmYXVsdClcbiAgZW5hYmxlTWVudT86IGJvb2xlYW47IC8vIEVuYWJsZSBieSBkZWZhdWx0XG5cbiAgLy8gTG9nZ2luZ1xuICBsb2dnaW5nPzogUGFydGlhbDxMb2dnaW5nU2VydmljZUNvbmZpZz47XG5cbiAgLy8gU3RvcmFnZVxuICBjYWNoZT86IFBhcnRpYWw8Q2FjaGVDb25maWc+O1xuICBzdG9yYWdlPzogUGFydGlhbDxTdG9yYWdlQ29uZmlnPjtcbiAgc3RvcmFnZVNhdmVQZXJpb2RNcz86IG51bWJlcjtcblxuICAvLyBBYm91dFxuICBzb3VyY2VVcmw/OiBzdHJpbmc7XG4gIHJlcG9ydElzc3VlVXJsPzogc3RyaW5nO1xuXG4gIGZvcnVtVXJsPzogc3RyaW5nOyAvLyBUT0RPIGFsbG93IGEgbWFwIGJ5IGxvY2FsZSA/IGV4OiB7IFtsYW5nOiBzdHJpbmddOiBzdHJpbmcgfTtcbiAgaGVscFVybD86IHN0cmluZzsgLy8gVE9ETyBhbGxvdyBhIG1hcCBieSBsb2NhbGUgP1xuICBwcml2YWN5UG9saWN5VXJsPzogc3RyaW5nOyAvLyBUT0RPIGFsbG93IGEgbWFwIGJ5IGxvY2FsZSA/XG4gIHRlcm1zT2ZVc2VVcmw/OiBzdHJpbmc7IC8vIFRPRE8gYWxsb3cgYSBtYXAgYnkgbG9jYWxlID9cblxuICAvLyBEZWZhdWx0IGF1dGhlbnRpY2F0aW9uIC8hXFwgRm9yIERFViBvbmx5XG4gIC8vIChzZWUgdmFsdWVzIGluIHRoZSB0ZXN0IGRhdGFiYXNlIC0gWE1MIGZpbGVzIGluIFBvZCdzIG1vZHVsZSlcbiAgZGVmYXVsdEF1dGhWYWx1ZXM/OiB7XG4gICAgdXNlcm5hbWU/OiBzdHJpbmc7XG4gICAgcGFzc3dvcmQ/OiBzdHJpbmc7XG4gICAgdG9rZW4/OiBzdHJpbmc7XG4gIH07XG5cbiAgLy8gQWNjb3VudFxuICBhY2NvdW50Pzoge1xuICAgIHNob3dBY2NvdW50QnV0dG9uPzogYm9vbGVhbjsgLy8gU2hvdyBhY2NvdW50IGJ1dHRvbiBpbiBob21lIHBhZ2UgKGlmIHVuZGVmaW5lZCA9IHRydWUpXG4gICAgZW5hYmxlTGlzdGVuQ2hhbmdlcz86IGJvb2xlYW47XG4gICAgLy8gSWYgdW5kZWZpbmVkIG9yIDAsIHRoZW4gbGlzdGVuIG9ubHkgY2hhbmdlcyBtYWRlIGJ5IHRoZSBwb2RcbiAgICAvLyBJZiBncmVhdGVyIHRoYW4gMCA6IHdpbGwgY2hlY2sgY29uY3VycmVudCBjaGFuZ2VzIGluIHRoZSBEQiAoZS5nLiBjaGFuZ2VzIG1kZSBieSBhbm90aGVyIHNvZnR3YXJlKSBBTkQgY2hhbmdlcyBtYWRlIHRoZSBwb2RcbiAgICBsaXN0ZW5JbnRlcnZhbEluU2Vjb25kcz86IG51bWJlcjtcbiAgfTtcblxuICBlbnRpdHlFZGl0b3I/OiB7XG4gICAgZW5hYmxlTGlzdGVuQ2hhbmdlcz86IGJvb2xlYW47XG4gICAgLy8gSWYgdW5kZWZpbmVkIG9yIDAsIHRoZW4gbGlzdGVuIG9ubHkgY2hhbmdlcyBtYWRlIGJ5IHRoZSBwb2RcbiAgICAvLyBJZiBncmVhdGVyIHRoYW4gMCA6IHdpbGwgY2hlY2sgY29uY3VycmVudCBjaGFuZ2VzIGluIHRoZSBEQiAoZS5nLiBjaGFuZ2VzIG1kZSBieSBhbm90aGVyIHNvZnR3YXJlKSBBTkQgY2hhbmdlcyBtYWRlIHRoZSBwb2RcbiAgICBsaXN0ZW5JbnRlcnZhbEluU2Vjb25kcz86IG51bWJlcjtcbiAgfTtcbn1cbiJdfQ==

package/esm2022/src/environments/environment.loader.mjs

@@ -0,0 +1,77 @@
+import { Directive } from '@angular/core';
+import { firstValueFrom, of, shareReplay, tap } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { isNotNilOrBlank } from '../app/shared/functions';
+import * as i0 from "@angular/core";
+export class EnvironmentLoader {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentLoader, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: EnvironmentLoader, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentLoader, decorators: [{
+            type: Directive
+        }] });
+export class EnvironmentHttpLoader extends EnvironmentLoader {
+    http;
+    _logPrefix = '[environment-loader] ';
+    _debug;
+    _environment;
+    _loaded = false;
+    _externalEnvironmentUrl;
+    constructor(http, defaultEnvironment) {
+        super();
+        this.http = http;
+        // Copy default environment (because can be readonly)
+        this._environment = Object.assign({}, defaultEnvironment || {});
+        this._externalEnvironmentUrl = this._environment.externalEnvironmentUrl;
+        this._debug = !this._environment.production;
+    }
+    /**
+     * Get the loaded environment. Should be call after loaded
+     */
+    get() {
+        if (!this._loaded && isNotNilOrBlank(this._externalEnvironmentUrl)) {
+            console.warn(`${this._logPrefix}EnvironmentHttpLoader.get() should be called AFTER load() finished.`);
+        }
+        return this._environment;
+    }
+    async load() {
+        if (this._loaded)
+            return this._environment; // Already loaded
+        try {
+            // If it has an external url
+            if (isNotNilOrBlank(this._externalEnvironmentUrl)) {
+                // DEBUG
+                //await sleep(4000);
+                // Load external environment file
+                const json = await this.fetch(this._externalEnvironmentUrl);
+                // Patch the existing environment
+                if (json) {
+                    Object.assign(this._environment, json);
+                }
+            }
+            return this._environment;
+        }
+        finally {
+            this._loaded = true;
+        }
+    }
+    /* -- protected function -- */
+    async fetch(url) {
+        if (this._debug)
+            console.debug(`${this._logPrefix}Loading external environment from {${url}}...`);
+        return firstValueFrom(this.http.get(url).pipe(shareReplay(1), tap((json) => {
+            if (this._debug)
+                console.debug(`${this._logPrefix}External environment loaded`, json);
+        }), catchError((error) => {
+            if (error.status === 404) {
+                if (this._debug)
+                    console.error(`${this._logPrefix}External environment not found (404)`);
+            }
+            else {
+                console.error(`${this._logPrefix}Failed to load external environment: ${error.message}`, error);
+            }
+            return of(null);
+        })));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/environments/environment.mjs

@@ -0,0 +1,109 @@
+// This file can be replaced during build by using the `fileReplacements` array.
+// `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.
+// The list of file replacements can be found in `angular.json`.
+import { StorageDrivers } from '../app/shared/storage/storage.utils';
+/*
+ * In development mode, to ignore zone related error stack frames such as
+ * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can
+ * import the following file, but please comment it out in production mode
+ * because it will have performance impact when throw error
+ */
+//import 'zone.js/plugins/zone-error';
+export const environment = Object.freeze({
+    name: '@sumaris-net/ngx-components', // overridden by ENVIRONMENT token
+    version: '1.0', // overridden by ENVIRONMENT token
+    // Do NOT set to false - because this value will be used by releases
+    production: true,
+    // Do NOT set - because this value will be used by releases
+    //externalEnvironmentUrl: null,
+    baseUrl: '/',
+    defaultLocale: 'fr',
+    defaultLatLongFormat: 'DDMM',
+    apolloFetchPolicy: 'cache-first',
+    useHash: false,
+    allowDarkMode: true,
+    //defaultRoute: '/home',
+    //enableMenu: true,
+    // FIXME: enable cache
+    persistCache: false,
+    // TODO: make this works
+    //offline: true,
+    peerMinVersion: '1.8.0',
+    enableSelectPeerByFeature: true,
+    defaultPeer: {
+        host: 'localhost',
+        port: 8081,
+    },
+    defaultPeers: [
+        {
+            host: 'localhost',
+            port: 8080,
+        },
+        {
+            host: 'localhost',
+            port: 8081,
+        },
+        {
+            host: '192.168.0.45',
+            port: 8080,
+        },
+        {
+            host: '192.168.0.24',
+            port: 8080,
+        },
+        {
+            host: '192.168.0.29',
+            port: 8080,
+        },
+        {
+            host: '192.168.0.107',
+            port: 8080,
+        },
+        {
+            host: 'sih.sfa.sc',
+            port: 443,
+        },
+        {
+            host: 'test.sumaris.net',
+            port: 443,
+        },
+        {
+            host: 'open.sumaris.net',
+            port: 443,
+        },
+        {
+            host: 'server.e-is.pro',
+            port: 443,
+        },
+    ],
+    defaultAppName: 'SUMARiS',
+    defaultAndroidInstallUrl: 'https://play.google.com/store/apps/details?id=net.sumaris.app',
+    defaultIOSInstallUrl: 'https://apps.apple.com/us/app/sumaris/id6736747523',
+    defaultDesktopInstallUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/releases',
+    // Storage
+    storage: {
+        driverOrder: [StorageDrivers.SQLLite, StorageDrivers.IndexedDB, StorageDrivers.WebSQL, StorageDrivers.LocalStorage],
+    },
+    // About
+    sourceUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components',
+    reportIssueUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/issues',
+    forumUrl: null, //'https://forum.sumaris.net',
+    helpUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-doc/-/blob/master/user-manual/index_fr.md',
+    privacyPolicyUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/raw/master/doc/privacy_policy_fr.md',
+    termsOfUseUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/raw/master/doc/terms_of_use_fr.md?ref_type=heads',
+    // Development
+    defaultAuthValues: {
+        // Token auth (using Person.pubkey)
+        username: 'admin@sumaris.net',
+        password: 'admin',
+    },
+    account: {
+        enableListenChanges: true,
+        listenIntervalInSeconds: 60,
+    },
+    entityEditor: {
+        enableListenChanges: true,
+        listenIntervalInSeconds: 60,
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/sumaris-net.ngx-components.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3VtYXJpcy1uZXQubmd4LWNvbXBvbmVudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zdW1hcmlzLW5ldC5uZ3gtY29tcG9uZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19