@sumaris-net/ngx-components 2.4.146 → 2.4.148

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

@@ -0,0 +1,79 @@
+import { Directive, Injectable } 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";
+import * as i1 from "@angular/common/http";
+export class EnvironmentLoader {
+}
+EnvironmentLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EnvironmentLoader, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+EnvironmentLoader.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: EnvironmentLoader, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EnvironmentLoader, decorators: [{
+            type: Directive
+        }] });
+export class EnvironmentHttpLoader extends EnvironmentLoader {
+    constructor(http, defaultEnvironment) {
+        super();
+        this.http = http;
+        this._logPrefix = '[environment-loader] ';
+        this._loaded = false;
+        // 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);
+        })));
+    }
+}
+EnvironmentHttpLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EnvironmentHttpLoader, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+EnvironmentHttpLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EnvironmentHttpLoader });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EnvironmentHttpLoader, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/environments/environment.mjs

@@ -12,7 +12,10 @@ import { StorageDrivers } from '../app/shared/storage/storage.utils';
 export const environment = Object.freeze({
     name: '@sumaris-net/ngx-components',
     version: undefined,
+    // 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',
@@ -24,51 +27,51 @@ export const environment = Object.freeze({
     peerMinVersion: '1.8.0',
     defaultPeer: {
         host: '192.168.0.45',
-        port: 8080
+        port: 8080,
     },
     defaultPeers: [
         {
             host: 'localhost',
-            port: 8080
+            port: 8080,
         },
         {
             host: 'localhost',
-            port: 8081
+            port: 8081,
         },
         {
             host: '192.168.0.45',
-            port: 8080
+            port: 8080,
         },
         {
             host: '192.168.0.24',
-            port: 8080
+            port: 8080,
         },
         {
             host: '192.168.0.29',
-            port: 8080
+            port: 8080,
         },
         {
             host: 'sih.sfa.sc',
-            port: 443
+            port: 443,
         },
         {
             host: 'test.sumaris.net',
-            port: 443
+            port: 443,
         },
         {
             host: 'open.sumaris.net',
-            port: 443
+            port: 443,
         },
         {
             host: 'server.e-is.pro',
-            port: 443
-        }
+            port: 443,
+        },
     ],
     defaultAppName: 'SUMARiS',
     defaultAndroidInstallUrl: 'https://play.google.com/store/apps/details?id=net.sumaris.app',
     // Storage
     storage: {
-        driverOrder: [StorageDrivers.SQLLite, StorageDrivers.IndexedDB, StorageDrivers.WebSQL, StorageDrivers.LocalStorage]
+        driverOrder: [StorageDrivers.SQLLite, StorageDrivers.IndexedDB, StorageDrivers.WebSQL, StorageDrivers.LocalStorage],
     },
     // About
     sourceUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components',
@@ -84,11 +87,11 @@ export const environment = Object.freeze({
     },
     account: {
         enableListenChanges: true,
-        listenIntervalInSeconds: 60
+        listenIntervalInSeconds: 60,
     },
     entityEditor: {
         enableListenChanges: true,
-        listenIntervalInSeconds: 60
-    }
+        listenIntervalInSeconds: 60,
+    },
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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