@openziti/ziti-console-lib 0.3.0

package/esm2022/lib/services/settings-service.class.mjs

@@ -0,0 +1,131 @@
+/*
+    Copyright NetFoundry Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+import { Injectable } from '@angular/core';
+import { HttpClient } from "@angular/common/http";
+import { BehaviorSubject } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../features/messaging/growler.service";
+// @ts-ignore
+const { service, growler, context, page, settings } = window;
+const DEFAULTS = {
+    "session": {},
+    "edgeControllers": [],
+    "editable": true,
+    "update": false,
+    "location": "../ziti",
+    "protocol": "http",
+    "host": "localhost",
+    "port": 1408,
+    "portTLS": 8443,
+    "rejectUnauthorized": false,
+    "mail": {
+        "host": "",
+        "port": 25,
+        "secure": false,
+        "auth": {
+            "user": "",
+            "pass": ""
+        }
+    },
+    "from": "",
+    "to": "",
+};
+class SettingsServiceClass {
+    constructor(httpBackend, growlerService) {
+        this.httpBackend = httpBackend;
+        this.growlerService = growlerService;
+        this.name = "settings";
+        this.settings = {};
+        this.versionData = {};
+        this.settingsChange = new BehaviorSubject({});
+        this.rejectUnauthorized = false;
+        this.port = DEFAULTS.port;
+        this.portTLS = DEFAULTS.portTLS;
+        this.apiVersions = [];
+        this.protocol = DEFAULTS.protocol;
+        this.host = DEFAULTS.host;
+        this.supportedFeatures = {
+            organization: false,
+            tags: false,
+            customFields: false,
+            mailer: false,
+            recipes: false
+        };
+        this.httpClient = new HttpClient(httpBackend);
+    }
+    get() {
+        const tmp = localStorage.getItem('ziti.settings');
+        if (tmp) {
+            this.settings = JSON.parse(tmp);
+        }
+        else {
+            this.settings = { ...DEFAULTS };
+            localStorage.setItem('ziti.settings', JSON.stringify(this.settings));
+        }
+        settings.data = this.settings;
+        context.set(this.name, this.settings);
+        this.settingsChange.next(this.settings);
+    }
+    set(data) {
+        this.settings = data;
+        localStorage.setItem('ziti.settings', JSON.stringify(data));
+        context.set(this.name, this.settings);
+        this.settingsChange.next(this.settings);
+    }
+    version() {
+        this.versionData = localStorage.getItem('ziti.version');
+        context.set("version", this.versionData);
+        this.settings = { ...this.settings, version: this.versionData };
+        this.settingsChange.next(this.settings);
+    }
+    delete(url) {
+        service.call("server", { url: url }, this.deleted, "DELETE");
+    }
+    deleted(e) {
+        if (page != null && page.deleting != null && page.deleting == this.versionData.baseUrl) {
+            window.location.href = "/login";
+        }
+    }
+    getHttpOptions() {
+        const options = {
+            headers: {
+                accept: '*',
+            },
+            params: {},
+            responseType: 'text',
+        };
+        return options;
+    }
+    addContoller(name, url) {
+        if (name.trim().length == 0 || url.trim().length == 0) {
+            growler.error("Name and URL required");
+        }
+        else {
+            this.controllerSave(name, url);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SettingsServiceClass, deps: [{ token: i1.HttpBackend }, { token: i2.GrowlerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SettingsServiceClass, providedIn: 'root' }); }
+}
+export { SettingsServiceClass };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SettingsServiceClass, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpBackend }, { type: i2.GrowlerService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settings-service.class.js","sourceRoot":"","sources":["../../../../../projects/ziti-console-lib/src/lib/services/settings-service.class.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n    Copyright NetFoundry Inc.\n\n    Licensed under the Apache License, Version 2.0 (the \"License\");\n    you may not use this file except in compliance with the License.\n    You may obtain a copy of the License at\n\n    https://www.apache.org/licenses/LICENSE-2.0\n\n    Unless required by applicable law or agreed to in writing, software\n    distributed under the License is distributed on an \"AS IS\" BASIS,\n    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n    See the License for the specific language governing permissions and\n    limitations under the License.\n*/\n\nimport {Injectable} from '@angular/core';\nimport {isEmpty, defer} from \"lodash\";\nimport {HttpBackend, HttpClient} from \"@angular/common/http\";\nimport {BehaviorSubject, firstValueFrom, map, tap} from \"rxjs\";\nimport {catchError} from \"rxjs/operators\";\nimport {GrowlerService} from \"../features/messaging/growler.service\";\n\n// @ts-ignore\nconst {service, growler, context, page, settings} = window;\nconst DEFAULTS = {\n    \"session\": {},\n    \"edgeControllers\": [],\n    \"editable\": true,\n    \"update\": false,\n    \"location\": \"../ziti\",\n    \"protocol\": \"http\",\n    \"host\": \"localhost\",\n    \"port\": 1408,\n    \"portTLS\": 8443,\n    \"rejectUnauthorized\": false,\n    \"mail\": {\n        \"host\": \"\",\n        \"port\": 25,\n        \"secure\": false,\n        \"auth\": {\n            \"user\": \"\",\n            \"pass\": \"\"\n        }\n    },\n    \"from\": \"\",\n    \"to\": \"\",\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport abstract class SettingsServiceClass {\n\n    name = \"settings\";\n    settings: any = {};\n    versionData: any = {};\n    settingsChange = new BehaviorSubject<any>({})\n    rejectUnauthorized = false;\n    port = DEFAULTS.port;\n    portTLS = DEFAULTS.portTLS;\n    apiVersions: any[] = [];\n    protocol = DEFAULTS.protocol;\n    host = DEFAULTS.host;\n    httpClient: HttpClient;\n\n    public supportedFeatures: any = {\n        organization: false,\n        tags: false,\n        customFields: false,\n        mailer: false,\n        recipes: false\n    }\n\n    constructor(protected httpBackend: HttpBackend, protected growlerService: GrowlerService) {\n        this.httpClient = new HttpClient(httpBackend);\n    }\n\n    public abstract init();\n    public abstract controllerSave(name: string, url: string);\n    public abstract initApiVersions(url);\n    public abstract loadSettings();\n\n    public get() {\n        const tmp = localStorage.getItem('ziti.settings');\n        if (tmp) {\n            this.settings = JSON.parse(tmp);\n        } else {\n            this.settings = {...DEFAULTS};\n            localStorage.setItem('ziti.settings', JSON.stringify(this.settings));\n        }\n        settings.data = this.settings;\n        context.set(this.name, this.settings);\n        this.settingsChange.next(this.settings)\n    }\n\n    public set(data: any) {\n        this.settings = data;\n        localStorage.setItem('ziti.settings', JSON.stringify(data));\n        context.set(this.name, this.settings);\n        this.settingsChange.next(this.settings);\n    }\n\n    public version() {\n        this.versionData = localStorage.getItem('ziti.version');\n        context.set(\"version\", this.versionData);\n        this.settings = {...this.settings, version: this.versionData};\n        this.settingsChange.next(this.settings)\n    }\n\n    public delete(url: string) {\n        service.call(\"server\", {url: url}, this.deleted, \"DELETE\");\n    }\n\n    public deleted(e: any) {\n        if (page != null && page.deleting != null && page.deleting == this.versionData.baseUrl) {\n            window.location.href = \"/login\";\n        }\n    }\n\n    public getHttpOptions() {\n        const options: any = {\n            headers: {\n                accept: '*',\n            },\n            params: {},\n            responseType: 'text' as const,\n        };\n        return options;\n    }\n\n    public addContoller(name: string, url: string) {\n        if (name.trim().length == 0 || url.trim().length == 0) {\n            growler.error(\"Name and URL required\");\n        } else {\n            this.controllerSave(name, url);\n        }\n    }\n}\n"]}

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

@@ -0,0 +1,193 @@
+/*
+    Copyright NetFoundry Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+import { Injectable, InjectionToken } from '@angular/core';
+import { firstValueFrom, map, tap } from "rxjs";
+import { catchError } from "rxjs/operators";
+import { SettingsServiceClass } from "./settings-service.class";
+import { GrowlerModel } from "../features/messaging/growler.model";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../features/messaging/growler.service";
+export const SETTINGS_SERVICE = new InjectionToken('SETTINGS_SERVICE');
+// @ts-ignore
+const { service, growler, context, page, settings } = window;
+const DEFAULTS = {
+    "session": {},
+    "edgeControllers": [],
+    "editable": true,
+    "update": false,
+    "location": "../ziti",
+    "protocol": "http",
+    "host": "localhost",
+    "port": 1408,
+    "portTLS": 8443,
+    "rejectUnauthorized": false,
+    "mail": {
+        "host": "",
+        "port": 25,
+        "secure": false,
+        "auth": {
+            "user": "",
+            "pass": ""
+        }
+    },
+    "from": "",
+    "to": "",
+};
+const DEFAULT_API_VERSIONS = {
+    "edge": {
+        "v1": {
+            "apiBaseUrls": [
+                `${window.origin}/edge/client/v1`
+            ],
+            "path": "/edge/client/v1"
+        }
+    },
+    "edge-client": {
+        "v1": {
+            "apiBaseUrls": [
+                `${window.origin}/edge/client/v1`
+            ],
+            "path": "/edge/client/v1"
+        }
+    },
+    "edge-management": {
+        "v1": {
+            "apiBaseUrls": [
+                `${window.origin}/edge/management/v1`
+            ],
+            "path": "/edge/management/v1"
+        }
+    }
+};
+class SettingsService extends SettingsServiceClass {
+    constructor(httpBackend, growlerService) {
+        super(httpBackend, growlerService);
+        this.httpBackend = httpBackend;
+        this.growlerService = growlerService;
+    }
+    init() {
+        this.get();
+        this.version();
+        if (this.settings.port && !isNaN(this.settings.port))
+            this.port = this.settings.port;
+        if (this.settings.portTLS && !isNaN(this.settings.portTLS))
+            this.portTLS = this.settings.portTLS;
+        if (this.settings.rejectUnauthorized && !isNaN(this.settings.rejectUnauthorized))
+            this.rejectUnauthorized = this.settings.rejectUnauthorized;
+        if (this.settings.selectedEdgeController)
+            return this.initApiVersions(this.settings.selectedEdgeController);
+        else
+            return Promise.resolve();
+    }
+    loadSettings() {
+        //this is a no-op for the default settings service
+    }
+    controllerSave(name, url) {
+        url = url.split('#').join('').split('?').join('');
+        if (url.endsWith('/'))
+            url = url.substr(0, url.length - 1);
+        if (!url.startsWith('https://') && !url.startsWith('http://'))
+            url = 'https://' + url;
+        const callUrl = url + "/edge/management/v1/version?rejectUnauthorized=" + this.rejectUnauthorized;
+        firstValueFrom(this.httpClient.get(callUrl).pipe(catchError((err) => {
+            throw "Edge Controller not Online: " + err?.message;
+        }))).then((body) => {
+            try {
+                if (body.error) {
+                    growler.error("Invalid Edge Controller: " + body.error);
+                }
+                else {
+                    if (body?.data?.apiVersions?.edge?.v1 != null) {
+                        this.apiVersions = body.data.apiVersions;
+                        let found = false;
+                        if (this.settings.edgeControllers?.length > 0) {
+                            for (let i = 0; i < this.settings.edgeControllers.length; i++) {
+                                if (this.settings.edgeControllers[i].url == url) {
+                                    found = true;
+                                    this.settings.edgeControllers[i].name = name;
+                                    this.settings.edgeControllers[i].url = url;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!found) {
+                            let isDefault = false;
+                            if (!this.settings.edgeControllers)
+                                this.settings.edgeControllers = [];
+                            if (this.settings.edgeControllers?.length === 0)
+                                isDefault = true;
+                            this.settings.edgeControllers.push({
+                                name: name,
+                                url: url,
+                                default: isDefault
+                            });
+                        }
+                        this.settings.selectedEdgeController = url;
+                        this.set(this.settings);
+                    }
+                    else {
+                        growler.error("Invalid Edge Controller: " + JSON.stringify(body));
+                    }
+                }
+            }
+            catch (e) {
+                growler.error("Invalid Edge Controller: " + e);
+            }
+        }).catch(err => {
+            growler.error(err);
+        });
+    }
+    initApiVersions(url) {
+        url = url.split('#').join('').split('?').join('');
+        if (url.endsWith('/'))
+            url = url.substr(0, url.length - 1);
+        if (!url.startsWith('https://') && !url.startsWith('http://'))
+            url = 'https://' + url;
+        const callUrl = url + "/edge/management/v1/version?rejectUnauthorized=false";
+        return firstValueFrom(this.httpClient.get(callUrl)
+            .pipe(tap((body) => {
+            try {
+                if (body.error) {
+                    growler.error("Invalid Edge Controller: " + body.error);
+                }
+                else {
+                    this.apiVersions = body.data.apiVersions;
+                }
+            }
+            catch (e) {
+                growler.error("Invalid Edge Controller: " + body);
+            }
+        }), catchError((err) => {
+            this.apiVersions = DEFAULT_API_VERSIONS;
+            const growlerData = new GrowlerModel('error', 'Error', `Edge Controller`, `Failed to connect to Edge Controller: ${err?.message}`);
+            const res = { data: this.apiVersions };
+            return Promise.resolve(res);
+        }), map((body) => {
+            return body?.data?.apiVersions;
+        })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SettingsService, deps: [{ token: i1.HttpBackend }, { token: i2.GrowlerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SettingsService, providedIn: 'root' }); }
+}
+export { SettingsService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpBackend }, { type: i2.GrowlerService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settings.service.js","sourceRoot":"","sources":["../../../../../projects/ziti-console-lib/src/lib/services/settings.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n    Copyright NetFoundry Inc.\n\n    Licensed under the Apache License, Version 2.0 (the \"License\");\n    you may not use this file except in compliance with the License.\n    You may obtain a copy of the License at\n\n    https://www.apache.org/licenses/LICENSE-2.0\n\n    Unless required by applicable law or agreed to in writing, software\n    distributed under the License is distributed on an \"AS IS\" BASIS,\n    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n    See the License for the specific language governing permissions and\n    limitations under the License.\n*/\n\nimport {Injectable, Inject, InjectionToken} from '@angular/core';\nimport {firstValueFrom, map, tap} from \"rxjs\";\nimport {catchError} from \"rxjs/operators\";\nimport {isEmpty, defer} from \"lodash\";\nimport {HttpBackend, HttpClient} from \"@angular/common/http\";\nimport {SettingsServiceClass} from \"./settings-service.class\";\nimport {GrowlerService} from \"../features/messaging/growler.service\";\nimport {GrowlerModel} from \"../features/messaging/growler.model\";\n\nexport const SETTINGS_SERVICE = new InjectionToken<SettingsServiceClass>('SETTINGS_SERVICE');\n\n// @ts-ignore\nconst {service, growler, context, page, settings} = window;\nconst DEFAULTS = {\n    \"session\": {},\n    \"edgeControllers\": [],\n    \"editable\": true,\n    \"update\": false,\n    \"location\": \"../ziti\",\n    \"protocol\": \"http\",\n    \"host\": \"localhost\",\n    \"port\": 1408,\n    \"portTLS\": 8443,\n    \"rejectUnauthorized\": false,\n    \"mail\": {\n        \"host\": \"\",\n        \"port\": 25,\n        \"secure\": false,\n        \"auth\": {\n            \"user\": \"\",\n            \"pass\": \"\"\n        }\n    },\n    \"from\": \"\",\n    \"to\": \"\",\n}\n\nconst DEFAULT_API_VERSIONS: any = {\n    \"edge\": {\n      \"v1\": {\n        \"apiBaseUrls\": [\n          `${window.origin}/edge/client/v1`\n        ],\n        \"path\": \"/edge/client/v1\"\n      }\n    },\n    \"edge-client\": {\n      \"v1\": {\n        \"apiBaseUrls\": [\n          `${window.origin}/edge/client/v1`\n        ],\n        \"path\": \"/edge/client/v1\"\n      }\n    },\n    \"edge-management\": {\n      \"v1\": {\n        \"apiBaseUrls\": [\n          `${window.origin}/edge/management/v1`\n        ],\n        \"path\": \"/edge/management/v1\"\n      }\n    }\n  };\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SettingsService extends SettingsServiceClass {\n\n    constructor(override httpBackend: HttpBackend, override growlerService: GrowlerService) {\n        super(httpBackend, growlerService);\n    }\n\n    init() {\n        this.get();\n        this.version();\n\n        if (this.settings.port && !isNaN(this.settings.port)) this.port = this.settings.port;\n        if (this.settings.portTLS && !isNaN(this.settings.portTLS)) this.portTLS = this.settings.portTLS;\n        if (this.settings.rejectUnauthorized && !isNaN(this.settings.rejectUnauthorized)) this.rejectUnauthorized = this.settings.rejectUnauthorized;\n        if (this.settings.selectedEdgeController) return this.initApiVersions(this.settings.selectedEdgeController);\n        else return Promise.resolve();\n    }\n\n    override loadSettings() {\n        //this is a no-op for the default settings service\n    }\n\n    override controllerSave(name: string, url: string) {\n        url = url.split('#').join('').split('?').join('');\n        if (url.endsWith('/')) url = url.substr(0, url.length - 1);\n        if (!url.startsWith('https://') && !url.startsWith('http://')) url = 'https://' + url;\n        const callUrl = url + \"/edge/management/v1/version?rejectUnauthorized=\" + this.rejectUnauthorized;\n        firstValueFrom(this.httpClient.get(callUrl).pipe(catchError((err: any) => {\n            throw \"Edge Controller not Online: \" + err?.message;\n        }))).then((body: any) => {\n            try {\n                if (body.error) {\n                    growler.error(\"Invalid Edge Controller: \" + body.error);\n                } else {\n                    if (body?.data?.apiVersions?.edge?.v1 != null) {\n                        this.apiVersions = body.data.apiVersions;\n                        let found = false;\n                        if (this.settings.edgeControllers?.length > 0) {\n                            for (let i = 0; i < this.settings.edgeControllers.length; i++) {\n                                if (this.settings.edgeControllers[i].url == url) {\n                                    found = true;\n                                    this.settings.edgeControllers[i].name = name;\n                                    this.settings.edgeControllers[i].url = url;\n                                    break;\n                                }\n                            }\n                        }\n                        if (!found) {\n                            let isDefault = false;\n                            if (!this.settings.edgeControllers) this.settings.edgeControllers = [];\n                            if (this.settings.edgeControllers?.length === 0) isDefault = true;\n                            this.settings.edgeControllers.push({\n                                name: name,\n                                url: url,\n                                default: isDefault\n                            });\n                        }\n                        this.settings.selectedEdgeController = url;\n                        this.set(this.settings);\n\n                    } else {\n                        growler.error(\"Invalid Edge Controller: \" + JSON.stringify(body));\n                    }\n                }\n            } catch (e) {\n                growler.error(\"Invalid Edge Controller: \" + e);\n            }\n        }).catch(err => {\n            growler.error(err);\n        });\n    }\n\n    public initApiVersions(url: string) {\n        url = url.split('#').join('').split('?').join('');\n        if (url.endsWith('/')) url = url.substr(0, url.length - 1);\n        if (!url.startsWith('https://') && !url.startsWith('http://')) url = 'https://' + url;\n        const callUrl = url + \"/edge/management/v1/version?rejectUnauthorized=false\";\n        return firstValueFrom(this.httpClient.get(callUrl)\n            .pipe(\n                tap((body: any) => {\n                    try {\n                        if (body.error) {\n                            growler.error(\"Invalid Edge Controller: \" + body.error);\n                        } else {\n                            this.apiVersions = body.data.apiVersions;\n                        }\n                    } catch (e) {\n                        growler.error(\"Invalid Edge Controller: \" + body);\n                    }\n                }),\n                catchError((err: any) => {\n                    this.apiVersions = DEFAULT_API_VERSIONS;\n                    const growlerData = new GrowlerModel(\n                        'error',\n                        'Error',\n                        `Edge Controller`,\n                        `Failed to connect to Edge Controller: ${err?.message}`,\n                    );\n                    const res: any = {data: this.apiVersions};\n                    return Promise.resolve(res);\n                }),\n                map((body: any) => {\n                    return body?.data?.apiVersions\n                })));\n    }\n}\n"]}

package/esm2022/lib/services/tab-name.service.mjs

@@ -0,0 +1,65 @@
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { SETTINGS_SERVICE } from "./settings.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./settings-service.class";
+export const ZITI_TAB_OVERRIDES = new InjectionToken('ZITI_TAB_OVERRIDES');
+export class NoopTabInterceptorService {
+    override(key, tabs) {
+        return tabs;
+    }
+}
+class TabNameService {
+    constructor(interceptor, settings) {
+        this.interceptor = interceptor;
+        this.settings = settings;
+        this.pageToTabsMap = new Map([
+            ["identities", [
+                    { label: 'Identities', url: '/identities' },
+                    { label: 'Recipes', url: '/recipes', hidden: !this.settings.supportedFeatures?.recipies },
+                    { label: 'Terminators', url: '/terminators' },
+                    { label: 'Posture Checks', url: '/posture-checks' },
+                ]
+            ],
+            ["services", [
+                    { label: 'Services', url: '/services' },
+                    { label: 'Configurations', url: '/configs' },
+                    { label: 'Config Types', url: '/config-types' },
+                ]
+            ],
+            ["routers", [
+                    { label: 'Routers', url: '/routers' },
+                    { label: 'Transit Routers', url: '/transit-routers' },
+                    { label: 'Router Policies', url: '/router-policies' },
+                ],
+            ],
+            ["policies", [
+                    { label: 'Service Policies', url: '/service-policies' },
+                    { label: 'Router Policies', url: '/router-policies' },
+                    { label: 'Service Router Policies', url: '/service-router-policies' },
+                    { label: 'Auth Policies', url: '/auth-policies' },
+                    { label: 'JWT Signers', url: '/jwt-signers' },
+                ],
+            ],
+        ]);
+    }
+    getTabs(key) {
+        const val = this.pageToTabsMap.get(key);
+        return this.interceptor.override(key, val);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TabNameService, deps: [{ token: ZITI_TAB_OVERRIDES }, { token: SETTINGS_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TabNameService, providedIn: 'root' }); }
+}
+export { TabNameService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TabNameService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ZITI_TAB_OVERRIDES]
+                }] }, { type: i1.SettingsServiceClass, decorators: [{
+                    type: Inject,
+                    args: [SETTINGS_SERVICE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/validation.service.mjs

@@ -0,0 +1,124 @@
+import { Injectable } from "@angular/core";
+import { includes, isNil, isNumber } from "lodash";
+import * as i0 from "@angular/core";
+class ValidationService {
+    getPortRanges(allowedPortRanges) {
+        if (!allowedPortRanges) {
+            return undefined;
+        }
+        const ranges = [];
+        allowedPortRanges.forEach((val) => {
+            const vals = val.split('-');
+            if (vals.length === 1) {
+                const port = parseInt(val);
+                ranges.push({ high: port, low: port });
+            }
+            else if (vals.length === 2) {
+                const port1 = parseInt(vals[0]);
+                const port2 = parseInt(vals[1]);
+                ranges.push({ low: port1, high: port2 });
+            }
+            else {
+                // do nothing, invalid range
+            }
+        });
+        return ranges;
+    }
+    combinePortRanges(allowedPortRanges) {
+        const val = [];
+        if (!allowedPortRanges) {
+            return val;
+        }
+        allowedPortRanges.forEach((range) => {
+            if (range.low === range.high) {
+                val.push(range.low + '');
+            }
+            else {
+                val.push(range.low + '-' + range.high);
+            }
+        });
+        return val;
+    }
+    parsePortRanges(portRanges) {
+        const parsedPortRanges = [];
+        if (!portRanges) {
+            return parsedPortRanges;
+        }
+        portRanges.forEach((val) => {
+            const vals = val.split('-');
+            if (vals.length === 1) {
+                const port = parseInt(val);
+                parsedPortRanges.push({
+                    low: port,
+                    high: port
+                });
+            }
+            else if (vals.length === 2) {
+                const port1 = parseInt(vals[0]);
+                const port2 = parseInt(vals[1]);
+                parsedPortRanges.push({
+                    low: port1,
+                    high: port2
+                });
+            }
+        });
+        return parsedPortRanges;
+    }
+    validatePortRanges(portRanges) {
+        let invalid = false;
+        if (!portRanges) {
+            return invalid;
+        }
+        portRanges.forEach((range) => {
+            if (!this.isValidPort(range.low) || !this.isValidPort(range.high)) {
+                invalid = true;
+                return;
+            }
+            else if (range.low > range.high) {
+                invalid = true;
+                return;
+            }
+        });
+        return invalid;
+    }
+    isValidPort(port) {
+        return !isNaN(port) && isNumber(port) && port >= 1 && port <= 65535;
+    }
+    isValidInterceptHost(address) {
+        return includes(address, '.');
+    }
+    redefineObject(obj) {
+        for (let prop in obj) {
+            if (Array.isArray(obj[prop]) && obj[prop].length == 0) {
+                delete obj[prop];
+            }
+            else {
+                if (typeof obj[prop] === "string" && obj[prop].trim().length == 0) {
+                    delete obj[prop];
+                }
+                else if (isNil(obj[prop])) {
+                    delete obj[prop];
+                }
+                else {
+                    if (typeof obj[prop] === "object") {
+                        obj[prop] = this.redefineObject(obj[prop]);
+                        if (Object.keys(obj[prop]).length == 0) {
+                            delete obj[prop];
+                        }
+                    }
+                }
+            }
+        }
+        return obj;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValidationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValidationService, providedIn: 'root' }); }
+}
+export { ValidationService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValidationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.service.js","sourceRoot":"","sources":["../../../../../projects/ziti-console-lib/src/lib/services/validation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from \"@angular/core\";\nimport {includes, isEmpty, isNil, isNumber} from \"lodash\";\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ValidationService {\n\n    getPortRanges(allowedPortRanges) {\n        if (!allowedPortRanges) {\n            return undefined;\n        }\n        const ranges = [];\n        allowedPortRanges.forEach((val: string) => {\n            const vals = val.split('-');\n            if (vals.length === 1) {\n                const port = parseInt(val);\n                ranges.push({high: port, low: port});\n            } else if (vals.length === 2) {\n                const port1 = parseInt(vals[0]);\n                const port2 = parseInt(vals[1]);\n                ranges.push({low: port1, high: port2});\n            } else {\n                // do nothing, invalid range\n            }\n        });\n        return ranges;\n    }\n\n    combinePortRanges(allowedPortRanges) {\n        const val = [];\n        if (!allowedPortRanges) {\n            return val;\n        }\n        allowedPortRanges.forEach((range: any) => {\n            if (range.low === range.high) {\n                val.push(range.low + '');\n            } else {\n                val.push(range.low + '-' + range.high);\n            }\n        });\n        return val;\n    }\n\n    parsePortRanges(portRanges) {\n        const parsedPortRanges = [];\n        if (!portRanges) {\n            return parsedPortRanges;\n        }\n        portRanges.forEach((val: string) => {\n            const vals = val.split('-');\n            if (vals.length === 1) {\n                const port = parseInt(val);\n                parsedPortRanges.push({\n                    low: port,\n                    high: port\n                });\n            } else if (vals.length === 2) {\n                const port1 = parseInt(vals[0]);\n                const port2 = parseInt(vals[1]);\n                parsedPortRanges.push({\n                    low: port1,\n                    high: port2\n                });\n            }\n        });\n        return parsedPortRanges;\n    }\n\n    validatePortRanges(portRanges) {\n        let invalid = false;\n        if (!portRanges) {\n            return invalid;\n        }\n        portRanges.forEach((range: any) => {\n            if (!this.isValidPort(range.low) || !this.isValidPort(range.high)) {\n                invalid = true;\n                return;\n            } else if (range.low > range.high) {\n                invalid = true;\n                return;\n            }\n        });\n        return invalid;\n    }\n\n    isValidPort(port) {\n        return !isNaN(port) && isNumber(port) && port >= 1 && port <= 65535;\n    }\n\n    isValidInterceptHost(address) {\n        return includes(address, '.');\n    }\n\n    redefineObject(obj) {\n        for (let prop in obj) {\n            if (Array.isArray(obj[prop]) && obj[prop].length==0) {\n                delete obj[prop];\n            } else {\n                if (typeof obj[prop] === \"string\" && obj[prop].trim().length==0) {\n                    delete obj[prop];\n                } else if (isNil(obj[prop])) {\n                    delete obj[prop];\n                } else {\n                    if (typeof obj[prop] === \"object\") {\n                        obj[prop] = this.redefineObject(obj[prop]);\n                        if (Object.keys(obj[prop]).length==0) {\n                            delete obj[prop];\n                        }\n                    }\n                }\n            }\n        }\n        return obj;\n    }\n}"]}