@sambath999/localize-token 12.3.1 → 12.3.3

package/fesm2015/sambath999-localize-token.js

@@ -1,17 +1,17 @@
 import * as i0 from '@angular/core';
 import { Injectable, NgModule, Component, ViewEncapsulation, ChangeDetectorRef, Injector, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
 import { __awaiter } from 'tslib';
-import { BehaviorSubject } from 'rxjs';
+import { BehaviorSubject, takeUntil, catchError, throwError, Subject } from 'rxjs';
 import * as jwt_decode from 'jwt-decode';
 import * as i1 from '@angular/common/http';
-import { HttpHeaders, HttpClient } from '@angular/common/http';
+import { HttpErrorResponse, HttpHeaders, HttpClient } from '@angular/common/http';
 import { MessageService } from 'primeng/api';
 import { DynamicDialogRef, DynamicDialogConfig, DialogService } from 'primeng/dynamicdialog';
+import { DomSanitizer, BrowserModule } from '@angular/platform-browser';
 import { CommonModule } from '@angular/common';
 import { ToastModule } from 'primeng/toast';
 import { InputTextModule } from 'primeng/inputtext';
 import { ButtonModule } from 'primeng/button';
-import { BrowserModule } from '@angular/platform-browser';
 import { FormsModule } from '@angular/forms';
 
 /**
@@ -208,6 +208,8 @@ class LocalizeTokenService {
         }
     }
     tenantToken(name) {
+        if (!name)
+            return undefined;
         return LocalizeToken.storage.get(name);
     }
     storageGet() {
@@ -224,6 +226,11 @@ class LocalizeTokenService {
         const base64 = btoa(JSON.stringify(value));
         LocalizeToken.storage.set(this.config.authTokenName, base64);
     }
+    tokensValid(tenantTokenName) {
+        var _a, _b;
+        return !!((_a = this.refreshToken) === null || _a === void 0 ? void 0 : _a.length)
+            && (!this.config.needTenant || !!((_b = this.tenantToken(tenantTokenName)) === null || _b === void 0 ? void 0 : _b.length));
+    }
     get decodeRefreshToken() {
         const token = LocalizeToken.storage.get(this.config.refreshTokenName);
         if (!token)
@@ -242,136 +249,452 @@ LocalizeTokenService.ctorParameters = () => [];
  */
 var EMethod;
 (function (EMethod) {
-    EMethod[EMethod["POST"] = 1] = "POST";
-    EMethod[EMethod["GET"] = 2] = "GET";
-    EMethod[EMethod["PUT"] = 3] = "PUT";
-    EMethod[EMethod["DELETE"] = 4] = "DELETE";
-    EMethod[EMethod["PATCH"] = 5] = "PATCH";
-})(EMethod || (EMethod = {}));
+    EMethod["POST"] = "post";
+    EMethod["GET"] = "get";
+    EMethod["PUT"] = "put";
+    EMethod["DELETE"] = "delete";
+    EMethod["PATCH"] = "patch";
+})(EMethod || (EMethod = {}));
+
+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();
+    }
+}
+const ApiHelper = new LocalizeApiHelper();
+
+const SCHEMES = LocalizeToken.httpHeaders;
 class LocalizeApiService {
     constructor(httpClient, localizeTokenService) {
         this.httpClient = httpClient;
         this.localizeTokenService = localizeTokenService;
+        this.destroy$ = new Subject();
         this.isRequestingSubject = new BehaviorSubject(false);
         this.isResolvedStartupSubject = new BehaviorSubject(false);
-        this.apiConfigs = {};
+        this.needTenant = LocalizeToken.config.needTenant;
+        this.config = {
+            waitEachRequest: { milliseconds: 0 },
+            enableRequestCancellation: true,
+            retryOptions: {
+                maxRetries: 1000,
+                delay: 1000,
+                retryFunction: ApiHelper.defaultRetryFunction.bind(this),
+            },
+        };
+        this.apiOptions = {
+            method: EMethod.GET,
+            requestBody: null,
+        };
         /**
          * A higher-order function that returns a curried function for making API requests.
          *
          * @param baseUrl - The base URL of the API.
          * @returns A curried function that can be used to make API requests.
          */
-        this.func = (baseUrl) => (path, method = EMethod.GET, value = null, isFormData = false, headers) => this.base(baseUrl, path, method, value, isFormData, headers);
+        this.func = (baseUrl) => (path, method = EMethod.GET, reqBody = null, reqHeaders) => this.request(baseUrl, path, method, reqBody, reqHeaders);
     }
-    get isRequesting() { return this.isRequestingSubject.value; }
     get isResolvedStartup() { return this.isResolvedStartupSubject.value; }
+    get isRequesting() { return this.isRequestingSubject.value; }
+    get isRevokingToken() { return this.localizeTokenService.isRevokingToken; }
+    set isRevokingToken(value) { this.localizeTokenService.isRevokingToken = value; }
+    get accessToken() { return this.localizeTokenService.accessToken; }
+    set accessToken(value) { this.localizeTokenService.accessToken = value; }
+    get refreshToken() { return this.localizeTokenService.refreshToken; }
+    get tenantToken() { return this.localizeTokenService.tenantToken(this.config.tenantTokenName); }
     /**
      * Initialize the API service.
      * @param apiConfigs - The API configurations.
      */
     init(apiConfigs) {
-        this.apiConfigs = apiConfigs;
+        this.config = Object.assign(Object.assign({}, this.config), apiConfigs);
+        ApiHelper.validateConfig(this.config);
+    }
+    cancelPendingRequests() {
+        this.config.enableRequestCancellation
+            && this.destroy$.next();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
     }
-    base(baseUrl, path, method = EMethod.GET, value = null, isFormData = false, headers) {
+    request(baseUrl, path, method = EMethod.GET, reqBody = null, reqHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.ifPromise(this.apiConfigs.onPrepareRequest);
-            const url = `${baseUrl.trim().replace(/\/?$/, '/')}${path.trim().replace(/^\//, '')}`;
-            const httpMethod = EMethod[method].toLowerCase();
-            const request = () => { return { body: value, headers: this.options(isFormData, headers) }; };
-            // Wait for previous request to complete
-            yield this.toWaitForPreviousRequest();
-            // Process request
+            yield ApiHelper.invokeHook(this.config.onPrepareRequest);
+            const apiOptions = this.buildApiOptions(baseUrl, path, method, reqBody, reqHeaders);
             try {
-                return yield this.processRequest(httpMethod, url, request());
+                yield this.toWaitForPreviousRequest();
+                return yield ApiHelper.performRequestWithRetry(apiOptions, this.config, this.performRequest.bind(this));
             }
-            // Handle unauthorized error if any
             catch (error) {
-                if (error.status !== 401) {
-                    throw error;
-                }
-                return yield this.onUnauthorizedError(httpMethod, url, request);
-            }
-        });
-    }
-    onUnauthorizedError(httpMethod, url, request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.revokeToken();
-            if (!this.isResolvedStartup) {
-                return yield this.processRequest(httpMethod, url, request());
+                return yield this.handleOnRequestError(error, apiOptions);
             }
         });
     }
-    toWaitForPreviousRequest() {
-        var _a;
+    handleOnRequestError(error, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.localizeTokenService.isRevokingToken) {
-                yield waitUntil(() => !this.localizeTokenService.isRevokingToken);
-            }
-            // to wait for each request in 50ms, even if the request is not completed
-            if ((_a = this.apiConfigs.waitEachRequest) === null || _a === void 0 ? void 0 : _a.milliseconds) {
-                yield waitFor(this.apiConfigs.waitEachRequest.milliseconds, this.isRequesting);
-            }
+            if (error.status !== 401 || this.isResolvedStartup)
+                throw error;
+            return yield ApiHelper.performRetry({
+                maxRetries: () => 1000,
+                delay: 500,
+                retryUnless: (error) => error.status === 401 || ApiHelper.isConnectionError(error),
+                callback: () => __awaiter(this, void 0, void 0, function* () {
+                    // Only handle 401 Unauthorized errors
+                    yield this.revokeToken();
+                    // Retry the request with the new access token
+                    return yield this.performRequest(options);
+                })
+            });
         });
     }
-    processRequest(method, url, options) {
+    performRequest(options) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Build the request options
+            const buildOptions = { headers: this.buildHeaderOptions(options) };
+            // Create the request observable
+            const request$ = ApiHelper.createRequest({
+                client: this.httpClient,
+                destroy$: () => this.destroy$
+            }, options.method, options.requestUrl, options.requestBody, buildOptions);
+            // Set the isRequesting state to true before making the request
             this.isRequestingSubject.next(true);
-            const result = yield new Promise((resolve, reject) => this.httpClient.request(method, url, options).subscribe({ next: resolve, error: reject }));
+            const response = yield new Promise((resolve, reject) => request$.subscribe({ next: (res) => resolve(res.body), error: reject }));
+            // Reset the isRequesting state after the request completes
             this.isRequestingSubject.next(false);
-            return result;
+            return response;
         });
     }
     revokeToken() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.localizeTokenService.isRevokingToken) {
-                yield waitUntil(() => !this.localizeTokenService.isRevokingToken);
-                return;
-            }
             try {
-                this.localizeTokenService.isRevokingToken = true;
-                const reqUrl = LocalizeToken.config.revokeTokenUrl;
-                const reqHeaders = this.options().append(LocalizeToken.httpHeaders.X_REFRESH_TOKEN, `${this.localizeTokenService.refreshToken}`);
-                const revokeToken = yield new Promise((resolve, reject) => this.httpClient.get(reqUrl, { headers: reqHeaders }).subscribe({ next: resolve, error: reject }));
-                if (revokeToken === null || revokeToken === void 0 ? void 0 : revokeToken.status) {
-                    this.localizeTokenService.accessToken = revokeToken.message;
-                }
-                else if (!this.localizeTokenService.refreshToken) {
-                    yield this.ifPromise(this.apiConfigs.onAutoLogout);
-                }
-                else {
-                    if (this.apiConfigs.onRevokeUnauthorized) {
-                        yield this.ifPromise(this.apiConfigs.onRevokeUnauthorized);
-                        // await this.revokeToken(true);
-                    }
-                }
+                if (yield this.interceptRevokeToken())
+                    return;
+                this.isRevokingToken = true;
+                const apiOptions = Object.assign(Object.assign({}, this.buildApiOptions(LocalizeToken.config.revokeTokenUrl)), { refreshToken: true });
+                // const revokeToken = await this.performRequest(apiOptions);
+                const revokeToken = yield ApiHelper.performRequestWithRetry(apiOptions, this.config, this.performRequest.bind(this));
+                yield this.handleOnTokenRevoked(revokeToken);
+            }
+            catch (error) {
+                // Handle the error, log it
+                yield ApiHelper.invokeHook(this.config.onAutoLogout);
             }
             finally {
-                this.localizeTokenService.isRevokingToken = false;
+                // Reset the revoking token state
+                this.isRevokingToken = false;
             }
         });
     }
     /** default http request options */
-    options(isFormData = false, headers = {}) {
-        const defaultHeaders = { [LocalizeToken.httpHeaders.AUTHORIZATION]: `Bearer ${this.localizeTokenService.accessToken}`, };
-        if (LocalizeToken.config.needTenant) {
-            defaultHeaders[LocalizeToken.httpHeaders.X_TENANT] = `${this.localizeTokenService.tenantToken(this.apiConfigs.tenantTokenName)}`;
-        }
-        if (!isFormData) {
-            defaultHeaders[LocalizeToken.httpHeaders.CONTENT_TYPE] = 'application/json';
+    buildHeaderOptions(options) {
+        let headers = Object.assign(Object.assign({}, (options.refreshToken && { [SCHEMES.X_REFRESH_TOKEN]: `${this.refreshToken}` })), (!options.isFormData && { [SCHEMES.CONTENT_TYPE]: 'application/json' }));
+        if (!options.refreshToken) {
+            headers = Object.assign(Object.assign(Object.assign({}, headers), { [SCHEMES.AUTHORIZATION]: `Bearer ${this.accessToken}` }), (this.needTenant && { [SCHEMES.X_TENANT]: `${this.tenantToken}` }));
         }
-        const filteredHeaders = Object.keys(defaultHeaders).filter(key => !Object.keys(headers).includes(key))
-            .reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: defaultHeaders[key] })), {});
-        const mergedHeaders = Object.assign(Object.assign({}, filteredHeaders), headers);
-        return new HttpHeaders(mergedHeaders);
+        return new HttpHeaders(Object.assign(Object.assign({}, headers), options.headers));
     }
-    ifPromise(fn) {
+    buildApiOptions(baseUrl, path = '', method = EMethod.GET, requestBody = null, headers) {
+        const requestUrl = ApiHelper.buildUrl(baseUrl, path);
+        const isFormData = requestBody && requestBody instanceof FormData;
+        return Object.assign(Object.assign({}, this.apiOptions), { headers, method, requestUrl, requestBody, isFormData });
+    }
+    toWaitForPreviousRequest() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!fn)
-                return;
-            return fn instanceof Promise ? yield fn() : fn();
+            this.isRevokingToken &&
+                (yield waitUntil(() => !this.isRevokingToken));
+            // to wait for each request in 50ms, even if the request is not completed
+            ((_a = this.config.waitEachRequest) === null || _a === void 0 ? void 0 : _a.milliseconds) &&
+                (yield waitFor(this.config.waitEachRequest.milliseconds, this.isRequesting));
+        });
+    }
+    handleOnTokenRevoked(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (response === null || response === void 0 ? void 0 : response.status) {
+                // If the response is successful, update the access token
+                this.accessToken = response.message;
+            }
+            else {
+                // If the response indicates an error, invoke the onRevokeUnauthorized hook
+                console.warn('Token revocation failed, refresh token is expired.', response.message);
+                yield ApiHelper.invokeHook(this.config.onRevokeUnauthorized);
+            }
+        });
+    }
+    interceptRevokeToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isRevokingToken) {
+                console.warn('Token is already being revoked. Waiting for the current operation to complete...');
+                yield waitUntil(() => !this.isRevokingToken);
+                return true;
+            }
+            if (!this.refreshToken) {
+                // await ApiHelper.invokeHook(this.apiConfigs.onAutoLogout);
+                throw new Error('Refresh token is missing. Please login again.');
+            }
+            return false;
         });
     }
-} //class
+}
 LocalizeApiService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LocalizeApiService_Factory() { return new LocalizeApiService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(LocalizeTokenService)); }, token: LocalizeApiService, providedIn: "root" });
 LocalizeApiService.decorators = [
     { type: Injectable, args: [{
@@ -390,18 +713,19 @@ LocalizeTokenModule.decorators = [
                 providers: [
                     LocalizeTokenService,
                     LocalizeApiService
-                ],
+                ]
             },] }
 ];
 
 class LocalizeLogindlgComponent {
-    constructor(messageService, cdt, dlgRef, dlgConfig, tokenService, httpClient) {
+    constructor(messageService, cdt, dlgRef, dlgConfig, tokenService, httpClient, sanitizer) {
         this.messageService = messageService;
         this.cdt = cdt;
         this.dlgRef = dlgRef;
         this.dlgConfig = dlgConfig;
         this.tokenService = tokenService;
         this.httpClient = httpClient;
+        this.sanitizer = sanitizer;
         this.messageKey = "$login-dlg";
         this.loading = false;
         this.success = false;
@@ -409,6 +733,7 @@ class LocalizeLogindlgComponent {
         this.clickLogout = () => { var _a; return (_a = this.logout) === null || _a === void 0 ? void 0 : _a.call(this); };
         this.decodeToken = this.tokenService.decodeRefreshToken;
         this.loginConfig = this.dlgConfig.data.loginConfig;
+        this.properties = this.loginConfig.properties;
     }
     ngOnInit() {
         this.dlgConfig.closable = false;
@@ -426,31 +751,37 @@ class LocalizeLogindlgComponent {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isValidPassword) {
-                this.showMessage("error", "Password is required and must be at least 6 characters");
-                return;
+                return this.showMessage("error", "Password is required and must be at least 6 characters");
             }
             this.loading = true;
             const loginRes = yield this.login();
             if (!(loginRes === null || loginRes === void 0 ? void 0 : loginRes.status)) {
-                this.showMessage("error", (_a = loginRes.message) !== null && _a !== void 0 ? _a : "An error occurred");
-                return;
+                return this.showMessage("error", (_a = loginRes.message) !== null && _a !== void 0 ? _a : "An error occurred");
             }
             this.tokenService.accessToken = loginRes.tokens.accessToken;
-            const cookieOptions = { expires: (_b = this.loginConfig.expire) !== null && _b !== void 0 ? _b : 5 };
+            const cookieOptions = { expires: (_b = this.loginConfig.expire) !== null && _b !== void 0 ? _b : 365 };
             LocalizeToken.storage.set(this.config.refreshTokenName, loginRes.tokens.refreshToken, cookieOptions);
             this.success = true;
-            setTimeout(() => this.dlgRef.close(true), 2000);
+            setTimeout(() => {
+                this.dlgConfig.dismissableMask = true;
+                this.dlgConfig.modal = false;
+                this.dlgRef.close(true);
+            }, 2000);
         });
     }
     login() {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.loginUrl || !this.loginUrl.trim().length) {
+            if (!((_a = this.loginUrl) === null || _a === void 0 ? void 0 : _a.trim().length)) {
                 this.showMessage("error", "Login url is required");
                 throw new Error("Login url is required");
             }
             try {
-                return yield new Promise((resolve, reject) => this.httpClient.post(this.loginUrl, { password: this.password.trim() }, { headers: this.getHeaders() })
-                    .subscribe({ next: resolve, error: reject }));
+                if (this.loginConfig.loginFunction) {
+                    console.log("Using custom login function");
+                    return yield this.loginConfig.loginFunction((_c = (_b = this.decodeToken) === null || _b === void 0 ? void 0 : _b.email) !== null && _c !== void 0 ? _c : '', this.password.trim(), this.getHeaders());
+                }
+                return yield new Promise((resolve, reject) => this.httpClient.post(this.loginUrl, { password: this.password.trim() }, { headers: this.getHeaders() }).subscribe({ next: resolve, error: reject }));
             }
             catch (e) {
                 this.showMessage("error", e.message);
@@ -467,21 +798,27 @@ class LocalizeLogindlgComponent {
     }
     get isValidPassword() {
         this.loading = false;
-        return this.password && this.password.trim().length >= 6 && this.password.trim().length <= 50;
+        return this.properties.passwordValidator
+            ? this.properties.passwordValidator(this.password)
+            : this.password && this.password.trim().length >= 6 && this.password.trim().length <= 50;
     }
     showMessage(severity, summary) {
         this.messageService.add({ key: this.messageKey, severity, summary });
         this.loading = false;
     }
+    get sanitizedTitle() {
+        var _a;
+        return this.sanitizer.bypassSecurityTrustHtml((_a = this.properties.title) !== null && _a !== void 0 ? _a : '');
+    }
 }
 LocalizeLogindlgComponent.decorators = [
     { type: Component, args: [{
                 template: `<p-toast key="$login-dlg" position="top-center"></p-toast>
   <div id="login-dlg-wrap">
     <div id="login-dlg-header">
-      <div id="login-logo" class="p-mb-2"></div>
-      <h3 *ngIf="!success">Your session is expired! <br> Please login again to continue.</h3>
-      <h3 *ngIf="success" style="color:green !important;">You haved successfully logged in.</h3>
+      <div id="login-logo" class="p-mb-2" style="background: url('{{properties.logoImage}}') no-repeat"></div>
+      <h3 *ngIf="!success" [innerHTML]="sanitizedTitle"></h3>
+      <h3 *ngIf="success" style="color:green !important;">{{properties.loginSuccessMessage}}</h3>
     </div>
     <div id="login-dlg-content">
       <ng-container *ngIf="!success">
@@ -493,7 +830,7 @@ LocalizeLogindlgComponent.decorators = [
             <span class="p-inputgroup-addon">
               <i class="material-icons-round">person</i>
             </span>
-            <input disabled pInputText type="text" placeholder="Username" [value]="decodeToken?.email" />
+            <input disabled pInputText type="text" placeholder="{{properties.username?.placeHolder}}" [value]="decodeToken?.email" />
           </div>
         </div>
   
@@ -502,18 +839,20 @@ LocalizeLogindlgComponent.decorators = [
             <span class="p-inputgroup-addon">
               <i class="material-icons-round">lock</i>
             </span>
-            <input [disabled]="loading" (keydown.enter)="clickLogin()" pInputText type="password" placeholder="Password" [(ngModel)]="password"
+            <input [disabled]="loading" (keydown.enter)="clickLogin()" pInputText type="password" 
+              placeholder="{{properties.password?.placeHolder}}" [(ngModel)]="password"
               autofocus />
           </div>
         </div>
         <div class="login-dlg-elm">
-          <button style="width: 100%;" pButton type="button" label="Login" (click)="clickLogin()"
+          <button style="width: 100%;" pButton type="button" label="{{properties.loginButton?.placeHolder}}" (click)="clickLogin()"
             [disabled]="!password || loading"></button>
         </div>
   
-        <div class="login-dlg-elm" style="display:flex;align-items: center;user-select: none;">
-          <span>No, I want to login with another user.</span>
-          <button class="p-button-text" pButton type="button" label="Logout" (click)="clickLogout()"></button>
+        <div class="login-dlg-elm login-dlg-suggest" style="display:flex;align-items: center;user-select: none;">
+          <span>{{properties.logoutButton?.message}}</span>
+          <button class="p-button-text" pButton type="button" label="{{properties.logoutButton?.placeHolder}}" 
+            (click)="clickLogout()"></button>
         </div>
       </ng-container>
   
@@ -543,11 +882,23 @@ LocalizeLogindlgComponent.decorators = [
     max-width: 400px;
     margin: 0 auto;
     padding: 30px;
+    height: 100%;
   }
   
   .login-dlg-elm {
     margin-top: 1rem;
   }
+
+  .login-dlg-elm.login-dlg-suggest {
+    display: flex ;
+    align-items: center;
+    user-select: none;
+    border-bottom: solid 1px #ddd;
+    border-radius: 5px;
+    padding: 5px 10px;
+    background: #f9f9f9;
+    box-shadow: 1px 5px 10px -12px #000;
+  }
   
   #login-dlg-header {
     display: flex;
@@ -564,10 +915,10 @@ LocalizeLogindlgComponent.decorators = [
   }
   
   #login-logo {
-    height: 40px;
-    width: 40px;
-    background: url("/assets/images/logo-300px.png") no-repeat;
-    background-size: contain;
+    height: 55px;
+    width: 55px;
+    /* background: url("/assets/images/logo-300px.png") no-repeat; */
+    background-size: contain !important;
   }
   
   #login-dlg-content .p-inputgroup {
@@ -579,6 +930,10 @@ LocalizeLogindlgComponent.decorators = [
     border-radius: 15px 0 0 15px;
     width: 50px;
   }
+  #login-dlg-content *{
+    font-size: .9rem;
+    /* font-family: 'Lexend', 'Roboto', sans-serif, 'material-icons-round'; */
+  }
   
   #login-dlg-content .p-inputgroup .p-inputgroup-addon * {
     font-size: 1rem;
@@ -773,7 +1128,8 @@ LocalizeLogindlgComponent.ctorParameters = () => [
     { type: DynamicDialogRef },
     { type: DynamicDialogConfig },
     { type: LocalizeTokenService },
-    { type: HttpClient }
+    { type: HttpClient },
+    { type: DomSanitizer }
 ];
 
 class LocalizeLogindlgService {
@@ -782,12 +1138,9 @@ class LocalizeLogindlgService {
     }
     openLoginDialog(loginConfig, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            config !== null && config !== void 0 ? config : (config = {
-                header: 'Login',
-                height: '650px',
-                style: { 'max-width': '400px', width: '100%', 'height': '650px' },
-            });
-            config.data = Object.assign(Object.assign({}, config.data || {}), { loginConfig });
+            config = this.intercepDialogConfig(config);
+            this.initConfig(loginConfig);
+            config.data = Object.assign(Object.assign({}, (config.data || {})), { loginConfig });
             const dialogService = this.injector.get(DialogService);
             const dialog = dialogService.open(LocalizeLogindlgComponent, config);
             yield new Promise((resolve) => dialog.onClose.subscribe(res => {
@@ -797,6 +1150,36 @@ class LocalizeLogindlgService {
             }));
         });
     }
+    intercepDialogConfig(config) {
+        config !== null && config !== void 0 ? config : (config = {
+            header: 'Login',
+            style: { 'max-width': '400px', width: '100%', 'height': '650px' },
+            modal: true,
+            closable: false,
+            showHeader: false,
+        });
+        config = Object.assign(Object.assign({}, config), {
+            contentStyle: { 'height': '100%', 'border-radius': '20px' }
+        });
+        config.style = Object.assign(Object.assign({}, config.style), { 'border-radius': '20px' });
+        return config;
+    }
+    initConfig(loginConfig) {
+        var _a;
+        loginConfig !== null && loginConfig !== void 0 ? loginConfig : (loginConfig = {});
+        (_a = loginConfig.properties) !== null && _a !== void 0 ? _a : (loginConfig.properties = {
+            title: 'Your session is expired!<br/> Please login again to continue.',
+            loginSuccessMessage: 'You have successfully logged in.',
+            logoImage: '/assets/images/logo-300px.png',
+            username: { placeHolder: 'Username' },
+            password: { placeHolder: 'Password' },
+            loginButton: { placeHolder: 'Login' },
+            logoutButton: {
+                message: 'No, I want to login with another user.',
+                placeHolder: 'Logout'
+            }
+        });
+    }
 }
 LocalizeLogindlgService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LocalizeLogindlgService_Factory() { return new LocalizeLogindlgService(i0.ɵɵinject(i0.INJECTOR)); }, token: LocalizeLogindlgService, providedIn: "root" });
 LocalizeLogindlgService.decorators = [
@@ -831,5 +1214,5 @@ LocalizeLogindlgModule.decorators = [
  * Generated bundle index. Do not edit.
  */
 
-export { EMethod, LocalizeApiService, LocalizeLogindlgComponent, LocalizeLogindlgModule, LocalizeLogindlgService, LocalizeToken, LocalizeTokenModule, LocalizeTokenService, LocalizeTokenStorage, extractMainDomain, waitFor, waitUntil };
+export { ApiHelper, EMethod, LocalizeApiService, LocalizeLogindlgComponent, LocalizeLogindlgModule, LocalizeLogindlgService, LocalizeToken, LocalizeTokenModule, LocalizeTokenService, LocalizeTokenStorage, extractMainDomain, waitFor, waitUntil };
 //# sourceMappingURL=sambath999-localize-token.js.map