@wertzui/ngx-restworld-client 3.4.0 → 4.0.0

package/esm2020/lib/services/settings.service.mjs

@@ -1,46 +1,66 @@
-import { HttpClient } from "@angular/common/http";
 import { Injectable } from "@angular/core";
 import { RESTworldOptions } from "../models/restworld-options";
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/common/http";
-import * as i2 from "./restworld-client-collection";
+import * as i1 from "./restworld-client-collection";
 export class SettingsService {
-    constructor(backend, _clients) {
+    constructor(_clients) {
         this._clients = _clients;
         this.initializing = false;
         this.initialized = false;
-        this._client = new HttpClient(backend);
     }
     get settings() {
-        return this._settings;
+        return SettingsService._settings;
     }
     async ensureInitialized() {
         if (this.initializing || this.initialized)
             return;
         this.initializing = true;
-        await this.loadSettings();
+        await SettingsService.ensureSettingsAreLoaded();
         await this.populateRESTworldClientCollectionFromSettings();
         this.initialized = true;
         this.initializing = false;
     }
-    async loadSettings() {
-        this._settings = await this._client
-            .get('/settings')
-            .toPromise();
+    /**
+     * Call this method in your main.ts before calling bootstrapModule(...)
+     *
+     * Example:
+     * async function main() {
+     *   try {
+     *     await SettingsService.ensureSettingsAreLoaded();
+     *
+     *     const providers : StaticProvider[] = [
+     *       { provide: 'BASE_URL', useFactory: getBaseUrl, deps: [] }
+     *     ];
+     *
+     *     await platformBrowserDynamic(providers).bootstrapModule(AppModule);
+     *   }
+     *   catch (e) {
+     *     console.error(e);
+     *   }
+     * }
+     *
+     * main();
+     * */
+    static async ensureSettingsAreLoaded() {
+        if (SettingsService._settings === undefined) {
+            const response = await fetch('/settings');
+            const settings = await response.json();
+            SettingsService._settings = settings;
+        }
     }
     async populateRESTworldClientCollectionFromSettings() {
-        if (!this._settings?.apiUrls)
+        if (!this.settings?.apiUrls)
             return;
-        await Promise.all(this._settings.apiUrls
+        await Promise.all(this.settings.apiUrls
             .map(api => this._clients.addOrGetExistingClient(api.name, new RESTworldOptions(api.url, api.version))));
     }
 }
-SettingsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: SettingsService, deps: [{ token: i1.HttpBackend }, { token: i2.RESTworldClientCollection }], target: i0.ɵɵFactoryTarget.Injectable });
+SettingsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: SettingsService, deps: [{ token: i1.RESTworldClientCollection }], target: i0.ɵɵFactoryTarget.Injectable });
 SettingsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: SettingsService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: SettingsService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: i1.HttpBackend }, { type: i2.RESTworldClientCollection }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: function () { return [{ type: i1.RESTworldClientCollection }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dGluZ3Muc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZXN0d29ybGQtY2xpZW50L3NyYy9saWIvc2VydmljZXMvc2V0dGluZ3Muc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDOzs7QUFNL0QsTUFBTSxPQUFPLGVBQWU7SUFTMUIsWUFDVSxRQUFtQztRQUFuQyxhQUFRLEdBQVIsUUFBUSxDQUEyQjtRQUpyQyxpQkFBWSxHQUFHLEtBQUssQ0FBQztRQUNyQixnQkFBVyxHQUFHLEtBQUssQ0FBQztJQUk1QixDQUFDO0lBVEQsSUFBVyxRQUFRO1FBQ2pCLE9BQU8sZUFBZSxDQUFDLFNBQVMsQ0FBQztJQUNuQyxDQUFDO0lBU00sS0FBSyxDQUFDLGlCQUFpQjtRQUM1QixJQUFJLElBQUksQ0FBQyxZQUFZLElBQUksSUFBSSxDQUFDLFdBQVc7WUFDdkMsT0FBTztRQUVULElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDO1FBRXpCLE1BQU0sZUFBZSxDQUFDLHVCQUF1QixFQUFFLENBQUM7UUFDaEQsTUFBTSxJQUFJLENBQUMsNkNBQTZDLEVBQUUsQ0FBQztRQUUzRCxJQUFJLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQztRQUN4QixJQUFJLENBQUMsWUFBWSxHQUFHLEtBQUssQ0FBQztJQUU1QixDQUFDO0lBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O1NBb0JLO0lBQ0UsTUFBTSxDQUFDLEtBQUssQ0FBQyx1QkFBdUI7UUFDekMsSUFBSSxlQUFlLENBQUMsU0FBUyxLQUFLLFNBQVMsRUFBRTtZQUMzQyxNQUFNLFFBQVEsR0FBRyxNQUFNLEtBQUssQ0FBQyxXQUFXLENBQUMsQ0FBQztZQUMxQyxNQUFNLFFBQVEsR0FBbUIsTUFBTSxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDdkQsZUFBZSxDQUFDLFNBQVMsR0FBRyxRQUFRLENBQUM7U0FDdEM7SUFDSCxDQUFDO0lBRU8sS0FBSyxDQUFDLDZDQUE2QztRQUN6RCxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxPQUFPO1lBQ3pCLE9BQU87UUFFVCxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPO2FBQ3BDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsc0JBQXNCLENBQUMsR0FBRyxDQUFDLElBQUksRUFBRSxJQUFJLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzlHLENBQUM7OzRHQTlEVSxlQUFlO2dIQUFmLGVBQWUsY0FGZCxNQUFNOzJGQUVQLGVBQWU7a0JBSDNCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cEJhY2tlbmQsIEh0dHBDbGllbnQgfSBmcm9tIFwiQGFuZ3VsYXIvY29tbW9uL2h0dHBcIjtcclxuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IENsaWVudFNldHRpbmdzIH0gZnJvbSBcIi4uL21vZGVscy9jbGllbnQtc2V0dGluZ3NcIjtcclxuaW1wb3J0IHsgUkVTVHdvcmxkT3B0aW9ucyB9IGZyb20gXCIuLi9tb2RlbHMvcmVzdHdvcmxkLW9wdGlvbnNcIjtcclxuaW1wb3J0IHsgUkVTVHdvcmxkQ2xpZW50Q29sbGVjdGlvbiB9IGZyb20gXCIuL3Jlc3R3b3JsZC1jbGllbnQtY29sbGVjdGlvblwiO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgU2V0dGluZ3NTZXJ2aWNlIHtcclxuICBwcml2YXRlIHN0YXRpYyBfc2V0dGluZ3M6IENsaWVudFNldHRpbmdzIHwgdW5kZWZpbmVkO1xyXG4gIHB1YmxpYyBnZXQgc2V0dGluZ3MoKTogQ2xpZW50U2V0dGluZ3MgfCB1bmRlZmluZWQge1xyXG4gICAgcmV0dXJuIFNldHRpbmdzU2VydmljZS5fc2V0dGluZ3M7XHJcbiAgfVxyXG5cclxuICBwcml2YXRlIGluaXRpYWxpemluZyA9IGZhbHNlO1xyXG4gIHByaXZhdGUgaW5pdGlhbGl6ZWQgPSBmYWxzZTtcclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBwcml2YXRlIF9jbGllbnRzOiBSRVNUd29ybGRDbGllbnRDb2xsZWN0aW9uKSB7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgYXN5bmMgZW5zdXJlSW5pdGlhbGl6ZWQoKTogUHJvbWlzZTx2b2lkPiB7XHJcbiAgICBpZiAodGhpcy5pbml0aWFsaXppbmcgfHwgdGhpcy5pbml0aWFsaXplZClcclxuICAgICAgcmV0dXJuO1xyXG5cclxuICAgIHRoaXMuaW5pdGlhbGl6aW5nID0gdHJ1ZTtcclxuXHJcbiAgICBhd2FpdCBTZXR0aW5nc1NlcnZpY2UuZW5zdXJlU2V0dGluZ3NBcmVMb2FkZWQoKTtcclxuICAgIGF3YWl0IHRoaXMucG9wdWxhdGVSRVNUd29ybGRDbGllbnRDb2xsZWN0aW9uRnJvbVNldHRpbmdzKCk7XHJcblxyXG4gICAgdGhpcy5pbml0aWFsaXplZCA9IHRydWU7XHJcbiAgICB0aGlzLmluaXRpYWxpemluZyA9IGZhbHNlO1xyXG5cclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIENhbGwgdGhpcyBtZXRob2QgaW4geW91ciBtYWluLnRzIGJlZm9yZSBjYWxsaW5nIGJvb3RzdHJhcE1vZHVsZSguLi4pXHJcbiAgICogXHJcbiAgICogRXhhbXBsZTpcclxuICAgKiBhc3luYyBmdW5jdGlvbiBtYWluKCkge1xyXG4gICAqICAgdHJ5IHtcclxuICAgKiAgICAgYXdhaXQgU2V0dGluZ3NTZXJ2aWNlLmVuc3VyZVNldHRpbmdzQXJlTG9hZGVkKCk7XHJcbiAgICogXHJcbiAgICogICAgIGNvbnN0IHByb3ZpZGVycyA6IFN0YXRpY1Byb3ZpZGVyW10gPSBbXHJcbiAgICogICAgICAgeyBwcm92aWRlOiAnQkFTRV9VUkwnLCB1c2VGYWN0b3J5OiBnZXRCYXNlVXJsLCBkZXBzOiBbXSB9XHJcbiAgICogICAgIF07XHJcbiAgICogXHJcbiAgICogICAgIGF3YWl0IHBsYXRmb3JtQnJvd3NlckR5bmFtaWMocHJvdmlkZXJzKS5ib290c3RyYXBNb2R1bGUoQXBwTW9kdWxlKTtcclxuICAgKiAgIH1cclxuICAgKiAgIGNhdGNoIChlKSB7XHJcbiAgICogICAgIGNvbnNvbGUuZXJyb3IoZSk7XHJcbiAgICogICB9XHJcbiAgICogfVxyXG4gICAqIFxyXG4gICAqIG1haW4oKTtcclxuICAgKiAqL1xyXG4gIHB1YmxpYyBzdGF0aWMgYXN5bmMgZW5zdXJlU2V0dGluZ3NBcmVMb2FkZWQoKTogUHJvbWlzZTx2b2lkPiB7XHJcbiAgICBpZiAoU2V0dGluZ3NTZXJ2aWNlLl9zZXR0aW5ncyA9PT0gdW5kZWZpbmVkKSB7XHJcbiAgICAgIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgZmV0Y2goJy9zZXR0aW5ncycpO1xyXG4gICAgICBjb25zdCBzZXR0aW5nczogQ2xpZW50U2V0dGluZ3MgPSBhd2FpdCByZXNwb25zZS5qc29uKCk7XHJcbiAgICAgIFNldHRpbmdzU2VydmljZS5fc2V0dGluZ3MgPSBzZXR0aW5ncztcclxuICAgIH1cclxuICB9XHJcblxyXG4gIHByaXZhdGUgYXN5bmMgcG9wdWxhdGVSRVNUd29ybGRDbGllbnRDb2xsZWN0aW9uRnJvbVNldHRpbmdzKCk6IFByb21pc2U8dm9pZD4ge1xyXG4gICAgaWYgKCF0aGlzLnNldHRpbmdzPy5hcGlVcmxzKVxyXG4gICAgICByZXR1cm47XHJcblxyXG4gICAgYXdhaXQgUHJvbWlzZS5hbGwodGhpcy5zZXR0aW5ncy5hcGlVcmxzXHJcbiAgICAgIC5tYXAoYXBpID0+ICB0aGlzLl9jbGllbnRzLmFkZE9yR2V0RXhpc3RpbmdDbGllbnQoYXBpLm5hbWUsIG5ldyBSRVNUd29ybGRPcHRpb25zKGFwaS51cmwsIGFwaS52ZXJzaW9uKSkpKTtcclxuICB9XHJcblxyXG59XHJcbiJdfQ==