@stemy/ngx-utils 12.1.3 → 13.0.2

package/esm2020/ngx-utils/services/base-http.service.mjs

@@ -0,0 +1,298 @@
+import { Inject, Injectable, Optional } from "@angular/core";
+import { HttpEventType } from "@angular/common/http";
+import { CONFIG_SERVICE, EXPRESS_REQUEST, HttpPromise, LANGUAGE_SERVICE, TOASTER_SERVICE } from "../common-types";
+import { ObjectUtils } from "../utils/object.utils";
+import { MathUtils } from "../utils/math.utils";
+import { BaseHttpClient } from "./base-http.client";
+import { StorageService } from "./storage.service";
+import { timeout } from "rxjs/operators";
+import { TimeoutError } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "./base-http.client";
+import * as i2 from "./storage.service";
+export class BaseHttpService {
+    constructor(client, storage, language, toaster, configs, request = null) {
+        this.client = client;
+        this.storage = storage;
+        this.language = language;
+        this.toaster = toaster;
+        this.configs = configs;
+        this.request = request;
+        this.requestHeaders = {};
+        this.requestParams = {};
+        this.cache = {};
+    }
+    get name() {
+        return "base";
+    }
+    get withCredentials() {
+        return true;
+    }
+    static retryFailedRequests() {
+        BaseHttpService.failedRequests.forEach(r => r());
+        BaseHttpService.failedRequests = [];
+    }
+    get universal() {
+        return this.storage.universal;
+    }
+    url(url) {
+        return url;
+    }
+    createUrl(url, params) {
+        const httpParams = this.client.makeParams(params);
+        const query = httpParams.keys().map(key => {
+            return `${key}=${httpParams.get(key)}`;
+        }).join("&");
+        return `${this.url(url)}?${query}`;
+    }
+    makeListParams(page, itemsPerPage, orderBy = null, orderDescending = null, filter = null) {
+        const params = {
+            page: (page - 1),
+            limit: itemsPerPage
+        };
+        if (!ObjectUtils.isNullOrUndefined(orderBy) && !ObjectUtils.isNullOrUndefined(orderDescending)) {
+            params.sort = `${orderDescending ? "-" : ""}${orderBy}`;
+        }
+        if (!ObjectUtils.isNullOrUndefined(filter)) {
+            params.filter = filter;
+        }
+        return params;
+    }
+    getPromise(url, options, body) {
+        options = this.makeOptions(options, "GET", body);
+        return this.toPromise(url, options);
+    }
+    deletePromise(url, options, body) {
+        options = this.makeOptions(options, "DELETE", body);
+        return this.toPromise(url, options);
+    }
+    postPromise(url, body, options) {
+        options = this.makeOptions(options, "POST", body);
+        return this.toPromise(url, options);
+    }
+    putPromise(url, body, options) {
+        options = this.makeOptions(options, "PUT", body);
+        return this.toPromise(url, options);
+    }
+    patchPromise(url, body, options) {
+        options = this.makeOptions(options, "PATCH", body);
+        return this.toPromise(url, options);
+    }
+    uploadPromise(url, body, listener, options) {
+        const headers = {};
+        if (body instanceof Blob) {
+            headers["Content-Type"] = "application/octet-stream";
+        }
+        options = this.makeOptions(Object.assign({
+            headers: headers,
+            reportProgress: true
+        }, options), "POST", body);
+        return this.toPromise(url, options, listener);
+    }
+    listPromise(url, params) {
+        return new Promise(resolve => {
+            this.getPromise(url, { params: params }).then(data => {
+                if (ObjectUtils.isArray(data)) {
+                    resolve({
+                        total: data.length,
+                        items: data,
+                        meta: {}
+                    });
+                    return;
+                }
+                resolve({
+                    total: data.meta?.total || data?.total || data.items?.length || 0,
+                    items: data.items || [],
+                    meta: data.meta || {}
+                });
+            }, response => {
+                if (response.status == 0 || response.status == 301) {
+                    resolve({
+                        total: 1,
+                        items: [{
+                                id: null,
+                                label: "Not implemented."
+                            }],
+                        meta: {}
+                    });
+                    return true;
+                }
+                resolve({
+                    total: 0,
+                    items: [],
+                    meta: {}
+                });
+                return false;
+            });
+        });
+    }
+    handleUnauthorizedError(absoluteUrl, options, reject) {
+        reject();
+        if (BaseHttpService.failedRequests.length > 1) {
+            return;
+        }
+        if (this.universal.isServer)
+            return;
+        console.log("User auth error", absoluteUrl, options);
+    }
+    toastWarning(message, issueContext, reason, options) {
+        this.toaster.warning(message, { issueContext, reason, options });
+    }
+    toastError(message, issueContext, reason, options) {
+        this.toaster.warning(message, { issueContext, reason, options });
+    }
+    toPromise(url, options, listener) {
+        const issueContext = { url: "" };
+        return new HttpPromise(response => {
+            if (!response) {
+                if (this.universal.isServer)
+                    return;
+                console.log("You may not need a reject Handler for this request!", this.name, url, options);
+                return;
+            }
+            const reason = response.error || {};
+            if (response.status == 0 || response.status == 301) {
+                this.toastWarning(`${url} endpoint is not implemented! Click here, to quickly create an issue.`, issueContext, reason, options);
+                return;
+            }
+            const regex = /((E11000 duplicate key error collection: (.)+\.)|(_1 dup key:(.)+))/g;
+            if (reason.message && regex.test(reason.message)) {
+                this.toastError("message.duplicate-key.error." + reason.message.replace(regex, "").replace(" index: ", "-"), issueContext, reason, options);
+                return;
+            }
+            this.toastWarning(`${url} endpoint error is not handled properly! Click here, to quickly create an issue.`, issueContext, reason, options);
+        }, (resolve, reject) => {
+            this.absoluteUrl(url, options).then(absoluteUrl => {
+                issueContext.url = absoluteUrl;
+                const request = this.client.request(options.method, absoluteUrl, options);
+                const finalRequest = ObjectUtils.isNumber(options.timeout) && options.timeout > 0
+                    ? request.pipe(timeout(options.timeout)) : request;
+                finalRequest.subscribe((event) => {
+                    if (options.reportProgress && event.type === HttpEventType.UploadProgress) {
+                        const progress = {
+                            percentage: MathUtils.round(event.loaded / event.total, 2, 0.01),
+                            loaded: event.loaded,
+                            total: event.total
+                        };
+                        if (listener) {
+                            listener(progress);
+                        }
+                        return;
+                    }
+                    resolve(this.parseResponse(event, url, options));
+                    const headers = options.headers;
+                    const authKey = "Authorization";
+                    // If we use token auth
+                    if (this.client.renewTokenFunc && headers.has(authKey)) {
+                        const currentTime = new Date().getTime();
+                        const userTokenTime = this.storage.get("userTokenTime") || currentTime;
+                        // And the last request was a long long time ago
+                        if (currentTime - 600000 > userTokenTime) {
+                            this.client.renewTokenFunc();
+                        }
+                    }
+                }, (response) => {
+                    if (response instanceof TimeoutError || response.status == 0 || response.status == 301) {
+                        reject(response);
+                        return;
+                    }
+                    const headers = options.headers;
+                    const authKey = "Authorization";
+                    // If an authorization header exists and we still have an Unauthorized response prompt the user to log in again
+                    if (headers.has(authKey) && response.status == 401) {
+                        const pushed = this.pushFailedRequest(url, options, () => {
+                            options.headers = this.makeHeaders(options.originalHeaders);
+                            this.toPromise(url, options, listener).then(resolve, reject);
+                        });
+                        if (pushed)
+                            this.handleUnauthorizedError(absoluteUrl, options, () => reject(response));
+                        return;
+                    }
+                    reject(response);
+                });
+            });
+        });
+    }
+    pushFailedRequest(url, options, req) {
+        if (url.indexOf("tokens") >= 0)
+            return false;
+        BaseHttpService.failedRequests.push(req);
+        return true;
+    }
+    checkHeaders(headers) {
+        if (!headers || !headers.cookie || !headers.referer || !headers.host) {
+            return false;
+        }
+        return headers.referer.indexOf(headers.host) >= 0;
+    }
+    makeOptions(options, method = "GET", body) {
+        // Set base options
+        options = options ? { ...options } : {};
+        options.method = method;
+        options.observe = options.observe || "body";
+        options.originalHeaders = options.originalHeaders || options.headers || {};
+        options.withCredentials = ObjectUtils.isBoolean(options.withCredentials) ? options.withCredentials : this.withCredentials;
+        options.body = body || {};
+        // Set cookies from server side request
+        const headers = !this.request ? null : this.request.headers;
+        if (this.checkHeaders(headers)) {
+            options.headers["Cookie"] = headers.cookie;
+        }
+        options.headers = this.makeHeaders(options);
+        options.params = this.makeParams(options);
+        return options;
+    }
+    makeHeaders(options) {
+        return this.client.makeHeaders(Object.assign({}, this.requestHeaders, options?.headers || {}));
+    }
+    makeParams(options) {
+        return this.client.makeParams(Object.assign({}, this.requestParams, options?.params || {}));
+    }
+    parseResponse(response, url, options) {
+        return response;
+    }
+    parseUrl(url) {
+        return this.url(url).replace(/(?:((?!:).\/)\/)/g, "$1");
+    }
+    async absoluteUrl(url, options) {
+        const absoluteUrl = this.parseUrl(url);
+        if (url == "api-docs") {
+            return absoluteUrl.replace("/api", "");
+        }
+        return absoluteUrl;
+    }
+    expressRequestUrl(url) {
+        const req = this.request;
+        if (!req || !url || url.startsWith("http") || url.startsWith("//"))
+            return url;
+        const separator = url.startsWith("/") ? "" : "/";
+        return `${req.protocol}://${req.get("host")}${separator}${url}`;
+    }
+}
+BaseHttpService.failedRequests = [];
+BaseHttpService.ɵfac = function BaseHttpService_Factory(t) { return new (t || BaseHttpService)(i0.ɵɵinject(BaseHttpClient), i0.ɵɵinject(StorageService), i0.ɵɵinject(LANGUAGE_SERVICE), i0.ɵɵinject(TOASTER_SERVICE), i0.ɵɵinject(CONFIG_SERVICE), i0.ɵɵinject(EXPRESS_REQUEST, 8)); };
+BaseHttpService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: BaseHttpService, factory: BaseHttpService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseHttpService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.BaseHttpClient, decorators: [{
+                type: Inject,
+                args: [BaseHttpClient]
+            }] }, { type: i2.StorageService, decorators: [{
+                type: Inject,
+                args: [StorageService]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [LANGUAGE_SERVICE]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [TOASTER_SERVICE]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [CONFIG_SERVICE]
+            }] }, { type: undefined, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [EXPRESS_REQUEST]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-http.service.js","sourceRoot":"","sources":["../../../../src/ngx-utils/services/base-http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional} from \"@angular/core\";\r\nimport {HttpErrorResponse, HttpEventType, HttpHeaders, HttpParams, HttpResponse} from \"@angular/common/http\";\r\nimport {Request} from \"express\";\r\n\r\nimport {\r\n    CONFIG_SERVICE,\r\n    EXPRESS_REQUEST,\r\n    HttpPromise,\r\n    IConfigService,\r\n    IHttpHeaders,\r\n    IHttpParams,\r\n    IHttpService,\r\n    IIssueContext,\r\n    ILanguageService,\r\n    IPaginationData,\r\n    IRequestOptions,\r\n    IToasterService,\r\n    LANGUAGE_SERVICE,\r\n    ProgressListener,\r\n    TOASTER_SERVICE\r\n} from \"../common-types\";\r\n\r\nimport {ObjectUtils} from \"../utils/object.utils\";\r\nimport {MathUtils} from \"../utils/math.utils\";\r\n\r\nimport {BaseHttpClient} from \"./base-http.client\";\r\nimport {UniversalService} from \"./universal.service\";\r\nimport {StorageService} from \"./storage.service\";\r\nimport {timeout} from \"rxjs/operators\";\r\nimport {TimeoutError} from \"rxjs\";\r\n\r\n@Injectable()\r\nexport class BaseHttpService implements IHttpService {\r\n\r\n    protected static failedRequests: Array<() => void> = [];\r\n\r\n    get name(): string {\r\n        return \"base\";\r\n    }\r\n\r\n    protected get withCredentials(): boolean {\r\n        return true;\r\n    }\r\n\r\n    requestHeaders: IHttpHeaders;\r\n    requestParams: IHttpParams;\r\n    cache: any;\r\n\r\n    protected static retryFailedRequests(): void {\r\n        BaseHttpService.failedRequests.forEach(r => r());\r\n        BaseHttpService.failedRequests = [];\r\n    }\r\n\r\n    get universal(): UniversalService {\r\n        return this.storage.universal;\r\n    }\r\n\r\n    constructor(@Inject(BaseHttpClient) readonly client: BaseHttpClient,\r\n                @Inject(StorageService) readonly storage: StorageService,\r\n                @Inject(LANGUAGE_SERVICE) readonly language: ILanguageService,\r\n                @Inject(TOASTER_SERVICE) readonly toaster: IToasterService,\r\n                @Inject(CONFIG_SERVICE) readonly configs: IConfigService,\r\n                @Optional() @Inject(EXPRESS_REQUEST) readonly request: Request = null\r\n    ) {\r\n        this.requestHeaders = {};\r\n        this.requestParams = {};\r\n        this.cache = {};\r\n    }\r\n\r\n    url(url: string): string {\r\n        return url;\r\n    }\r\n\r\n    createUrl(url: string, params: IHttpParams): string {\r\n        const httpParams = this.client.makeParams(params);\r\n        const query = httpParams.keys().map(key => {\r\n            return `${key}=${httpParams.get(key)}`;\r\n        }).join(\"&\");\r\n        return `${this.url(url)}?${query}`;\r\n    }\r\n\r\n    makeListParams(page: number, itemsPerPage: number, orderBy: string = null, orderDescending: boolean = null, filter: string = null): IHttpParams {\r\n        const params: IHttpParams = {\r\n            page: (page - 1),\r\n            limit: itemsPerPage\r\n        };\r\n        if (!ObjectUtils.isNullOrUndefined(orderBy) && !ObjectUtils.isNullOrUndefined(orderDescending)) {\r\n            params.sort = `${orderDescending ? \"-\" : \"\"}${orderBy}`;\r\n        }\r\n        if (!ObjectUtils.isNullOrUndefined(filter)) {\r\n            params.filter = filter;\r\n        }\r\n        return params;\r\n    }\r\n\r\n    protected getPromise(url: string, options?: IRequestOptions, body?: any): HttpPromise {\r\n        options = this.makeOptions(options, \"GET\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected deletePromise(url: string, options?: IRequestOptions, body?: any): HttpPromise {\r\n        options = this.makeOptions(options, \"DELETE\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected postPromise(url: string, body?: any, options?: IRequestOptions): HttpPromise {\r\n        options = this.makeOptions(options, \"POST\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected putPromise(url: string, body?: any, options?: IRequestOptions): HttpPromise {\r\n        options = this.makeOptions(options, \"PUT\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected patchPromise(url: string, body?: any, options?: IRequestOptions): HttpPromise {\r\n        options = this.makeOptions(options, \"PATCH\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected uploadPromise(url: string, body: any, listener?: ProgressListener, options?: IRequestOptions): HttpPromise {\r\n        const headers: any = {};\r\n        if (body instanceof Blob) {\r\n            headers[\"Content-Type\"] = \"application/octet-stream\";\r\n        }\r\n        options = this.makeOptions(Object.assign({\r\n            headers: headers,\r\n            reportProgress: true\r\n        }, options), \"POST\", body);\r\n        return this.toPromise(url, options, listener);\r\n    }\r\n\r\n    protected listPromise(url: string, params: IHttpParams): Promise<IPaginationData> {\r\n        return new Promise<IPaginationData>(resolve => {\r\n            this.getPromise(url, {params: params}).then(data => {\r\n                if (ObjectUtils.isArray(data)) {\r\n                    resolve({\r\n                        total: data.length,\r\n                        items: data,\r\n                        meta: {}\r\n                    });\r\n                    return;\r\n                }\r\n                resolve({\r\n                    total: data.meta?.total || data?.total || data.items?.length || 0,\r\n                    items: data.items || [],\r\n                    meta: data.meta || {}\r\n                });\r\n            }, response => {\r\n                if (response.status == 0 || response.status == 301) {\r\n                    resolve({\r\n                        total: 1,\r\n                        items: [{\r\n                            id: null,\r\n                            label: \"Not implemented.\"\r\n                        }],\r\n                        meta: {}\r\n                    });\r\n                    return true;\r\n                }\r\n                resolve({\r\n                    total: 0,\r\n                    items: [],\r\n                    meta: {}\r\n                });\r\n                return false;\r\n            });\r\n        });\r\n    }\r\n\r\n    protected handleUnauthorizedError(absoluteUrl: string, options: IRequestOptions, reject: () => void): void {\r\n        reject();\r\n        if (BaseHttpService.failedRequests.length > 1) {\r\n            return;\r\n        }\r\n        if (this.universal.isServer) return;\r\n        console.log(\"User auth error\", absoluteUrl, options);\r\n    }\r\n\r\n    protected toastWarning(message: string, issueContext: IIssueContext, reason: any, options: IRequestOptions): void {\r\n        this.toaster.warning(message, {issueContext, reason, options});\r\n    }\r\n\r\n    protected toastError(message: string, issueContext: IIssueContext, reason: any, options: IRequestOptions): void {\r\n        this.toaster.warning(message, {issueContext, reason, options});\r\n    }\r\n\r\n    protected toPromise(url: string, options: IRequestOptions, listener?: ProgressListener): HttpPromise {\r\n        const issueContext: IIssueContext = {url: \"\"};\r\n\r\n        return new HttpPromise(response => {\r\n            if (!response) {\r\n                if (this.universal.isServer) return;\r\n                console.log(\"You may not need a reject Handler for this request!\", this.name, url, options);\r\n                return;\r\n            }\r\n            const reason = response.error || {};\r\n            if (response.status == 0 || response.status == 301) {\r\n                this.toastWarning(`${url} endpoint is not implemented! Click here, to quickly create an issue.`, issueContext, reason, options);\r\n                return;\r\n            }\r\n            const regex = /((E11000 duplicate key error collection: (.)+\\.)|(_1 dup key:(.)+))/g;\r\n            if (reason.message && regex.test(reason.message)) {\r\n                this.toastError(\"message.duplicate-key.error.\" + reason.message.replace(regex, \"\").replace(\" index: \", \"-\"), issueContext, reason, options);\r\n                return;\r\n            }\r\n            this.toastWarning(`${url} endpoint error is not handled properly! Click here, to quickly create an issue.`, issueContext, reason, options);\r\n        }, (resolve, reject) => {\r\n            this.absoluteUrl(url, options).then(absoluteUrl => {\r\n                issueContext.url = absoluteUrl;\r\n                const request = this.client.request(options.method, absoluteUrl, options);\r\n                const finalRequest = ObjectUtils.isNumber(options.timeout) && options.timeout > 0\r\n                    ? request.pipe(timeout(options.timeout)) : request;\r\n                finalRequest.subscribe((event: any) => {\r\n                    if (options.reportProgress && event.type === HttpEventType.UploadProgress) {\r\n                        const progress = {\r\n                            percentage: MathUtils.round(event.loaded / event.total, 2, 0.01),\r\n                            loaded: event.loaded,\r\n                            total: event.total\r\n                        };\r\n                        if (listener) {\r\n                            listener(progress);\r\n                        }\r\n                        return;\r\n                    }\r\n                    resolve(this.parseResponse(event, url, options));\r\n                    const headers = options.headers as HttpHeaders;\r\n                    const authKey = \"Authorization\";\r\n                    // If we use token auth\r\n                    if (this.client.renewTokenFunc && headers.has(authKey)) {\r\n                        const currentTime = new Date().getTime();\r\n                        const userTokenTime = this.storage.get(\"userTokenTime\") || currentTime;\r\n                        // And the last request was a long long time ago\r\n                        if (currentTime - 600000 > userTokenTime) {\r\n                            this.client.renewTokenFunc();\r\n                        }\r\n                    }\r\n                }, (response: HttpErrorResponse | TimeoutError) => {\r\n                    if (response instanceof TimeoutError || response.status == 0 || response.status == 301) {\r\n                        reject(response);\r\n                        return;\r\n                    }\r\n                    const headers = options.headers as HttpHeaders;\r\n                    const authKey = \"Authorization\";\r\n                    // If an authorization header exists and we still have an Unauthorized response prompt the user to log in again\r\n                    if (headers.has(authKey) && response.status == 401) {\r\n                        const pushed = this.pushFailedRequest(url, options, () => {\r\n                            options.headers = this.makeHeaders(options.originalHeaders);\r\n                            this.toPromise(url, options, listener).then(resolve, reject);\r\n                        });\r\n                        if (pushed)\r\n                            this.handleUnauthorizedError(absoluteUrl, options, () => reject(response));\r\n                        return;\r\n                    }\r\n                    reject(response);\r\n                });\r\n            });\r\n        });\r\n    }\r\n\r\n    protected pushFailedRequest(url: string, options: IRequestOptions, req: () => void): boolean {\r\n        if (url.indexOf(\"tokens\") >= 0) return false;\r\n        BaseHttpService.failedRequests.push(req);\r\n        return true;\r\n    }\r\n\r\n    protected checkHeaders(headers: any): boolean {\r\n        if (!headers || !headers.cookie || !headers.referer || !headers.host) {\r\n            return false;\r\n        }\r\n        return headers.referer.indexOf(headers.host) >= 0;\r\n    }\r\n\r\n    protected makeOptions(options?: IRequestOptions, method: string = \"GET\", body?: any): IRequestOptions {\r\n        // Set base options\r\n        options = options ? {...options} : {};\r\n        options.method = method;\r\n        options.observe = options.observe || \"body\";\r\n        options.originalHeaders = options.originalHeaders || (options.headers as IHttpHeaders) || {};\r\n        options.withCredentials = ObjectUtils.isBoolean(options.withCredentials) ? options.withCredentials : this.withCredentials;\r\n        options.body = body || {};\r\n        // Set cookies from server side request\r\n        const headers = !this.request ? null : this.request.headers;\r\n        if (this.checkHeaders(headers)) {\r\n            options.headers[\"Cookie\"] = headers.cookie;\r\n        }\r\n        options.headers = this.makeHeaders(options);\r\n        options.params = this.makeParams(options);\r\n        return options;\r\n    }\r\n\r\n    protected makeHeaders(options: IRequestOptions): HttpHeaders {\r\n        return this.client.makeHeaders(Object.assign({}, this.requestHeaders, options?.headers || {}));\r\n    }\r\n\r\n    protected makeParams(options: IRequestOptions): HttpParams {\r\n        return this.client.makeParams(Object.assign({}, this.requestParams, options?.params || {}));\r\n    }\r\n\r\n    protected parseResponse(response: any, url: string, options: IRequestOptions): any {\r\n        return response;\r\n    }\r\n\r\n    protected parseUrl(url: string): string {\r\n        return this.url(url).replace(/(?:((?!:).\\/)\\/)/g, \"$1\");\r\n    }\r\n\r\n    protected async absoluteUrl(url: string, options: IRequestOptions): Promise<string> {\r\n        const absoluteUrl = this.parseUrl(url);\r\n        if (url == \"api-docs\") {\r\n            return absoluteUrl.replace(\"/api\", \"\");\r\n        }\r\n        return absoluteUrl;\r\n    }\r\n\r\n    protected expressRequestUrl(url: string): string {\r\n        const req = this.request;\r\n        if (!req || !url || url.startsWith(\"http\") || url.startsWith(\"//\")) return url;\r\n        const separator = url.startsWith(\"/\") ? \"\" : \"/\";\r\n        return `${req.protocol}://${req.get(\"host\")}${separator}${url}`;\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-utils/services/config.service.mjs

@@ -0,0 +1,129 @@
+import { Inject, Injectable, Optional, isDevMode } from "@angular/core";
+import { HttpClient } from "@angular/common/http";
+import { UniversalService } from "./universal.service";
+import { BASE_CONFIG, IConfiguration, ROOT_ELEMENT, SCRIPT_PARAMS } from "../common-types";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./universal.service";
+import * as i3 from "../common-types";
+export class ConfigService {
+    constructor(http, universal, rootElement, baseConfig = null, scriptParams = null) {
+        this.http = http;
+        this.universal = universal;
+        this.rootElement = rootElement;
+        for (const key in []) {
+            Object.defineProperty(Array.prototype, key, {
+                enumerable: false
+            });
+        }
+        let baseUrl = "";
+        if (this.universal.isBrowser) {
+            const currentScript = document.currentScript;
+            if (!!currentScript) {
+                const scriptSrc = currentScript.src;
+                const srcParts = scriptSrc.split(".js");
+                baseUrl = scriptSrc.substr(0, srcParts[0].lastIndexOf("/") + 1);
+            }
+        }
+        this.baseConfig = baseConfig || {};
+        this.loadedConfig = Object.assign(!baseUrl ? {} : { baseUrl, baseDomain: this.parseDomain(baseUrl) }, this.baseConfig);
+        this.scriptParameters = scriptParams || {};
+        this.loaderFunc = () => {
+            this.loader = this.loader || new Promise((resolve, reject) => {
+                this.loadJson().then(config => {
+                    this.loadedConfig = config = Object.assign(this.loadedConfig, config);
+                    this.prepareConfig(config).then(c => {
+                        this.loadedConfig = c;
+                        c.baseUrl = c.baseUrl || "/";
+                        resolve(c);
+                    });
+                }, reject);
+            });
+            return this.loader;
+        };
+        this.initService();
+    }
+    get load() {
+        return this.loaderFunc;
+    }
+    get config() {
+        return this.loadedConfig;
+    }
+    get configUrl() {
+        return `${this.loadedConfig.baseUrl}config/config.json`;
+    }
+    parseDomain(baseUrl) {
+        try {
+            const url = new URL(baseUrl);
+            const port = url.port && url.port !== "443" && url.port !== "80" ? `:${url.port}` : ``;
+            return `${url.protocol}//${url.hostname}${port}/`;
+        }
+        catch {
+            return "/";
+        }
+    }
+    initService() {
+    }
+    async loadJson() {
+        if (this.universal.isServer) {
+            return Promise.resolve(this.loadedConfig);
+        }
+        const configUrl = this.configUrl;
+        try {
+            const config5 = await this.http.get(isDevMode() ? `${configUrl}5` : configUrl, { responseType: "text" }).toPromise();
+            return require("json5").parse(config5);
+        }
+        catch (e) {
+            try {
+                const config = await this.http.get(configUrl).toPromise();
+                console.log(`Can't parse json5 config: ${e}`);
+                return config;
+            }
+            catch (e) {
+                throw new Error(`Config file not found at: ${configUrl}`);
+            }
+        }
+    }
+    prepareConfig(config) {
+        return Promise.resolve(config);
+    }
+    prepareUrl(url, ending) {
+        const project = !this.loadedConfig ? "" : this.loadedConfig.project;
+        const needsProtocol = url?.startsWith("//") ?? false;
+        url = !needsProtocol && url?.startsWith("/") ? this.loadedConfig.baseDomain + url.substr(1) : url || "";
+        url = `${url.replace(/\/+$/, "")}${ending}`.replace("[project]", project);
+        return this.universal.isServer && needsProtocol ? `http:${url}` : url;
+    }
+    getConfigValue(key) {
+        return this.loadedConfig[key];
+    }
+    getQueryParameter(name, url) {
+        url = url || (this.universal.isBrowser ? window.location.href : "");
+        name = name.replace(/[\[\]]/g, "\\$&");
+        const regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)"), results = regex.exec(url);
+        if (!results)
+            return null;
+        if (!results[2])
+            return "";
+        return decodeURIComponent(results[2].replace(/\+/g, " "));
+    }
+}
+ConfigService.ɵfac = function ConfigService_Factory(t) { return new (t || ConfigService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.UniversalService), i0.ɵɵinject(ROOT_ELEMENT), i0.ɵɵinject(BASE_CONFIG, 8), i0.ɵɵinject(SCRIPT_PARAMS, 8)); };
+ConfigService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ConfigService, factory: ConfigService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConfigService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.UniversalService }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [ROOT_ELEMENT]
+            }] }, { type: i3.IConfiguration, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [BASE_CONFIG]
+            }] }, { type: undefined, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [SCRIPT_PARAMS]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.service.js","sourceRoot":"","sources":["../../../../src/ngx-utils/services/config.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional, isDevMode} from \"@angular/core\";\r\nimport {HttpClient} from \"@angular/common/http\";\r\nimport {UniversalService} from \"./universal.service\";\r\nimport {BASE_CONFIG, IConfigService, IConfiguration, ROOT_ELEMENT, SCRIPT_PARAMS} from \"../common-types\";\r\n\r\n@Injectable()\r\nexport class ConfigService implements IConfigService {\r\n\r\n    protected baseConfig: IConfiguration;\r\n    protected loadedConfig: IConfiguration;\r\n    protected scriptParameters: any;\r\n    protected loader: Promise<IConfiguration>;\r\n    protected readonly loaderFunc: () => Promise<IConfiguration>;\r\n\r\n    get load(): () => Promise<IConfiguration> {\r\n        return this.loaderFunc;\r\n    }\r\n\r\n    get config(): IConfiguration {\r\n        return this.loadedConfig;\r\n    }\r\n\r\n    get configUrl(): string {\r\n        return `${this.loadedConfig.baseUrl}config/config.json`;\r\n    }\r\n\r\n    constructor(readonly http: HttpClient,\r\n                readonly universal: UniversalService,\r\n                @Inject(ROOT_ELEMENT) readonly rootElement: any,\r\n                @Optional() @Inject(BASE_CONFIG) baseConfig: IConfiguration = null,\r\n                @Optional() @Inject(SCRIPT_PARAMS) scriptParams: any = null) {\r\n        for (const key in []) {\r\n            Object.defineProperty(Array.prototype, key, {\r\n                enumerable: false\r\n            });\r\n        }\r\n        let baseUrl = \"\";\r\n        if (this.universal.isBrowser) {\r\n            const currentScript = (document.currentScript as HTMLScriptElement);\r\n            if (!!currentScript) {\r\n                const scriptSrc = currentScript.src;\r\n                const srcParts = scriptSrc.split(\".js\");\r\n                baseUrl = scriptSrc.substr(0, srcParts[0].lastIndexOf(\"/\") + 1);\r\n            }\r\n        }\r\n        this.baseConfig = baseConfig || {};\r\n        this.loadedConfig = Object.assign(\r\n            !baseUrl ? {} : {baseUrl, baseDomain: this.parseDomain(baseUrl)},\r\n            this.baseConfig\r\n        );\r\n        this.scriptParameters = scriptParams || {};\r\n        this.loaderFunc = () => {\r\n            this.loader = this.loader || new Promise<any>((resolve, reject) => {\r\n                this.loadJson().then(config => {\r\n                    this.loadedConfig = config = Object.assign(this.loadedConfig, config);\r\n                    this.prepareConfig(config).then(c => {\r\n                        this.loadedConfig = c;\r\n                        c.baseUrl = c.baseUrl || \"/\";\r\n                        resolve(c);\r\n                    });\r\n                }, reject);\r\n            });\r\n            return this.loader;\r\n        };\r\n        this.initService();\r\n    }\r\n\r\n    protected parseDomain(baseUrl: string): string {\r\n        try {\r\n            const url = new URL(baseUrl);\r\n            const port = url.port && url.port !== \"443\" && url.port !== \"80\" ? `:${url.port}` : ``;\r\n            return `${url.protocol}//${url.hostname}${port}/`;\r\n        } catch {\r\n            return \"/\";\r\n        }\r\n    }\r\n\r\n    protected initService(): void {\r\n\r\n    }\r\n\r\n    protected async loadJson(): Promise<IConfiguration> {\r\n        if (this.universal.isServer) {\r\n            return Promise.resolve(this.loadedConfig);\r\n        }\r\n        const configUrl = this.configUrl;\r\n        try {\r\n            const config5 = await this.http.get(isDevMode() ? `${configUrl}5` : configUrl, {responseType: \"text\"}).toPromise();\r\n            return require(\"json5\").parse(config5);\r\n        } catch (e) {\r\n            try {\r\n                const config = await this.http.get(configUrl).toPromise();\r\n                console.log(`Can't parse json5 config: ${e}`);\r\n                return config;\r\n            } catch (e) {\r\n                throw new Error(`Config file not found at: ${configUrl}`);\r\n            }\r\n        }\r\n    }\r\n\r\n    protected prepareConfig(config: IConfiguration): Promise<IConfiguration> {\r\n        return Promise.resolve(config);\r\n    }\r\n\r\n    prepareUrl(url: string, ending: string): string {\r\n        const project = !this.loadedConfig ? \"\" : this.loadedConfig.project;\r\n        const needsProtocol = url?.startsWith(\"//\") ?? false;\r\n        url = !needsProtocol && url?.startsWith(\"/\") ? this.loadedConfig.baseDomain + url.substr(1) : url || \"\";\r\n        url = `${url.replace(/\\/+$/, \"\")}${ending}`.replace(\"[project]\", project);\r\n        return this.universal.isServer && needsProtocol ? `http:${url}` : url;\r\n    }\r\n\r\n    getConfigValue(key: string): any {\r\n        return this.loadedConfig[key];\r\n    }\r\n\r\n    getQueryParameter(name: string, url?: string): string {\r\n        url = url || (this.universal.isBrowser ? window.location.href : \"\");\r\n        name = name.replace(/[\\[\\]]/g, \"\\\\$&\");\r\n        const regex = new RegExp(\"[?&]\" + name + \"(=([^&#]*)|&|#|$)\"),\r\n            results = regex.exec(url);\r\n        if (!results) return null;\r\n        if (!results[2]) return \"\";\r\n        return decodeURIComponent(results[2].replace(/\\+/g, \" \"));\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-utils/services/error-handler.service.mjs

@@ -0,0 +1,49 @@
+import { ErrorHandler, Injectable, Injector } from "@angular/core";
+import { UniversalService } from "./universal.service";
+import { ERROR_HANDLER, TOASTER_SERVICE } from "../common-types";
+import * as i0 from "@angular/core";
+export class ErrorHandlerService extends ErrorHandler {
+    constructor(injector) {
+        super();
+        this.injector = injector;
+        this.errorMap = {};
+    }
+    handleError(error) {
+        try {
+            this.universal = this.universal || this.injector.get(UniversalService);
+        }
+        catch (e) {
+            return;
+        }
+        const date = new Date();
+        try {
+            this.errorCb = this.errorCb || this.injector.get(ERROR_HANDLER);
+            this.errorCb(`[${date}]: ${error.message}\n${error.stack}`);
+        }
+        catch (e) {
+            if (this.universal.isServer) {
+                console.error(`[${date}]: ${error.message}\n${error.stack}`);
+                return;
+            }
+        }
+        if (this.universal.isServer)
+            return;
+        const key = typeof btoa !== "undefined" ? btoa(unescape(encodeURIComponent(`${error.message} ${error.stack}`))) : error.message;
+        if (this.errorMap[key] && this.errorMap[key].getTime() > date.getTime() - 5000)
+            return;
+        this.errorMap[key] = date;
+        try {
+            this.toaster = this.toaster || this.injector.get(TOASTER_SERVICE);
+            this.toaster.error(`[${date}]: ${error.message}\n${error.stack}`);
+        }
+        catch (e) {
+        }
+        console.error(`[${date}]: ${error.message}\n${error.stack}`);
+    }
+}
+ErrorHandlerService.ɵfac = function ErrorHandlerService_Factory(t) { return new (t || ErrorHandlerService)(i0.ɵɵinject(i0.Injector)); };
+ErrorHandlerService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ErrorHandlerService, factory: ErrorHandlerService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorHandlerService, [{
+        type: Injectable
+    }], function () { return [{ type: i0.Injector }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/events.service.mjs

@@ -0,0 +1,26 @@
+import { EventEmitter, Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class EventsService {
+    constructor() {
+        this.eventForwarded = new EventEmitter();
+        this.stickyUpdated = new EventEmitter();
+        this.languageChanged = new EventEmitter();
+        this.sticky = false;
+    }
+    get isSticky() {
+        return this.sticky;
+    }
+    event(e) {
+        this.eventForwarded.emit(e);
+    }
+    updateSticky(sticky) {
+        this.sticky = sticky;
+        this.stickyUpdated.emit(sticky);
+    }
+}
+EventsService.ɵfac = function EventsService_Factory(t) { return new (t || EventsService)(); };
+EventsService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EventsService, factory: EventsService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventsService, [{
+        type: Injectable
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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