@sambath999/localize-token 12.3.1 → 12.3.2

package/esm2015/localize-token/helpers/loccalize.api.helper.js

@@ -0,0 +1,270 @@
+import { __awaiter } from "tslib";
+import { HttpErrorResponse } from "@angular/common/http";
+import { takeUntil, catchError, throwError } from "rxjs";
+import { LocalizeToken, waitFor } from "../localize.token";
+class LocalizeApiHelper {
+    constructor() {
+        this.defaultRetryOptions = {
+            connectionError: {
+                message: 'Connection error occurred. Please wait',
+                blockScreen: true,
+                blockScreenZIndex: 10000
+            }
+        };
+    }
+    performRetry(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let attempts = 0;
+            let lastError;
+            let consoleCount = 0;
+            // Merge default retry options with provided options
+            options = Object.assign(Object.assign({}, this.defaultRetryOptions), options);
+            let styleElement;
+            while (attempts < options.maxRetries()) {
+                try {
+                    const result = yield options.callback();
+                    this.removeBlocker(styleElement);
+                    return result;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (consoleCount >= 7) {
+                        console.clear();
+                        consoleCount = 0;
+                    }
+                    if (options.retryUnless && !options.retryUnless(error))
+                        throw error; // If the error should not be retried, rethrow it
+                    // Handle connection error
+                    styleElement = yield this.onConnectionError(options, error);
+                    if (options.onError)
+                        yield this.invokeHook(options.onError.bind(this, error));
+                    if (attempts >= options.maxRetries() - 1)
+                        throw error;
+                    attempts++;
+                    consoleCount++;
+                    console.warn(`Attempt ${attempts} failed. Retrying...`, error);
+                    yield waitFor(options.delay);
+                }
+            }
+            console.warn(`Failed after ${options.maxRetries} attempts`);
+            throw lastError;
+        });
+    }
+    performRequestWithRetry(options, config, performRequest) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const retryUnless = ((_a = config.retryOptions) === null || _a === void 0 ? void 0 : _a.retryFunction)
+                || this.isConnectionError;
+            return yield this.performRetry({
+                connectionError: (_b = config.retryOptions) === null || _b === void 0 ? void 0 : _b.onConnectionError,
+                maxRetries: () => { var _a, _b; return (_b = (_a = config.retryOptions) === null || _a === void 0 ? void 0 : _a.maxRetries) !== null && _b !== void 0 ? _b : 1000; },
+                delay: (_d = (_c = config.retryOptions) === null || _c === void 0 ? void 0 : _c.delay) !== null && _d !== void 0 ? _d : 500,
+                callback: () => performRequest(options),
+                retryUnless: retryUnless,
+            });
+        });
+    }
+    buildUrl(baseUrl, path) {
+        const normalizedUrl = `${baseUrl.trim().replace(/\/?$/, '/')}${path.trim().replace(/^\//, '')}`;
+        return normalizedUrl.endsWith('/')
+            ? normalizedUrl.slice(0, -1)
+            : normalizedUrl;
+    }
+    normalizeError(error) {
+        var _a, _b, _c;
+        return {
+            code: ((_a = error.error) === null || _a === void 0 ? void 0 : _a.code) || `HTTP_${error.status}`,
+            message: ((_b = error.error) === null || _b === void 0 ? void 0 : _b.message) || error.message,
+            details: (_c = error.error) === null || _c === void 0 ? void 0 : _c.details,
+            status: error.status
+        };
+    }
+    invokeHook(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!callback)
+                return;
+            const result = callback();
+            if (result instanceof Promise) {
+                yield result;
+            }
+        });
+    }
+    createRequest(instance, method, url, body, options) {
+        const request$ = instance.client.request(method, url, Object.assign(Object.assign({}, options), { body, observe: 'response' })).pipe(takeUntil(instance.destroy$()), catchError((error) => {
+            // Convert to a non-observable error to handle in the promise
+            return throwError(() => this.normalizeError(error));
+        }));
+        return request$;
+    }
+    defaultRetryFunction(error) {
+        // Don't retry for other errors (like 400, 401, 403, etc.)
+        if (!this.isConnectionError(error))
+            throw error;
+        return true;
+    }
+    isConnectionError(error) {
+        const isNetworkError = error.status === 0;
+        const isServerError = error.status >= 1000 && error.status < 600;
+        return isNetworkError || isServerError;
+    }
+    onConnectionError(options, error) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!options.connectionError)
+                return;
+            let styleElement;
+            if (this.isConnectionError(error)) {
+                styleElement = this.screenBlocker(options, error, true);
+                yield this.invokeHook((_a = options.connectionError.callback) === null || _a === void 0 ? void 0 : _a.bind(this, error));
+                return styleElement;
+            }
+            else {
+                this.screenBlocker(options, error, false);
+                styleElement === null || styleElement === void 0 ? void 0 : styleElement.remove();
+            }
+        });
+    }
+    validateConfig(config) {
+        var _a;
+        if (LocalizeToken.config.needTenant && !((_a = config.tenantTokenName) === null || _a === void 0 ? void 0 : _a.trim().length)) {
+            throw Error('Tenant token is required but tenantTokenName is not configured');
+        }
+        if (!LocalizeToken.config.revokeTokenUrl.trim().length) {
+            throw Error('Revoke token URL is not configured - token refresh will not work');
+        }
+    }
+    screenBlocker(optons, error, add = true) {
+        var _a, _b, _c, _d;
+        if (!((_a = optons.connectionError) === null || _a === void 0 ? void 0 : _a.blockScreen))
+            return;
+        if (error instanceof HttpErrorResponse)
+            error = this.normalizeError(error);
+        const message = ((_b = optons.connectionError) === null || _b === void 0 ? void 0 : _b.message)
+            || 'Connection error occurred. Please wait';
+        const errorMessage = (error === null || error === void 0 ? void 0 : error.message) || 'An error occurred';
+        const suggestinMessage = ((_c = optons.connectionError) === null || _c === void 0 ? void 0 : _c.suggestionMessage)
+            || 'Please check your internet connection or the server status.';
+        const zIndex = ((_d = optons.connectionError) === null || _d === void 0 ? void 0 : _d.blockScreenZIndex) || 10000;
+        const body = document.body;
+        const blcokerHtml = `
+        <div class="lze-blocker">
+            <div class="lze-blocker__message">
+                ${message}
+                <span class="lze-blocker__dotting">
+                    <span class="lze-blocker__dot"></span>
+                    <span class="lze-blocker__dot"></span>
+                    <span class="lze-blocker__dot"></span>
+                </span>
+            </div>
+            <div class="lze-blocker__error">${errorMessage}</div>
+            <div class="lze-blocker__error_suggestion">${suggestinMessage}</div>
+            <div class="lze-blocker__spinner"></div>
+        </div>
+        `;
+        const style = `
+        .lze-blocker {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.8);
+            z-index: ${zIndex};
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            flex-direction: column;
+            color: #fff;
+            font-family: Arial, sans-serif;
+            text-align: center;
+            padding: 20px;
+            box-sizing: border-box;
+            overflow: hidden;
+            user-select: none;
+        }
+        
+        .lze-blocker__spinner {
+            border: 4px solid rgba(255, 255, 255, 0.1);
+            border-top: 4px solid #fff;
+            border-radius: 50%;
+            width: 50px;
+            height: 50px;
+            animation: spin 1s linear infinite;
+            margin-top: 20px;
+        }
+
+        .lze-blocker__message {
+            color: #fff;
+            font-size: 18px;
+            margin-bottom: 10px;
+        }
+            
+        .lze-blocker__dotting {
+            display: inline-block;
+            vertical-align: middle;
+        }
+        .lze-blocker__dot {
+            display: inline-block;
+            width: 7px;
+            height: 7px;
+            background-color: #ffffff;
+            border-radius: 50%;
+            margin-left: 3px;
+            opacity: 0.3;
+            animation: dotting 1s infinite;
+        }
+        .lze-blocker__dot:nth-child(1) {
+            animation-delay: 0s;
+            opacity: 1;
+        }
+        .lze-blocker__dot:nth-child(2) {
+            animation-delay: 0.2s;
+        }
+        .lze-blocker__dot:nth-child(3) {
+            animation-delay: 0.4s;
+        }
+
+        @keyframes dotting {
+            0%, 80%, 100% { opacity: 0.3; }
+            40% { opacity: 1; }
+        }
+
+        .lze-blocker__error {
+            color: #f00;
+            font-size: 14px;
+            margin-bottom: 10px;
+            text-shadow: 0 0 1px #ff5f5f;
+        }
+
+        .lze-blocker__error_suggestion {
+            color: #ccc;
+            font-size: 14px;
+            margin-top: 10px;
+        }
+        
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+        `;
+        const styleElement = document.createElement('style');
+        if (add) {
+            if (!document.querySelector('.lze-blocker')) {
+                styleElement.innerHTML = style;
+                document.head.appendChild(styleElement);
+                body.insertAdjacentHTML('beforeend', blcokerHtml);
+            }
+        }
+        else {
+            this.removeBlocker(styleElement);
+        }
+        return styleElement;
+    }
+    removeBlocker(styleElement) {
+        const blocker = document.querySelector('.lze-blocker');
+        blocker === null || blocker === void 0 ? void 0 : blocker.remove();
+        styleElement === null || styleElement === void 0 ? void 0 : styleElement.remove();
+    }
+}
+export const ApiHelper = new LocalizeApiHelper();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loccalize.api.helper.js","sourceRoot":"","sources":["../../../../src/localize-token/helpers/loccalize.api.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse, HttpHeaders } from \"@angular/common/http\";\r\nimport { IApiOptions, ILocalizeApiConfigs, INormalizedError, IOnConnectionError } from \"./interfaces\";\r\nimport { takeUntil, catchError, throwError, Subject } from \"rxjs\";\r\nimport { LocalizeToken, waitFor } from \"../localize.token\";\r\n\r\ninterface IRequestInstance {\r\n    client: HttpClient;\r\n    destroy$: () => Subject<void>;\r\n}\r\n\r\ninterface IRetryOptions {\r\n    maxRetries: () => number;\r\n    delay: number;\r\n    callback: () => Promise<any> | any;\r\n    retryUnless?: (error: any) => boolean;\r\n    onError?: (error: any) => Promise<void> | any;\r\n    connectionError?: IOnConnectionError\r\n}\r\n\r\nclass LocalizeApiHelper {\r\n\r\n    readonly defaultRetryOptions: Partial<IRetryOptions> = {\r\n        connectionError: {\r\n            message: 'Connection error occurred. Please wait',\r\n            blockScreen: true,\r\n            blockScreenZIndex: 10000\r\n        }\r\n    };\r\n\r\n    async performRetry<T = any>(options: IRetryOptions): Promise<T> {\r\n        let attempts = 0;\r\n        let lastError: any;\r\n        let consoleCount = 0;\r\n\r\n        // Merge default retry options with provided options\r\n        options = { ...this.defaultRetryOptions, ...options }\r\n\r\n        let styleElement: HTMLStyleElement | undefined;\r\n\r\n        while (attempts < options.maxRetries()) {\r\n            try {\r\n                const result = await options.callback();\r\n                this.removeBlocker(styleElement);\r\n                return result;\r\n\r\n            } catch (error: any) {\r\n                lastError = error;\r\n\r\n                if (consoleCount >= 7) {\r\n                    console.clear();\r\n                    consoleCount = 0;\r\n                }\r\n\r\n                if (options.retryUnless && !options.retryUnless(error))\r\n                    throw error; // If the error should not be retried, rethrow it\r\n\r\n                // Handle connection error\r\n                styleElement = await this.onConnectionError(options, error);\r\n\r\n                if (options.onError)\r\n                    await this.invokeHook(options.onError.bind(this, error));\r\n\r\n                if (attempts >= options.maxRetries() - 1)\r\n                    throw error;\r\n\r\n                attempts++;\r\n                consoleCount++;\r\n                console.warn(`Attempt ${attempts} failed. Retrying...`, error);\r\n                await waitFor(options.delay);\r\n            }\r\n        }\r\n\r\n        console.warn(`Failed after ${options.maxRetries} attempts`);\r\n        throw lastError;\r\n    }\r\n\r\n    async performRequestWithRetry<T = any>(\r\n        options: IApiOptions,\r\n        config: ILocalizeApiConfigs,\r\n        performRequest: <T = any>(options: IApiOptions) => Promise<T>\r\n    ): Promise<T> {\r\n\r\n        const retryUnless = config.retryOptions?.retryFunction\r\n            || this.isConnectionError;\r\n\r\n        return await this.performRetry({\r\n            connectionError: config.retryOptions?.onConnectionError,\r\n            maxRetries: () => config.retryOptions?.maxRetries ?? 1000,\r\n            delay: config.retryOptions?.delay ?? 500,\r\n            callback: () => performRequest<T>(options),\r\n            retryUnless: retryUnless,\r\n        })\r\n    }\r\n\r\n    buildUrl(baseUrl: string, path: string): string {\r\n        const normalizedUrl = `${baseUrl.trim().replace(/\\/?$/, '/')}${path.trim().replace(/^\\//, '')}`;\r\n        return normalizedUrl.endsWith('/')\r\n            ? normalizedUrl.slice(0, -1)\r\n            : normalizedUrl;\r\n    }\r\n\r\n    normalizeError(error: HttpErrorResponse): INormalizedError {\r\n        return {\r\n            code: error.error?.code || `HTTP_${error.status}`,\r\n            message: error.error?.message || error.message,\r\n            details: error.error?.details,\r\n            status: error.status\r\n        };\r\n    }\r\n\r\n    async invokeHook(callback?: () => Promise<any> | any): Promise<any> {\r\n        if (!callback) return;\r\n\r\n        const result = callback();\r\n        if (result instanceof Promise) {\r\n            await result;\r\n        }\r\n    }\r\n\r\n    createRequest<T = any>(\r\n        instance: Required<IRequestInstance>,\r\n        method: string,\r\n        url: string,\r\n        body: any,\r\n        options: { headers: HttpHeaders }\r\n    ) {\r\n        const request$ = instance.client.request<T>(method, url, {\r\n            ...options,\r\n            body,\r\n            observe: 'response',\r\n        }).pipe(\r\n            takeUntil(instance.destroy$()),\r\n            catchError((error: HttpErrorResponse) => {\r\n                // Convert to a non-observable error to handle in the promise\r\n                return throwError(() => this.normalizeError(error));\r\n            })\r\n        );\r\n\r\n        return request$;\r\n    }\r\n\r\n    defaultRetryFunction(error: INormalizedError): boolean {\r\n\r\n        // Don't retry for other errors (like 400, 401, 403, etc.)\r\n        if (!this.isConnectionError(error))\r\n            throw error;\r\n\r\n        return true;\r\n    }\r\n\r\n    isConnectionError(error: INormalizedError): boolean {\r\n        const isNetworkError = error.status === 0;\r\n        const isServerError = error.status >= 1000 && error.status < 600;\r\n        return isNetworkError || isServerError;\r\n    }\r\n\r\n    async onConnectionError(\r\n        options: IRetryOptions,\r\n        error: any\r\n    ): Promise<Promise<void> | any> {\r\n\r\n        if (!options.connectionError)\r\n            return;\r\n\r\n        let styleElement: HTMLStyleElement | undefined;\r\n        if (this.isConnectionError(error)) {\r\n\r\n            styleElement = this.screenBlocker(options, error, true);\r\n\r\n            await this.invokeHook(options.connectionError.callback?.bind(this, error));\r\n            return styleElement;\r\n        } else {\r\n            this.screenBlocker(options, error, false);\r\n            styleElement?.remove();\r\n        }\r\n    }\r\n\r\n    validateConfig(config: ILocalizeApiConfigs): void {\r\n        if (LocalizeToken.config.needTenant && !config.tenantTokenName?.trim().length) {\r\n            throw Error('Tenant token is required but tenantTokenName is not configured');\r\n        }\r\n\r\n        if (!LocalizeToken.config.revokeTokenUrl.trim().length) {\r\n            throw Error('Revoke token URL is not configured - token refresh will not work');\r\n        }\r\n    }\r\n\r\n    screenBlocker(optons: IRetryOptions,\r\n        error?: any,\r\n        add: boolean = true): HTMLStyleElement | undefined {\r\n\r\n        if (!optons.connectionError?.blockScreen)\r\n            return;\r\n\r\n        if (error instanceof HttpErrorResponse)\r\n            error = this.normalizeError(error);\r\n\r\n        const message = optons.connectionError?.message\r\n            || 'Connection error occurred. Please wait';\r\n        const errorMessage = error?.message || 'An error occurred';\r\n        const suggestinMessage = optons.connectionError?.suggestionMessage\r\n            || 'Please check your internet connection or the server status.';\r\n\r\n        const zIndex = optons.connectionError?.blockScreenZIndex || 10000;\r\n\r\n        const body = document.body;\r\n        const blcokerHtml = `\r\n        <div class=\"lze-blocker\">\r\n            <div class=\"lze-blocker__message\">\r\n                ${message}\r\n                <span class=\"lze-blocker__dotting\">\r\n                    <span class=\"lze-blocker__dot\"></span>\r\n                    <span class=\"lze-blocker__dot\"></span>\r\n                    <span class=\"lze-blocker__dot\"></span>\r\n                </span>\r\n            </div>\r\n            <div class=\"lze-blocker__error\">${errorMessage}</div>\r\n            <div class=\"lze-blocker__error_suggestion\">${suggestinMessage}</div>\r\n            <div class=\"lze-blocker__spinner\"></div>\r\n        </div>\r\n        `;\r\n        const style = `\r\n        .lze-blocker {\r\n            position: fixed;\r\n            top: 0;\r\n            left: 0;\r\n            width: 100%;\r\n            height: 100%;\r\n            background: rgba(0, 0, 0, 0.8);\r\n            z-index: ${zIndex};\r\n            display: flex;\r\n            align-items: center;\r\n            justify-content: center;\r\n            flex-direction: column;\r\n            color: #fff;\r\n            font-family: Arial, sans-serif;\r\n            text-align: center;\r\n            padding: 20px;\r\n            box-sizing: border-box;\r\n            overflow: hidden;\r\n            user-select: none;\r\n        }\r\n        \r\n        .lze-blocker__spinner {\r\n            border: 4px solid rgba(255, 255, 255, 0.1);\r\n            border-top: 4px solid #fff;\r\n            border-radius: 50%;\r\n            width: 50px;\r\n            height: 50px;\r\n            animation: spin 1s linear infinite;\r\n            margin-top: 20px;\r\n        }\r\n\r\n        .lze-blocker__message {\r\n            color: #fff;\r\n            font-size: 18px;\r\n            margin-bottom: 10px;\r\n        }\r\n            \r\n        .lze-blocker__dotting {\r\n            display: inline-block;\r\n            vertical-align: middle;\r\n        }\r\n        .lze-blocker__dot {\r\n            display: inline-block;\r\n            width: 7px;\r\n            height: 7px;\r\n            background-color: #ffffff;\r\n            border-radius: 50%;\r\n            margin-left: 3px;\r\n            opacity: 0.3;\r\n            animation: dotting 1s infinite;\r\n        }\r\n        .lze-blocker__dot:nth-child(1) {\r\n            animation-delay: 0s;\r\n            opacity: 1;\r\n        }\r\n        .lze-blocker__dot:nth-child(2) {\r\n            animation-delay: 0.2s;\r\n        }\r\n        .lze-blocker__dot:nth-child(3) {\r\n            animation-delay: 0.4s;\r\n        }\r\n\r\n        @keyframes dotting {\r\n            0%, 80%, 100% { opacity: 0.3; }\r\n            40% { opacity: 1; }\r\n        }\r\n\r\n        .lze-blocker__error {\r\n            color: #f00;\r\n            font-size: 14px;\r\n            margin-bottom: 10px;\r\n            text-shadow: 0 0 1px #ff5f5f;\r\n        }\r\n\r\n        .lze-blocker__error_suggestion {\r\n            color: #ccc;\r\n            font-size: 14px;\r\n            margin-top: 10px;\r\n        }\r\n        \r\n        @keyframes spin {\r\n            0% { transform: rotate(0deg); }\r\n            100% { transform: rotate(360deg); }\r\n        }\r\n        `;\r\n\r\n        const styleElement = document.createElement('style');\r\n\r\n        if (add) {\r\n            if (!document.querySelector('.lze-blocker')) {\r\n                styleElement.innerHTML = style;\r\n                document.head.appendChild(styleElement);\r\n                body.insertAdjacentHTML('beforeend', blcokerHtml);\r\n            }\r\n        } else {\r\n            this.removeBlocker(styleElement);\r\n        }\r\n\r\n        return styleElement;\r\n    }\r\n\r\n    private removeBlocker(styleElement: HTMLStyleElement | undefined): void {\r\n        const blocker = document.querySelector('.lze-blocker');\r\n        blocker?.remove();\r\n        styleElement?.remove();\r\n    }\r\n}\r\n\r\nexport const ApiHelper = new LocalizeApiHelper();"]}