@sambath999/localize-token 12.2.8 → 18.0.0

package/esm2022/lib/index.mjs

@@ -0,0 +1,6 @@
+export * from './localize.token.service';
+export * from './localize.token';
+export * from './localize.token.storage';
+export * from './localize.token.module';
+export * from './localize.api.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbG9jYWxpemUudG9rZW4uc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbG9jYWxpemUudG9rZW4nO1xyXG5leHBvcnQgKiBmcm9tICcuL2xvY2FsaXplLnRva2VuLnN0b3JhZ2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xvY2FsaXplLnRva2VuLm1vZHVsZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbG9jYWxpemUuYXBpLnNlcnZpY2UnO1xyXG4iXX0=

package/esm2022/lib/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/lib/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/lib/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.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { LocalizeTokenService } from './localize.token.service';
+import { LocalizeApiService } from './localize.api.service';
+import * as i0 from "@angular/core";
+export class LocalizeTokenModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeTokenModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.12", ngImport: i0, type: LocalizeTokenModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeTokenModule, providers: [
+            LocalizeTokenService,
+            LocalizeApiService
+        ] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeTokenModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        LocalizeTokenService,
+                        LocalizeApiService
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemUudG9rZW4ubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9sb2NhbGl6ZS50b2tlbi5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFRNUQsTUFBTSxPQUFPLG1CQUFtQjt3R0FBbkIsbUJBQW1CO3lHQUFuQixtQkFBbUI7eUdBQW5CLG1CQUFtQixhQUxqQjtZQUNQLG9CQUFvQjtZQUNwQixrQkFBa0I7U0FDckI7OzRGQUVRLG1CQUFtQjtrQkFOL0IsUUFBUTttQkFBQztvQkFDTixTQUFTLEVBQUU7d0JBQ1Asb0JBQW9CO3dCQUNwQixrQkFBa0I7cUJBQ3JCO2lCQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTG9jYWxpemVUb2tlblNlcnZpY2UgfSBmcm9tICcuL2xvY2FsaXplLnRva2VuLnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBMb2NhbGl6ZUFwaVNlcnZpY2UgfSBmcm9tICcuL2xvY2FsaXplLmFwaS5zZXJ2aWNlJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgICBwcm92aWRlcnM6IFtcclxuICAgICAgICBMb2NhbGl6ZVRva2VuU2VydmljZSxcclxuICAgICAgICBMb2NhbGl6ZUFwaVNlcnZpY2VcclxuICAgIF0sXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBMb2NhbGl6ZVRva2VuTW9kdWxlIHsgfSJdfQ==

package/esm2022/lib/localize.token.service.mjs

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import { LocalizeToken } from './localize.token';
+import { BehaviorSubject } from 'rxjs';
+import * as jwt_decode from 'jwt-decode';
+import * as i0 from "@angular/core";
+export class LocalizeTokenService {
+    isRevokingTokenSubject = new BehaviorSubject(false);
+    get authToken() { return this.storageGet(); }
+    set authToken(value) {
+        value
+            ? this.storageSet(value)
+            : LocalizeToken.storage.delete(LocalizeToken.config.authTokenName);
+    }
+    get refreshToken() { return LocalizeToken.storage.get(LocalizeToken.config.refreshTokenName); }
+    get accessToken() { return this.authToken?.token; }
+    set accessToken(value) {
+        if (value) {
+            this.authToken = { token: value, revoke: false };
+        }
+    }
+    get isRevokingToken() { return this.isRevokingTokenSubject.value; /* this.authToken?.revoke ?? false */ }
+    set isRevokingToken(value) {
+        this.isRevokingTokenSubject.next(value);
+        if (this.authToken) {
+            this.authToken = { ...this.authToken, revoke: value };
+        }
+    }
+    get tenantToken() { return LocalizeToken.storage.get(LocalizeToken.config.tenantTokenName); }
+    constructor() { }
+    storageGet() {
+        try {
+            const encoded = LocalizeToken.storage.get(LocalizeToken.config.authTokenName);
+            const decoded = atob(encoded || '');
+            return JSON.parse(decoded);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    storageSet(value) {
+        const base64 = btoa(JSON.stringify(value));
+        LocalizeToken.storage.set(LocalizeToken.config.authTokenName, base64);
+    }
+    tokensValid() {
+        return this.refreshToken?.length && (!LocalizeToken.config.needTenant || this.tenantToken?.length);
+    }
+    decodeToken = (token) => jwt_decode.jwtDecode(token);
+    get decodeRefreshToken() {
+        const token = LocalizeToken.storage.get(LocalizeToken.config.refreshTokenName);
+        if (!token)
+            return null;
+        return this.decodeToken(token);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeTokenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeTokenService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: LocalizeTokenService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/localize.token.storage.mjs

@@ -0,0 +1,101 @@
+import { LocalizeToken } from "./localize.token";
+/**
+* Assembly of @package ng2-cookies @see https://www.npmjs.com/package/ng2-cookies
+*
+* Reassembled by
+* @author sambath999
+* @date_29_09_2021
+* Updated from raw parameters to
+* @param {ICookieOptions} options and added another newer cookie flag
+* @param {string} samesite
+* @param {constant} SameSiteTypes, @param {string} strict "strict", @param {string} lax "lax", @param {string} none "none"
+*
+* @enum
+*/
+export class LocalizeTokenStorageHelper {
+    /**
+     * Checks the existence of a single cookie by it's name
+     *
+     * @param  {string} name Identification of the cookie
+     * @returns existence of the cookie
+     */
+    check(name) {
+        if (typeof document === "undefined")
+            return false;
+        name = encodeURIComponent(name);
+        const regexp = new RegExp('(?:^' + name + '|;\\s*' + name + ')=(.*?)(?:;|$)', 'g');
+        return regexp.test(document.cookie);
+    }
+    /**
+     * Retrieves a single cookie by it's name
+     *
+     * @param  {string} name Identification of the Cookie
+     * @returns The Cookie's value
+     */
+    get(name) {
+        if (!this.check(name))
+            return undefined;
+        name = encodeURIComponent(name);
+        const regexp = new RegExp('(?:^' + name + '|;\\s*' + name + ')=(.*?)(?:;|$)', 'g');
+        const result = regexp.exec(document.cookie);
+        return result ? decodeURIComponent(result[1]) : undefined;
+    }
+    /**
+     * Retrieves a a list of all cookie avaiable
+     *
+     * @returns Object with all Cookies
+     */
+    getAll() {
+        const cookies = {};
+        if (document.cookie) {
+            const split = document.cookie.split(';');
+            for (const s of split) {
+                const currCookie = s.split('=');
+                currCookie[0] = currCookie[0].trim();
+                cookies[decodeURIComponent(currCookie[0])] = decodeURIComponent(currCookie[1]);
+            }
+        }
+        return cookies;
+    }
+    get defaultOptions() { return LocalizeToken.cookieOptions; }
+    set(name, value, options) {
+        options ??= this.defaultOptions;
+        const { expires, path, domain, secure, samesite } = options;
+        let cookieStr = `${encodeURIComponent(name)}=${encodeURIComponent(value)};`;
+        if (expires) {
+            const dtExpires = typeof expires === 'number' ? new Date(Date.now() + expires * 864e5) : expires;
+            cookieStr += `expires=${dtExpires.toUTCString()};`;
+        }
+        cookieStr += path ? `path=${path};` : '';
+        cookieStr += domain ? `domain=${domain};` : '';
+        cookieStr += secure ? 'secure;' : '';
+        cookieStr += samesite ? `samesite=${samesite};` : '';
+        document.cookie = cookieStr;
+    }
+    /**
+     * Removes specified Cookie
+     *
+     * @param  {string} name Cookie's identification
+     * @param  {string} path Path relative to the domain where the cookie should be avaiable. Default /
+     * @param  {string} domain Domain where the cookie should be avaiable. Default current domain
+     */
+    delete(name, path = '/', domain = window.location.hostname) {
+        this.set(name, '', { path, domain, expires: -1 });
+    }
+    /**
+     * Delete all cookie avaiable
+     */
+    deleteAll(path, domain) {
+        const cookies = this.getAll();
+        for (const cookieName of Object.keys(cookies)) {
+            this.delete(cookieName, path, domain);
+        }
+    }
+}
+export var ISameSiteType;
+(function (ISameSiteType) {
+    ISameSiteType["strict"] = "strict";
+    ISameSiteType["lax"] = "lax";
+    ISameSiteType["none"] = "none";
+})(ISameSiteType || (ISameSiteType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localize.token.storage.js","sourceRoot":"","sources":["../../../src/lib/localize.token.storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD;;;;;;;;;;;;EAYE;AACF,MAAM,OAAO,0BAA0B;IAErC;;;;;OAKG;IACH,KAAK,CAAC,IAAY;QAChB,IAAI,OAAO,QAAQ,KAAK,WAAW;YAAE,OAAO,KAAK,CAAC;QAClD,IAAI,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,GAAG,IAAI,GAAG,QAAQ,GAAG,IAAI,GAAG,gBAAgB,EAAE,GAAG,CAAC,CAAC;QACnF,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAC,IAAY;QACd,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YAAE,OAAO,SAAS,CAAC;QAExC,IAAI,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,GAAG,IAAI,GAAG,QAAQ,GAAG,IAAI,GAAG,gBAAgB,EAAE,GAAG,CAAC,CAAC;QACnF,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC5C,OAAO,MAAM,CAAC,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5D,CAAC;IAED;;;;OAIG;IACH,MAAM;QACJ,MAAM,OAAO,GAAQ,EAAE,CAAC;QAExB,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;YACpB,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACzC,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;gBACtB,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAChC,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;gBACrC,OAAO,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YACjF,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,IAAI,cAAc,KAAqB,OAAO,aAAa,CAAC,aAAa,CAAA,CAAC,CAAC;IAG3E,GAAG,CAAC,IAAY,EAAE,KAAa,EAAE,OAAwB;QACvD,OAAO,KAAK,IAAI,CAAC,cAAc,CAAC;QAChC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;QAC5D,IAAI,SAAS,GAAG,GAAG,kBAAkB,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,KAAK,CAAC,GAAG,CAAC;QAE5E,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,SAAS,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;YACjG,SAAS,IAAI,WAAW,SAAS,CAAC,WAAW,EAAE,GAAG,CAAC;QACrD,CAAC;QAED,SAAS,IAAI,IAAI,CAAC,CAAC,CAAC,QAAQ,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QACzC,SAAS,IAAI,MAAM,CAAC,CAAC,CAAC,UAAU,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/C,SAAS,IAAI,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;QACrC,SAAS,IAAI,QAAQ,CAAC,CAAC,CAAC,YAAY,QAAQ,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAErD,QAAQ,CAAC,MAAM,GAAG,SAAS,CAAC;IAC9B,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,IAAY,EAAE,OAAe,GAAG,EAAE,SAAiB,MAAM,CAAC,QAAQ,CAAC,QAAQ;QAChF,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,IAAa,EAAE,MAAe;QACtC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAE9B,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9C,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;CAEF;AAED,MAAM,CAAN,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,kCAAiB,CAAA;IACjB,4BAAW,CAAA;IACX,8BAAa,CAAA;AACf,CAAC,EAJW,aAAa,KAAb,aAAa,QAIxB","sourcesContent":["import { LocalizeToken } from \"./localize.token\";\r\n\r\n\r\n/**\r\n* Assembly of @package ng2-cookies @see https://www.npmjs.com/package/ng2-cookies\r\n*\r\n* Reassembled by\r\n* @author sambath999\r\n* @date_29_09_2021\r\n* Updated from raw parameters to\r\n* @param {ICookieOptions} options and added another newer cookie flag\r\n* @param {string} samesite\r\n* @param {constant} SameSiteTypes, @param {string} strict \"strict\", @param {string} lax \"lax\", @param {string} none \"none\"\r\n*\r\n* @enum\r\n*/\r\nexport class LocalizeTokenStorageHelper {\r\n\r\n  /**\r\n   * Checks the existence of a single cookie by it's name\r\n   *\r\n   * @param  {string} name Identification of the cookie\r\n   * @returns existence of the cookie\r\n   */\r\n  check(name: string): boolean {\r\n    if (typeof document === \"undefined\") return false;\r\n    name = encodeURIComponent(name);\r\n    const regexp = new RegExp('(?:^' + name + '|;\\\\s*' + name + ')=(.*?)(?:;|$)', 'g');\r\n    return regexp.test(document.cookie);\r\n  }\r\n\r\n  /**\r\n   * Retrieves a single cookie by it's name\r\n   *\r\n   * @param  {string} name Identification of the Cookie\r\n   * @returns The Cookie's value\r\n   */\r\n  get(name: string): string | undefined {\r\n    if (!this.check(name)) return undefined;\r\n\r\n    name = encodeURIComponent(name);\r\n    const regexp = new RegExp('(?:^' + name + '|;\\\\s*' + name + ')=(.*?)(?:;|$)', 'g');\r\n    const result = regexp.exec(document.cookie);\r\n    return result ? decodeURIComponent(result[1]) : undefined;\r\n  }\r\n\r\n  /**\r\n   * Retrieves a a list of all cookie avaiable\r\n   *\r\n   * @returns Object with all Cookies\r\n   */\r\n  getAll(): any {\r\n    const cookies: any = {};\r\n\r\n    if (document.cookie) {\r\n      const split = document.cookie.split(';');\r\n      for (const s of split) {\r\n        const currCookie = s.split('=');\r\n        currCookie[0] = currCookie[0].trim();\r\n        cookies[decodeURIComponent(currCookie[0])] = decodeURIComponent(currCookie[1]);\r\n      }\r\n    }\r\n\r\n    return cookies;\r\n  }\r\n\r\n  get defaultOptions(): ICookieOptions { return LocalizeToken.cookieOptions }\r\n\r\n\r\n  set(name: string, value: string, options?: ICookieOptions) {\r\n    options ??= this.defaultOptions;\r\n    const { expires, path, domain, secure, samesite } = options;\r\n    let cookieStr = `${encodeURIComponent(name)}=${encodeURIComponent(value)};`;\r\n\r\n    if (expires) {\r\n      const dtExpires = typeof expires === 'number' ? new Date(Date.now() + expires * 864e5) : expires;\r\n      cookieStr += `expires=${dtExpires.toUTCString()};`;\r\n    }\r\n\r\n    cookieStr += path ? `path=${path};` : '';\r\n    cookieStr += domain ? `domain=${domain};` : '';\r\n    cookieStr += secure ? 'secure;' : '';\r\n    cookieStr += samesite ? `samesite=${samesite};` : '';\r\n\r\n    document.cookie = cookieStr;\r\n  }\r\n\r\n  /**\r\n   * Removes specified Cookie\r\n   *\r\n   * @param  {string} name Cookie's identification\r\n   * @param  {string} path Path relative to the domain where the cookie should be avaiable. Default /\r\n   * @param  {string} domain Domain where the cookie should be avaiable. Default current domain\r\n   */\r\n  delete(name: string, path: string = '/', domain: string = window.location.hostname): void {\r\n    this.set(name, '', { path, domain, expires: -1 });\r\n  }\r\n\r\n  /**\r\n   * Delete all cookie avaiable\r\n   */\r\n  deleteAll(path?: string, domain?: string): void {\r\n    const cookies = this.getAll();\r\n\r\n    for (const cookieName of Object.keys(cookies)) {\r\n      this.delete(cookieName, path, domain);\r\n    }\r\n  }\r\n\r\n}\r\n\r\nexport enum ISameSiteType {\r\n  strict = \"strict\",\r\n  lax = \"lax\",\r\n  none = \"none\"\r\n}\r\n\r\nexport interface ICookieOptions {\r\n  expires?: number | Date;\r\n  path?: string;\r\n  domain?: string;\r\n  secure?: boolean;\r\n  samesite?: string\r\n}\r\n"]}

package/esm2022/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './lib';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWInOyJdfQ==

package/{esm2015/sambath999-localize-token.js → esm2022/sambath999-localize-token.mjs}

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public-api';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FtYmF0aDk5OS1sb2NhbGl6ZS10b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zYW1iYXRoOTk5LWxvY2FsaXplLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=