@sambath999/localize-token 18.0.3 → 18.0.5

package/esm2022/localize-logindlg/localize-logindlg.component.mjs

@@ -0,0 +1,210 @@
+import { Component, ViewEncapsulation, } from "@angular/core";
+import { MessageService } from "primeng/api";
+import { LocalizeToken } from "../localize-token/localize.token";
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+import * as i2 from "primeng/dynamicdialog";
+import * as i3 from "../localize-token/localize.token.service";
+import * as i4 from "@angular/common/http";
+import * as i5 from "@angular/common";
+import * as i6 from "primeng/toast";
+import * as i7 from "primeng/inputtext";
+import * as i8 from "@angular/forms";
+export class LocalizeLogindlgComponent {
+    messageService;
+    cdt;
+    dlgRef;
+    dlgConfig;
+    tokenService;
+    httpClient;
+    messageKey = "$login-dlg";
+    password;
+    decodeToken;
+    loading = false;
+    success = false;
+    config;
+    logout;
+    loginUrl;
+    constructor(messageService, cdt, dlgRef, dlgConfig, tokenService, httpClient) {
+        this.messageService = messageService;
+        this.cdt = cdt;
+        this.dlgRef = dlgRef;
+        this.dlgConfig = dlgConfig;
+        this.tokenService = tokenService;
+        this.httpClient = httpClient;
+        this.decodeToken = this.tokenService.decodeRefreshToken;
+        this.config = LocalizeToken.config;
+    }
+    ngOnInit() {
+        this.dlgConfig.closable = false;
+        this.logout = this.dlgConfig.data?.logout;
+        this.loginUrl = this.dlgConfig.data?.loginUrl;
+        if (!this.decodeToken) {
+            this.messageService.add({
+                key: this.messageKey,
+                severity: "error",
+                summary: "Token is invalid",
+            });
+            setTimeout(() => this.logout?.(), 2000);
+        }
+    }
+    ngAfterViewInit() {
+        this.cdt.detectChanges();
+    }
+    async clickLogin() {
+        if (!this.isValidPassword) {
+            this.messageService.add({
+                key: this.messageKey,
+                severity: "error",
+                summary: "Password is required and must be at least 6 characters",
+            });
+        }
+        this.loading = true;
+        const loginRes = await this.login();
+        if (!loginRes?.status) {
+            this.messageService.add({
+                key: this.messageKey,
+                severity: "error",
+                summary: loginRes.message,
+            });
+            this.loading = false;
+            return;
+        }
+        this.tokenService.accessToken = loginRes.tokens.accessToken;
+        LocalizeToken.storage.set(this.config.refreshTokenName, loginRes.tokens.refreshToken);
+        this.success = true;
+        setTimeout(() => this.dlgRef.close(true), 2000);
+    }
+    async login() {
+        const path = this.loginUrl ?? "/api/auth/login";
+        const response = await new Promise((resolve, reject) => this.httpClient
+            .post(path, { password: this.password.trim() }, { headers: this.getHeaders() })
+            .subscribe({ next: resolve, error: reject }));
+        return response;
+    }
+    getHeaders() {
+        return {
+            [LocalizeToken.httpHeaders.X_REFRESH_TOKEN]: LocalizeToken.storage.get(this.config.refreshTokenName),
+            [LocalizeToken.httpHeaders.X_TENANT]: LocalizeToken.storage.get(this.config.tenantTokenName) ?? "",
+        };
+    }
+    get isValidPassword() {
+        return this.password && this.password.trim().length >= 6;
+    }
+    clickLogout = () => this.logout?.();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeLogindlgComponent, deps: [{ token: i1.MessageService }, { token: i0.ChangeDetectorRef }, { token: i2.DynamicDialogRef }, { token: i2.DynamicDialogConfig }, { token: i3.LocalizeTokenService }, { token: i4.HttpClient }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.12", type: LocalizeLogindlgComponent, selector: "app-localize-logindlg", providers: [MessageService], ngImport: i0, 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>
+    <div id="login-dlg-content">
+      <ng-container *ngIf="!success">
+        <div class="login-dlg-elm">
+          <div class="p-inputgroup">
+            <span class="p-inputgroup-addon">
+              <i class="material-icons-round">person</i>
+            </span>
+            <input disabled pInputText type="text" placeholder="Username" [value]="decodeToken?.email" />
+          </div>
+        </div>
+  
+        <div class="login-dlg-elm">
+          <div class="p-inputgroup">
+            <span class="p-inputgroup-addon">
+              <i class="material-icons-round">lock</i>
+            </span>
+            <input (keydown.enter)="clickLogin()" pInputText type="password" placeholder="Password" [(ngModel)]="password"
+              autofocus />
+          </div>
+        </div>
+        <div class="login-dlg-elm">
+          <button style="width: 100%;" pButton type="button" label="Login" (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>
+      </ng-container>
+  
+      <ng-container *ngIf="success">
+        <div style="margin-top:35px;"></div>
+        <div class="check-animation-wrap">
+          <div class="check-main-container">
+            <div class="check-container">
+              <div class="check-background">
+                <svg viewBox="0 0 65 51" fill="none" xmlns="http://www.w3.org/2000/svg">
+                  <path d="M7 25L27.3077 44L58.5 7" stroke="white" stroke-width="13" stroke-linecap="round"
+                    stroke-linejoin="round"></path>
+                </svg>
+              </div>
+            </div>
+          </div>
+        </div>
+      </ng-container>
+    </div>
+  </div>`, isInline: true, styles: ["#login-dlg-wrap{width:100%;max-width:400px;margin:0 auto;padding:30px}.login-dlg-elm{margin-top:1rem}#login-dlg-header{display:flex;flex-direction:column;align-items:center;justify-content:center}#login-dlg-header h3{font-weight:700;font-size:.9rem;color:orange;text-align:center}#login-logo{height:40px;width:40px;background:url(/assets/images/logo-300px.png) no-repeat;background-size:contain}#login-dlg-content .p-inputgroup{height:45px}#login-dlg-content .p-inputgroup .p-inputgroup-addon{height:45px;border-radius:15px 0 0 15px;width:50px}#login-dlg-content .p-inputgroup .p-inputgroup-addon *{font-size:1rem}#login-dlg-content .p-inputgroup input{height:45px;border-radius:0 15px 15px 0}#login-dlg-content button{height:45px;border-radius:15px}.check-animation-wrap{top:0;left:0;position:absolute;display:flex;flex-direction:column;align-items:center;justify-content:center;width:100%;height:calc(100% - 200px);min-height:400px}.check-main-container{width:100%;height:100vh;display:flex;flex-flow:column;justify-content:center;align-items:center}.check-container{width:6.25rem;height:7.5rem;display:flex;flex-flow:column;align-items:center;justify-content:space-between}.check-container .check-background{width:100%;height:calc(100% - 1.25rem);background:linear-gradient(to bottom right,#5de593,#41d67c);box-shadow:0 0 0 65px #ffffff40 inset,0 0 0 65px #ffffff40 inset;transform:scale(.84);border-radius:50%;animation:animateContainer .75s ease-out forwards .75s;display:flex;align-items:center;justify-content:center;opacity:0}.check-container .check-background svg{width:65%;transform:translateY(.25rem);stroke-dasharray:80;stroke-dashoffset:80;animation:animateCheck .35s forwards 1.25s ease-out;min-width:auto!important}.check-container .check-shadow{bottom:calc(-15% - 5px);left:0;border-radius:50%;background:radial-gradient(closest-side,rgba(73,218,131,1),transparent);animation:animateShadow .75s ease-out forwards .75s}@keyframes animateContainer{0%{opacity:0;transform:scale(0);box-shadow:0 0 0 65px #ffffff40 inset,0 0 0 65px #ffffff40 inset}25%{opacity:1;transform:scale(.9);box-shadow:0 0 0 65px #ffffff40 inset,0 0 0 65px #ffffff40 inset}43.75%{transform:scale(1.15);box-shadow:0 0 0 43.334px #ffffff40 inset,0 0 0 65px #ffffff40 inset}62.5%{transform:scale(1);box-shadow:0 0 #ffffff40 inset,0 0 0 21.667px #ffffff40 inset}81.25%{box-shadow:0 0 #ffffff40 inset,0 0 #ffffff40 inset}to{opacity:1;box-shadow:0 0 #ffffff40 inset,0 0 #ffffff40 inset}}@keyframes animateCheck{0%{stroke-dashoffset:80}to{stroke-dashoffset:0}}@keyframes animateShadow{0%{opacity:0;width:100%;height:15%}25%{opacity:.25}43.75%{width:40%;height:7%;opacity:.35}to{width:85%;height:15%;opacity:.25}}\n"], dependencies: [{ kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i6.Toast, selector: "p-toast", inputs: ["key", "autoZIndex", "baseZIndex", "life", "style", "styleClass", "position", "preventOpenDuplicates", "preventDuplicates", "showTransformOptions", "hideTransformOptions", "showTransitionOptions", "hideTransitionOptions", "breakpoints"], outputs: ["onClose"] }, { kind: "directive", type: i7.InputText, selector: "[pInputText]", inputs: ["variant"] }, { kind: "directive", type: i8.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i8.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i8.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: 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>
+    <div id="login-dlg-content">
+      <ng-container *ngIf="!success">
+        <div class="login-dlg-elm">
+          <div class="p-inputgroup">
+            <span class="p-inputgroup-addon">
+              <i class="material-icons-round">person</i>
+            </span>
+            <input disabled pInputText type="text" placeholder="Username" [value]="decodeToken?.email" />
+          </div>
+        </div>
+  
+        <div class="login-dlg-elm">
+          <div class="p-inputgroup">
+            <span class="p-inputgroup-addon">
+              <i class="material-icons-round">lock</i>
+            </span>
+            <input (keydown.enter)="clickLogin()" pInputText type="password" placeholder="Password" [(ngModel)]="password"
+              autofocus />
+          </div>
+        </div>
+        <div class="login-dlg-elm">
+          <button style="width: 100%;" pButton type="button" label="Login" (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>
+      </ng-container>
+  
+      <ng-container *ngIf="success">
+        <div style="margin-top:35px;"></div>
+        <div class="check-animation-wrap">
+          <div class="check-main-container">
+            <div class="check-container">
+              <div class="check-background">
+                <svg viewBox="0 0 65 51" fill="none" xmlns="http://www.w3.org/2000/svg">
+                  <path d="M7 25L27.3077 44L58.5 7" stroke="white" stroke-width="13" stroke-linecap="round"
+                    stroke-linejoin="round"></path>
+                </svg>
+              </div>
+            </div>
+          </div>
+        </div>
+      </ng-container>
+    </div>
+  </div>`, selector: "app-localize-logindlg", providers: [MessageService], encapsulation: ViewEncapsulation.None, styles: ["#login-dlg-wrap{width:100%;max-width:400px;margin:0 auto;padding:30px}.login-dlg-elm{margin-top:1rem}#login-dlg-header{display:flex;flex-direction:column;align-items:center;justify-content:center}#login-dlg-header h3{font-weight:700;font-size:.9rem;color:orange;text-align:center}#login-logo{height:40px;width:40px;background:url(/assets/images/logo-300px.png) no-repeat;background-size:contain}#login-dlg-content .p-inputgroup{height:45px}#login-dlg-content .p-inputgroup .p-inputgroup-addon{height:45px;border-radius:15px 0 0 15px;width:50px}#login-dlg-content .p-inputgroup .p-inputgroup-addon *{font-size:1rem}#login-dlg-content .p-inputgroup input{height:45px;border-radius:0 15px 15px 0}#login-dlg-content button{height:45px;border-radius:15px}.check-animation-wrap{top:0;left:0;position:absolute;display:flex;flex-direction:column;align-items:center;justify-content:center;width:100%;height:calc(100% - 200px);min-height:400px}.check-main-container{width:100%;height:100vh;display:flex;flex-flow:column;justify-content:center;align-items:center}.check-container{width:6.25rem;height:7.5rem;display:flex;flex-flow:column;align-items:center;justify-content:space-between}.check-container .check-background{width:100%;height:calc(100% - 1.25rem);background:linear-gradient(to bottom right,#5de593,#41d67c);box-shadow:0 0 0 65px #ffffff40 inset,0 0 0 65px #ffffff40 inset;transform:scale(.84);border-radius:50%;animation:animateContainer .75s ease-out forwards .75s;display:flex;align-items:center;justify-content:center;opacity:0}.check-container .check-background svg{width:65%;transform:translateY(.25rem);stroke-dasharray:80;stroke-dashoffset:80;animation:animateCheck .35s forwards 1.25s ease-out;min-width:auto!important}.check-container .check-shadow{bottom:calc(-15% - 5px);left:0;border-radius:50%;background:radial-gradient(closest-side,rgba(73,218,131,1),transparent);animation:animateShadow .75s ease-out forwards .75s}@keyframes animateContainer{0%{opacity:0;transform:scale(0);box-shadow:0 0 0 65px #ffffff40 inset,0 0 0 65px #ffffff40 inset}25%{opacity:1;transform:scale(.9);box-shadow:0 0 0 65px #ffffff40 inset,0 0 0 65px #ffffff40 inset}43.75%{transform:scale(1.15);box-shadow:0 0 0 43.334px #ffffff40 inset,0 0 0 65px #ffffff40 inset}62.5%{transform:scale(1);box-shadow:0 0 #ffffff40 inset,0 0 0 21.667px #ffffff40 inset}81.25%{box-shadow:0 0 #ffffff40 inset,0 0 #ffffff40 inset}to{opacity:1;box-shadow:0 0 #ffffff40 inset,0 0 #ffffff40 inset}}@keyframes animateCheck{0%{stroke-dashoffset:80}to{stroke-dashoffset:0}}@keyframes animateShadow{0%{opacity:0;width:100%;height:15%}25%{opacity:.25}43.75%{width:40%;height:7%;opacity:.35}to{width:85%;height:15%;opacity:.25}}\n"] }]
+        }], ctorParameters: () => [{ type: i1.MessageService }, { type: i0.ChangeDetectorRef }, { type: i2.DynamicDialogRef }, { type: i2.DynamicDialogConfig }, { type: i3.LocalizeTokenService }, { type: i4.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localize-logindlg.component.js","sourceRoot":"","sources":["../../../src/localize-logindlg/localize-logindlg.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\r\nimport {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  OnInit,\r\n  ViewEncapsulation,\r\n} from \"@angular/core\";\r\nimport { MessageService } from \"primeng/api\";\r\nimport { DynamicDialogConfig, DynamicDialogRef } from \"primeng/dynamicdialog\";\r\nimport { JwtPayload, LocalizeTokenService } from \"../localize-token/localize.token.service\";\r\nimport { LocalizeToken } from \"../localize-token/localize.token\";\r\n\r\n@Component({\r\n  styles: `#login-dlg-wrap {\r\n    width: 100%;\r\n    max-width: 400px;\r\n    margin: 0 auto;\r\n    padding: 30px;\r\n  }\r\n  \r\n  .login-dlg-elm {\r\n    margin-top: 1rem;\r\n  }\r\n  \r\n  #login-dlg-header {\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: center;\r\n    justify-content: center;\r\n  }\r\n  \r\n  #login-dlg-header h3 {\r\n    font-weight: bold;\r\n    font-size: 0.9rem;\r\n    color: orange;\r\n    text-align: center;\r\n  }\r\n  \r\n  #login-logo {\r\n    height: 40px;\r\n    width: 40px;\r\n    background: url(\"/assets/images/logo-300px.png\") no-repeat;\r\n    background-size: contain;\r\n  }\r\n  \r\n  #login-dlg-content .p-inputgroup {\r\n    height: 45px;\r\n  }\r\n  \r\n  #login-dlg-content .p-inputgroup .p-inputgroup-addon {\r\n    height: 45px;\r\n    border-radius: 15px 0 0 15px;\r\n    width: 50px;\r\n  }\r\n  \r\n  #login-dlg-content .p-inputgroup .p-inputgroup-addon * {\r\n    font-size: 1rem;\r\n  }\r\n  \r\n  #login-dlg-content .p-inputgroup input {\r\n    height: 45px;\r\n    border-radius: 0 15px 15px 0;\r\n  }\r\n  \r\n  #login-dlg-content button {\r\n    height: 45px;\r\n    border-radius: 15px;\r\n  }\r\n  \r\n  /*check animation block*/\r\n  \r\n  .check-animation-wrap {\r\n    top: 0;\r\n    left: 0;\r\n    position: absolute;\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: center;\r\n    justify-content: center;\r\n    width: 100%;\r\n    height: calc(100% - 200px);\r\n    min-height: 400px;\r\n  }\r\n  \r\n  .check-main-container {\r\n    width: 100%;\r\n    height: 100vh;\r\n    display: flex;\r\n    flex-flow: column;\r\n    justify-content: center;\r\n    align-items: center;\r\n  }\r\n  \r\n  .check-container {\r\n    width: 6.25rem;\r\n    height: 7.5rem;\r\n    display: flex;\r\n    flex-flow: column;\r\n    align-items: center;\r\n    justify-content: space-between;\r\n  }\r\n  \r\n  .check-container .check-background {\r\n    width: 100%;\r\n    height: calc(100% - 1.25rem);\r\n    background: linear-gradient(to bottom right, #5de593, #41d67c);\r\n    box-shadow: 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset;\r\n    transform: scale(0.84);\r\n    border-radius: 50%;\r\n    animation: animateContainer 0.75s ease-out forwards 0.75s;\r\n    display: flex;\r\n    align-items: center;\r\n    justify-content: center;\r\n    opacity: 0;\r\n  }\r\n  \r\n  .check-container .check-background svg {\r\n    width: 65%;\r\n    transform: translateY(0.25rem);\r\n    stroke-dasharray: 80;\r\n    stroke-dashoffset: 80;\r\n    animation: animateCheck 0.35s forwards 1.25s ease-out;\r\n    min-width: auto !important;\r\n  }\r\n  \r\n  .check-container .check-shadow {\r\n    bottom: calc(-15% - 5px);\r\n    left: 0;\r\n    border-radius: 50%;\r\n    background: radial-gradient(closest-side, rgba(73, 218, 131, 1), transparent);\r\n    animation: animateShadow 0.75s ease-out forwards 0.75s;\r\n  }\r\n  \r\n  @keyframes animateContainer {\r\n    0% {\r\n      opacity: 0;\r\n      transform: scale(0);\r\n      box-shadow: 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset;\r\n    }\r\n  \r\n    25% {\r\n      opacity: 1;\r\n      transform: scale(0.9);\r\n      box-shadow: 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset;\r\n    }\r\n  \r\n    43.75% {\r\n      transform: scale(1.15);\r\n      box-shadow: 0px 0px 0px 43.334px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset;\r\n    }\r\n  \r\n    62.5% {\r\n      transform: scale(1);\r\n      box-shadow: 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 21.667px rgba(255, 255, 255, 0.25) inset;\r\n    }\r\n  \r\n    81.25% {\r\n      box-shadow: 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset;\r\n    }\r\n  \r\n    100% {\r\n      opacity: 1;\r\n      box-shadow: 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset;\r\n    }\r\n  }\r\n  \r\n  @keyframes animateCheck {\r\n    from {\r\n      stroke-dashoffset: 80;\r\n    }\r\n  \r\n    to {\r\n      stroke-dashoffset: 0;\r\n    }\r\n  }\r\n  \r\n  @keyframes animateShadow {\r\n    0% {\r\n      opacity: 0;\r\n      width: 100%;\r\n      height: 15%;\r\n    }\r\n  \r\n    25% {\r\n      opacity: 0.25;\r\n    }\r\n  \r\n    43.75% {\r\n      width: 40%;\r\n      height: 7%;\r\n      opacity: 0.35;\r\n    }\r\n  \r\n    100% {\r\n      width: 85%;\r\n      height: 15%;\r\n      opacity: 0.25;\r\n    }\r\n  }`,\r\n  template: `<p-toast key=\"$login-dlg\" position=\"top-center\"></p-toast>\r\n  <div id=\"login-dlg-wrap\">\r\n    <div id=\"login-dlg-header\">\r\n      <div id=\"login-logo\" class=\"p-mb-2\"></div>\r\n      <h3 *ngIf=\"!success\">Your session is expired! <br> Please login again to continue.</h3>\r\n      <h3 *ngIf=\"success\" style=\"color:green !important;\">You haved successfully logged in.</h3>\r\n    </div>\r\n    <div id=\"login-dlg-content\">\r\n      <ng-container *ngIf=\"!success\">\r\n        <div class=\"login-dlg-elm\">\r\n          <div class=\"p-inputgroup\">\r\n            <span class=\"p-inputgroup-addon\">\r\n              <i class=\"material-icons-round\">person</i>\r\n            </span>\r\n            <input disabled pInputText type=\"text\" placeholder=\"Username\" [value]=\"decodeToken?.email\" />\r\n          </div>\r\n        </div>\r\n  \r\n        <div class=\"login-dlg-elm\">\r\n          <div class=\"p-inputgroup\">\r\n            <span class=\"p-inputgroup-addon\">\r\n              <i class=\"material-icons-round\">lock</i>\r\n            </span>\r\n            <input (keydown.enter)=\"clickLogin()\" pInputText type=\"password\" placeholder=\"Password\" [(ngModel)]=\"password\"\r\n              autofocus />\r\n          </div>\r\n        </div>\r\n        <div class=\"login-dlg-elm\">\r\n          <button style=\"width: 100%;\" pButton type=\"button\" label=\"Login\" (click)=\"clickLogin()\"\r\n            [disabled]=\"!password || loading\"></button>\r\n        </div>\r\n  \r\n        <div class=\"login-dlg-elm\" style=\"display:flex;align-items: center;user-select: none;\">\r\n          <span>No, I want to login with another user.</span>\r\n          <button class=\"p-button-text\" pButton type=\"button\" label=\"Logout\" (click)=\"clickLogout()\"></button>\r\n        </div>\r\n      </ng-container>\r\n  \r\n      <ng-container *ngIf=\"success\">\r\n        <div style=\"margin-top:35px;\"></div>\r\n        <div class=\"check-animation-wrap\">\r\n          <div class=\"check-main-container\">\r\n            <div class=\"check-container\">\r\n              <div class=\"check-background\">\r\n                <svg viewBox=\"0 0 65 51\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                  <path d=\"M7 25L27.3077 44L58.5 7\" stroke=\"white\" stroke-width=\"13\" stroke-linecap=\"round\"\r\n                    stroke-linejoin=\"round\"></path>\r\n                </svg>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </ng-container>\r\n    </div>\r\n  </div>`,\r\n  selector: \"app-localize-logindlg\",\r\n  providers: [MessageService],\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class LocalizeLogindlgComponent implements OnInit {\r\n  readonly messageKey = \"$login-dlg\";\r\n  password: any;\r\n  readonly decodeToken: JwtPayload | null;\r\n  loading = false;\r\n  success = false;\r\n  private readonly config;\r\n\r\n  private logout?: () => any\r\n  private loginUrl?: string;\r\n\r\n\r\n  constructor(\r\n    private readonly messageService: MessageService,\r\n    private readonly cdt: ChangeDetectorRef,\r\n    private readonly dlgRef: DynamicDialogRef,\r\n    private readonly dlgConfig: DynamicDialogConfig,\r\n    private readonly tokenService: LocalizeTokenService,\r\n    private readonly httpClient: HttpClient\r\n  ) {\r\n    this.decodeToken = this.tokenService.decodeRefreshToken;\r\n    this.config = LocalizeToken.config;\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.dlgConfig.closable = false;\r\n    this.logout = this.dlgConfig.data?.logout;\r\n    this.loginUrl = this.dlgConfig.data?.loginUrl;\r\n\r\n    if (!this.decodeToken) {\r\n      this.messageService.add({\r\n        key: this.messageKey,\r\n        severity: \"error\",\r\n        summary: \"Token is invalid\",\r\n      });\r\n      setTimeout(() => this.logout?.(), 2000);\r\n    }\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    this.cdt.detectChanges();\r\n  }\r\n\r\n  async clickLogin() {\r\n    if (!this.isValidPassword) {\r\n      this.messageService.add({\r\n        key: this.messageKey,\r\n        severity: \"error\",\r\n        summary: \"Password is required and must be at least 6 characters\",\r\n      });\r\n    }\r\n\r\n    this.loading = true;\r\n    const loginRes = await this.login();\r\n    if (!loginRes?.status) {\r\n      this.messageService.add({\r\n        key: this.messageKey,\r\n        severity: \"error\",\r\n        summary: loginRes.message,\r\n      });\r\n      this.loading = false;\r\n      return;\r\n    }\r\n\r\n    this.tokenService.accessToken = loginRes.tokens.accessToken;\r\n    LocalizeToken.storage.set(this.config.refreshTokenName, loginRes.tokens.refreshToken);\r\n    this.success = true;\r\n    setTimeout(() => this.dlgRef.close(true), 2000);\r\n  }\r\n\r\n  private async login() {\r\n    const path = this.loginUrl ?? \"/api/auth/login\";\r\n    const response = await new Promise<any>((resolve, reject) =>\r\n      this.httpClient\r\n        .post(path, { password: this.password.trim() }, { headers: this.getHeaders() })\r\n        .subscribe({ next: resolve, error: reject })\r\n    );\r\n    return response;\r\n  }\r\n\r\n  private getHeaders() {\r\n    return {\r\n      [LocalizeToken.httpHeaders.X_REFRESH_TOKEN]: LocalizeToken.storage.get(this.config.refreshTokenName)!,\r\n      [LocalizeToken.httpHeaders.X_TENANT]: LocalizeToken.storage.get(this.config.tenantTokenName) ?? \"\",\r\n    };\r\n  }\r\n\r\n  get isValidPassword(): boolean {\r\n    return this.password && this.password.trim().length >= 6;\r\n  }\r\n\r\n  clickLogout = () => this.logout?.();\r\n}\r\n"]}

package/esm2022/localize-logindlg/localize-logindlg.module.mjs

@@ -0,0 +1,39 @@
+import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { LocalizeLogindlgComponent } from "./localize-logindlg.component";
+import { ToastModule } from "primeng/toast";
+import { InputTextModule } from "primeng/inputtext";
+import { BrowserModule } from '@angular/platform-browser';
+import { FormsModule } from '@angular/forms';
+import { LocalizeLogindlgService } from "./localize-logindlg.service";
+import * as i0 from "@angular/core";
+export class LocalizeLogindlgModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeLogindlgModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.12", ngImport: i0, type: LocalizeLogindlgModule, declarations: [LocalizeLogindlgComponent], imports: [CommonModule,
+            ToastModule,
+            InputTextModule,
+            BrowserModule,
+            FormsModule], exports: [LocalizeLogindlgComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeLogindlgModule, providers: [LocalizeLogindlgService], imports: [CommonModule,
+            ToastModule,
+            InputTextModule,
+            BrowserModule,
+            FormsModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeLogindlgModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [LocalizeLogindlgComponent],
+                    exports: [LocalizeLogindlgComponent],
+                    imports: [
+                        CommonModule,
+                        ToastModule,
+                        InputTextModule,
+                        BrowserModule,
+                        FormsModule,
+                    ],
+                    providers: [LocalizeLogindlgService],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/localize-logindlg/localize-logindlg.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { DialogService } from 'primeng/dynamicdialog';
+import { LocalizeLogindlgComponent } from './localize-logindlg.component';
+import * as i0 from "@angular/core";
+export class LocalizeLogindlgService {
+    injector;
+    constructor(injector) {
+        this.injector = injector;
+    }
+    async openLoginDialog(config) {
+        config ??= {
+            header: 'Login',
+            height: '650px',
+            style: { 'max-width': '400px', width: '100%', 'height': '650px' },
+        };
+        const dialogService = this.injector.get(DialogService);
+        const dialog = dialogService.open(LocalizeLogindlgComponent, config);
+        await new Promise((resolve) => dialog.onClose.subscribe(res => {
+            if (res) {
+                resolve();
+            }
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeLogindlgService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeLogindlgService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeLogindlgService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/localize-logindlg/public-api.mjs

@@ -0,0 +1,4 @@
+export * from './localize-logindlg.component';
+export * from './localize-logindlg.module';
+export * from './localize-logindlg.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9sb2NhbGl6ZS1sb2dpbmRsZy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUE7QUFDN0MsY0FBYyw0QkFBNEIsQ0FBQTtBQUMxQyxjQUFjLDZCQUE2QixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9sb2NhbGl6ZS1sb2dpbmRsZy5jb21wb25lbnQnXHJcbmV4cG9ydCAqIGZyb20gJy4vbG9jYWxpemUtbG9naW5kbGcubW9kdWxlJ1xyXG5leHBvcnQgKiBmcm9tICcuL2xvY2FsaXplLWxvZ2luZGxnLnNlcnZpY2UnIl19

package/esm2022/localize-token/localize.api.service.mjs

@@ -0,0 +1,138 @@
+import { Injectable } from "@angular/core";
+import { HttpHeaders } from "@angular/common/http";
+import { LocalizeToken, waitFor, waitUntil } from "./localize.token";
+import { BehaviorSubject } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./localize.token.service";
+/**
+ * Http method options
+ */
+export 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 = {}));
+export class LocalizeApiService {
+    httpClient;
+    localizeTokenService;
+    isRequestingSubject = new BehaviorSubject(false);
+    isResolvedStartupSubject = new BehaviorSubject(false);
+    get isRequesting() { return this.isRequestingSubject.value; }
+    get isResolvedStartup() { return this.isResolvedStartupSubject.value; }
+    apiConfigs = {};
+    constructor(httpClient, localizeTokenService) {
+        this.httpClient = httpClient;
+        this.localizeTokenService = localizeTokenService;
+    }
+    /**
+     * Initialize the API service.
+     * @param apiConfigs - The API configurations.
+     */
+    init(apiConfigs) {
+        this.apiConfigs = apiConfigs;
+    }
+    /**
+     * 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.
+     */
+    func = (baseUrl) => (path, method = EMethod.GET, value = null, isFormData = false, headers) => this.base(baseUrl, path, method, value, isFormData, headers);
+    async base(baseUrl, path, method = EMethod.GET, value = null, isFormData = false, headers) {
+        await 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
+        await this.toWaitForPreviousRequest();
+        // Process request
+        try {
+            return await this.processRequest(httpMethod, url, request());
+        }
+        // Handle unauthorized error if any
+        catch (error) {
+            if (error.status !== 401) {
+                throw error;
+            }
+            return await this.onUnauthorizedError(httpMethod, url, request);
+        }
+    }
+    async onUnauthorizedError(httpMethod, url, request) {
+        await this.revokeToken();
+        if (!this.isResolvedStartup) {
+            return await this.processRequest(httpMethod, url, request());
+        }
+    }
+    async toWaitForPreviousRequest() {
+        if (this.localizeTokenService.isRevokingToken) {
+            await waitUntil(() => !this.localizeTokenService.isRevokingToken);
+        }
+        // to wait for each request in 50ms, even if the request is not completed
+        await waitFor(50, this.isRequesting);
+    }
+    async processRequest(method, url, options) {
+        this.isRequestingSubject.next(true);
+        const result = await new Promise((resolve, reject) => this.httpClient.request(method, url, options).subscribe({ next: resolve, error: reject }));
+        this.isRequestingSubject.next(false);
+        return result;
+    }
+    async revokeToken(force = false) {
+        if (this.localizeTokenService.isRevokingToken && !force) {
+            await 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 = await new Promise((resolve, reject) => this.httpClient.get(reqUrl, { headers: reqHeaders }).subscribe({ next: resolve, error: reject }));
+            if (revokeToken?.status) {
+                this.localizeTokenService.accessToken = revokeToken.message;
+            }
+            else if (!this.localizeTokenService.refreshToken) {
+                await this.ifPromise(this.apiConfigs.onAutoLogout);
+            }
+            else {
+                if (this.apiConfigs.onRevokeUnauthorized) {
+                    await this.ifPromise(this.apiConfigs.onRevokeUnauthorized);
+                    await this.revokeToken(true);
+                }
+            }
+        }
+        finally {
+            this.localizeTokenService.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}`;
+        }
+        if (!isFormData) {
+            defaultHeaders[LocalizeToken.httpHeaders.CONTENT_TYPE] = 'application/json';
+        }
+        const filteredHeaders = Object.keys(defaultHeaders).filter(key => !Object.keys(headers).includes(key))
+            .reduce((acc, key) => ({ ...acc, [key]: defaultHeaders[key] }), {});
+        const mergedHeaders = { ...filteredHeaders, ...headers };
+        return new HttpHeaders(mergedHeaders);
+    }
+    async ifPromise(fn) {
+        if (!fn)
+            return;
+        return fn instanceof Promise ? await fn() : fn();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeApiService, deps: [{ token: i1.HttpClient }, { token: i2.LocalizeTokenService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeApiService, providedIn: 'root' });
+} //class
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.LocalizeTokenService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localize.api.service.js","sourceRoot":"","sources":["../../../src/localize-token/localize.api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { LocalizeTokenService } from \"./localize.token.service\";\r\nimport { HttpClient, HttpHeaders } from \"@angular/common/http\";\r\nimport { LocalizeToken, waitFor, waitUntil } from \"./localize.token\";\r\nimport { BehaviorSubject } from \"rxjs\";\r\n\r\n/**\r\n * Http method options\r\n */\r\nexport enum EMethod {\r\n  POST = 1,\r\n  GET = 2,\r\n  PUT = 3,\r\n  DELETE = 4,\r\n  PATCH = 5\r\n}\r\n\r\ninterface ILocalizeApiConfigs {\r\n  onPrepareRequest?: () => any;\r\n  /**\r\n   *  A function that is called when refresh token is missing then perform the auto logout.\r\n   * @returns - The base URL of the API.\r\n   */\r\n  onAutoLogout?: () => any;\r\n  /**\r\n   * A function that is called when request revoking token unauthorized.\r\n   * @returns - The login dialog service.\r\n   */\r\n  onRevokeUnauthorized?: () => any;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class LocalizeApiService {\r\n\r\n  readonly isRequestingSubject = new BehaviorSubject<boolean>(false);\r\n  readonly isResolvedStartupSubject = new BehaviorSubject<boolean>(false);\r\n  get isRequesting() { return this.isRequestingSubject.value; }\r\n  get isResolvedStartup() { return this.isResolvedStartupSubject.value; }\r\n\r\n  private apiConfigs: ILocalizeApiConfigs = {};\r\n\r\n  constructor(readonly httpClient: HttpClient,\r\n    private readonly localizeTokenService: LocalizeTokenService\r\n  ) { }\r\n\r\n  /**\r\n   * Initialize the API service.\r\n   * @param apiConfigs - The API configurations.\r\n   */\r\n  init(apiConfigs: ILocalizeApiConfigs) {\r\n    this.apiConfigs = apiConfigs;\r\n  }\r\n\r\n\r\n  /**\r\n   * A higher-order function that returns a curried function for making API requests.\r\n   *\r\n   * @param baseUrl - The base URL of the API.\r\n   * @returns A curried function that can be used to make API requests.\r\n   */\r\n  func = (baseUrl: string) =>\r\n    (path: string, method: EMethod = EMethod.GET, value: any = null, isFormData: boolean = false, headers?: { [x: string]: string }) =>\r\n      this.base(baseUrl, path, method, value, isFormData, headers)\r\n\r\n  private async base(baseUrl: string,\r\n    path: string,\r\n    method: EMethod = EMethod.GET,\r\n    value: any = null,\r\n    isFormData: boolean = false,\r\n    headers?: { [x: string]: string }) {\r\n\r\n    await this.ifPromise(this.apiConfigs.onPrepareRequest);\r\n\r\n    const url = `${baseUrl.trim().replace(/\\/?$/, '/')}${path.trim().replace(/^\\//, '')}`;\r\n    const httpMethod = EMethod[method].toLowerCase();\r\n    const request = () => { return { body: value, headers: this.options(isFormData, headers) } };\r\n\r\n    // Wait for previous request to complete\r\n    await this.toWaitForPreviousRequest();\r\n\r\n    // Process request\r\n    try { return await this.processRequest(httpMethod, url, request()) }\r\n    // Handle unauthorized error if any\r\n    catch (error) {\r\n      if ((error as any).status !== 401) { throw error; }\r\n      return await this.onUnauthorizedError(httpMethod, url, request);\r\n    }\r\n  }\r\n\r\n  private async onUnauthorizedError(httpMethod: string, url: string, request: Function) {\r\n    await this.revokeToken();\r\n    if (!this.isResolvedStartup) {\r\n      return await this.processRequest(httpMethod, url, request());\r\n    }\r\n  }\r\n\r\n  private async toWaitForPreviousRequest() {\r\n    if (this.localizeTokenService.isRevokingToken) {\r\n      await waitUntil(() => !this.localizeTokenService.isRevokingToken);\r\n    }\r\n    // to wait for each request in 50ms, even if the request is not completed\r\n    await waitFor(50, this.isRequesting);\r\n  }\r\n\r\n  private async processRequest(method: string, url: string, options: any): Promise<any> {\r\n    this.isRequestingSubject.next(true);\r\n    const result = await new Promise((resolve, reject) =>\r\n      this.httpClient.request<any>(method, url, options).subscribe({ next: resolve, error: reject }))\r\n    this.isRequestingSubject.next(false);\r\n    return result;\r\n  }\r\n\r\n  private async revokeToken(force: boolean = false): Promise<void> {\r\n\r\n    if (this.localizeTokenService.isRevokingToken && !force) {\r\n      await waitUntil(() => !this.localizeTokenService.isRevokingToken)\r\n      return;\r\n    }\r\n\r\n    try {\r\n      this.localizeTokenService.isRevokingToken = true;\r\n      const reqUrl = LocalizeToken.config.revokeTokenUrl;\r\n      const reqHeaders = this.options().append(LocalizeToken.httpHeaders.X_REFRESH_TOKEN, `${this.localizeTokenService.refreshToken}`);\r\n      const revokeToken: any = await new Promise((resolve, reject) =>\r\n        this.httpClient.get<any>(reqUrl!, { headers: reqHeaders }).subscribe({ next: resolve, error: reject }))\r\n\r\n      if (revokeToken?.status) {\r\n        this.localizeTokenService.accessToken = revokeToken.message;\r\n      } else if (!this.localizeTokenService.refreshToken) {\r\n        await this.ifPromise(this.apiConfigs.onAutoLogout)\r\n      } else {\r\n        if (this.apiConfigs.onRevokeUnauthorized) {\r\n          await this.ifPromise(this.apiConfigs.onRevokeUnauthorized);\r\n          await this.revokeToken(true);\r\n        }\r\n      }\r\n    } finally {\r\n      this.localizeTokenService.isRevokingToken = false;\r\n    }\r\n  }\r\n\r\n  /** default http request options */\r\n  private options(isFormData: boolean = false, headers: { [key: string]: string } = {}): HttpHeaders {\r\n    const defaultHeaders = { [LocalizeToken.httpHeaders.AUTHORIZATION]: `Bearer ${this.localizeTokenService.accessToken}`, };\r\n    if (LocalizeToken.config.needTenant) {\r\n      defaultHeaders[LocalizeToken.httpHeaders.X_TENANT] = `${this.localizeTokenService.tenantToken}`;\r\n    }\r\n\r\n    if (!isFormData) {\r\n      defaultHeaders[LocalizeToken.httpHeaders.CONTENT_TYPE] = 'application/json';\r\n    }\r\n\r\n    const filteredHeaders = Object.keys(defaultHeaders).filter(key => !Object.keys(headers).includes(key))\r\n      .reduce((acc, key) => ({ ...acc, [key]: defaultHeaders[key] }), {})\r\n    const mergedHeaders = { ...filteredHeaders, ...headers };\r\n    return new HttpHeaders(mergedHeaders);\r\n  }\r\n\r\n  private async ifPromise(fn?: Function) {\r\n    if (!fn) return;\r\n    return fn instanceof Promise ? await fn() : fn();\r\n  }\r\n\r\n}//class\r\n"]}

package/esm2022/localize-token/localize.token.mjs

@@ -0,0 +1,54 @@
+import { LocalizeTokenStorageHelper } from "./localize.token.storage";
+export class LocalizeToken {
+    static config = {
+        mainDomain: location.hostname,
+        authTokenName: 'auth-token',
+        tenantTokenName: 'tenant-token',
+        refreshTokenName: 'refresh-token',
+        needTenant: false,
+        isProduction: false,
+    };
+    static cookieOptions = {
+        path: '/',
+        domain: LocalizeToken.config.mainDomain,
+        secure: true,
+        // samesite: SameSiteType.strict,
+        expires: 1
+    };
+    static storage = new LocalizeTokenStorageHelper();
+    static httpHeaders = {
+        AUTHORIZATION: 'Authorization',
+        X_TENANT: 'X-Tenant',
+        X_REFRESH_TOKEN: 'X-RefreshToken',
+        CONTENT_TYPE: 'Content-Type',
+    };
+}
+/**
+ *  Waits for a specified amount of time.
+ * @param milliseconds  - The milliseconds to wait.
+ * @param when  - The condition to wait for. Default is true.
+ * @returns  - Promise<void>
+ */
+export async function waitFor(milliseconds, when = true) {
+    if (!when)
+        return;
+    await new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+/**
+ *  Waits until the condition is met.
+ * @param when  - The condition to wait for.
+ * @param intervalNumber  - The interval number in milliseconds to check the condition. Default is 50.
+ */
+export async function waitUntil(when, intervalNumber = 50) {
+    await new Promise(resolve => {
+        const interval = setInterval(async () => {
+            const cond = when();
+            const result = cond instanceof Promise ? await cond : cond;
+            if (result) {
+                clearInterval(interval);
+                resolve(true);
+            }
+        }, intervalNumber);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/{lib → localize-token}/localize.token.module.mjs

@@ -19,4 +19,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImpo
                     ],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemUudG9rZW4ubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9sb2NhbGl6ZS50b2tlbi5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFRNUQsTUFBTSxPQUFPLG1CQUFtQjt3R0FBbkIsbUJBQW1CO3lHQUFuQixtQkFBbUI7eUdBQW5CLG1CQUFtQixhQUxqQjtZQUNQLG9CQUFvQjtZQUNwQixrQkFBa0I7U0FDckI7OzRGQUVRLG1CQUFtQjtrQkFOL0IsUUFBUTttQkFBQztvQkFDTixTQUFTLEVBQUU7d0JBQ1Asb0JBQW9CO3dCQUNwQixrQkFBa0I7cUJBQ3JCO2lCQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTG9jYWxpemVUb2tlblNlcnZpY2UgfSBmcm9tICcuL2xvY2FsaXplLnRva2VuLnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBMb2NhbGl6ZUFwaVNlcnZpY2UgfSBmcm9tICcuL2xvY2FsaXplLmFwaS5zZXJ2aWNlJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgICBwcm92aWRlcnM6IFtcclxuICAgICAgICBMb2NhbGl6ZVRva2VuU2VydmljZSxcclxuICAgICAgICBMb2NhbGl6ZUFwaVNlcnZpY2VcclxuICAgIF0sXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBMb2NhbGl6ZVRva2VuTW9kdWxlIHsgfSJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemUudG9rZW4ubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xvY2FsaXplLXRva2VuL2xvY2FsaXplLnRva2VuLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQVE1RCxNQUFNLE9BQU8sbUJBQW1CO3dHQUFuQixtQkFBbUI7eUdBQW5CLG1CQUFtQjt5R0FBbkIsbUJBQW1CLGFBTGpCO1lBQ1Asb0JBQW9CO1lBQ3BCLGtCQUFrQjtTQUNyQjs7NEZBRVEsbUJBQW1CO2tCQU4vQixRQUFRO21CQUFDO29CQUNOLFNBQVMsRUFBRTt3QkFDUCxvQkFBb0I7d0JBQ3BCLGtCQUFrQjtxQkFDckI7aUJBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBMb2NhbGl6ZVRva2VuU2VydmljZSB9IGZyb20gJy4vbG9jYWxpemUudG9rZW4uc2VydmljZSc7XHJcbmltcG9ydCB7IExvY2FsaXplQXBpU2VydmljZSB9IGZyb20gJy4vbG9jYWxpemUuYXBpLnNlcnZpY2UnO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICAgIHByb3ZpZGVyczogW1xyXG4gICAgICAgIExvY2FsaXplVG9rZW5TZXJ2aWNlLFxyXG4gICAgICAgIExvY2FsaXplQXBpU2VydmljZVxyXG4gICAgXSxcclxufSlcclxuZXhwb3J0IGNsYXNzIExvY2FsaXplVG9rZW5Nb2R1bGUgeyB9Il19