codefoxcore 0.0.1 → 0.0.3

package/fesm2022/codefoxcore.mjs

@@ -1,9 +1,9 @@
 import { Subject, filter, Observable, takeUntil, timer } from 'rxjs';
-import { isPlatformBrowser } from '@angular/common';
+import { isPlatformBrowser, DOCUMENT } from '@angular/common';
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injector, PLATFORM_ID, ApplicationRef, createComponent, Injectable } from '@angular/core';
+import { InjectionToken, inject, Injector, PLATFORM_ID, ApplicationRef, createComponent, Injectable, makeEnvironmentProviders } from '@angular/core';
 import { Title } from '@angular/platform-browser';
-import { HttpClient } from '@angular/common/http';
+import { HttpClient, HTTP_INTERCEPTORS } from '@angular/common/http';
 
 class DialogRef {
     constructor() {
@@ -170,6 +170,28 @@ var LogLevel;
     LogLevel[LogLevel["Fatal"] = 5] = "Fatal";
     LogLevel[LogLevel["Off"] = 6] = "Off";
 })(LogLevel || (LogLevel = {}));
+var TokenServiceMode;
+(function (TokenServiceMode) {
+    TokenServiceMode[TokenServiceMode["LOCALSTORAGE"] = 0] = "LOCALSTORAGE";
+    TokenServiceMode[TokenServiceMode["SESSIONSTORAGE"] = 1] = "SESSIONSTORAGE";
+    TokenServiceMode[TokenServiceMode["COOKIE"] = 2] = "COOKIE";
+})(TokenServiceMode || (TokenServiceMode = {}));
+var InterceptorType;
+(function (InterceptorType) {
+    InterceptorType["ALL"] = "ALL";
+    InterceptorType["ERROR"] = "ERROR";
+    InterceptorType["LOADER"] = "LOADER";
+    InterceptorType["MOCK"] = "MOCK";
+    InterceptorType["TOKEN"] = "TOKEN";
+    InterceptorType["PRECHECK"] = "PRECHECK";
+    InterceptorType["LOCK"] = "LOCK";
+    InterceptorType["REQUESTID"] = "REQUESTID";
+})(InterceptorType || (InterceptorType = {}));
+var Precheck;
+(function (Precheck) {
+    Precheck["ERROR"] = "ERROR";
+    Precheck["WARNING"] = "WARNING";
+})(Precheck || (Precheck = {}));
 
 const MESSAGE_DEFAULT_CONFIGURATION = new InjectionToken('Message default configuration', {
     factory: () => {
@@ -812,9 +834,374 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 }]
         }] });
 
+function isBrowser() {
+    const platformId = inject(PLATFORM_ID);
+    return isPlatformBrowser(platformId);
+}
+function localStorage() {
+    const document = inject(DOCUMENT);
+    if (document.defaultView !== null) {
+        return document.defaultView.window.localStorage;
+    }
+    return null;
+}
+function sessionStorage() {
+    const document = inject(DOCUMENT);
+    if (document.defaultView !== null) {
+        return document.defaultView.window.sessionStorage;
+    }
+    return null;
+}
+
+class CookieService {
+    constructor() {
+        this.browser = isBrowser();
+        this.document = inject(DOCUMENT);
+        this.loggerService = inject(LoggerService);
+    }
+    /**
+     * Get the value of a cookie by name, returns `null` if the cookie is not set
+     *
+     * @param name name of the cookie
+     * @returns value of the cookie
+     */
+    get(name) {
+        if (!this.browser) {
+            return null;
+        }
+        const cookies = this.cookies;
+        return cookies[name] || null;
+    }
+    /**
+     * Set the value of a cookie with the given name
+     *
+     * @param name name of the cookie
+     * @param value value of the cookie
+     * @param expire expire of the cookie in seconds, if null, it will never expire
+     * @param path path of the cookie, default is '/'
+     * @param config optional configuration values (expire in seconds, path of cookie)
+     */
+    set(name, value, expire = null, path = '/') {
+        if (!this.browser) {
+            return;
+        }
+        if (path === null) {
+            path = '/';
+        }
+        // Default cookie informations
+        let cookie = `${name}=${value};`;
+        // If we have an expire date, we need to set
+        if (expire !== null) {
+            let d = new Date();
+            d.setTime(d.getTime() + (expire * 1000));
+            cookie += `expires=${d.toUTCString()};`;
+        }
+        // Set path
+        cookie += `path=${path};`;
+        // Log
+        this.loggerService.info('Cookie data to set: ' + cookie);
+        // Set the cookie
+        this.document.cookie = cookie;
+    }
+    /**
+     * Delete a cookie by its name
+     *
+     * @param name name of the cookie
+     */
+    delete(name) {
+        if (!this.browser) {
+            return;
+        }
+        this.set(name, '', -1);
+    }
+    get cookies() {
+        if (!this.browser) {
+            return {};
+        }
+        const cookies = this.document.cookie;
+        if (cookies.length === 0) {
+            return {};
+        }
+        const cookiesArray = cookies.split(';');
+        const cookiesObject = {};
+        cookiesArray.forEach((cookiesArrayItem) => {
+            const cookiesArrayItemSplit = cookiesArrayItem.split('=');
+            cookiesObject[cookiesArrayItemSplit[0].trim()] = cookiesArrayItemSplit[1];
+        });
+        return cookiesObject;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CookieService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CookieService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CookieService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class TokenService {
+    constructor() {
+        this.cookieService = inject(CookieService);
+        this.loggerService = inject(LoggerService);
+        this.localStorage = localStorage();
+        this.sessionStorage = sessionStorage();
+        this.isBrowser = isBrowser();
+        this.cookiePath = null;
+        this.accessToken = null;
+        this.accessTokenKey = 'acccessToken';
+        this.accessTokenCookieExpireDays = 30;
+    }
+    write(mode) {
+        if (this.accessToken === null) {
+            this.loggerService.error('No accessToken set to write!');
+            return;
+        }
+        if (mode === null) {
+            this.loggerService.error('Invalid mode for token write!');
+        }
+        switch (mode) {
+            case TokenServiceMode.LOCALSTORAGE:
+                if (this.isBrowser && this.localStorage !== null) {
+                    this.localStorage.setItem(this.accessTokenKey, this.accessToken);
+                    this.loggerService.debug('Token set to local storage: ' + this.accessToken);
+                }
+                else {
+                    this.loggerService.error('Trying to set localStorage on not a browser platform!');
+                }
+                break;
+            case TokenServiceMode.SESSIONSTORAGE:
+                if (this.isBrowser && this.sessionStorage !== null) {
+                    this.sessionStorage.setItem(this.accessTokenKey, this.accessToken);
+                    this.loggerService.debug('Token set to session storage: ' + this.accessToken);
+                }
+                else {
+                    this.loggerService.error('Trying to set sessionStorage on not a browser platform!');
+                }
+                break;
+            case TokenServiceMode.COOKIE:
+                this.cookieService.set(this.accessTokenKey, this.accessToken, this.accessTokenCookieExpireDays * 24 * 60 * 60, this.cookiePath);
+                this.loggerService.debug('Token set to cookie: ' + this.accessToken);
+                break;
+        }
+    }
+    read(mode) {
+        if (mode === null) {
+            this.loggerService.error('Invalid mode for token read!');
+            return null;
+        }
+        switch (mode) {
+            case TokenServiceMode.LOCALSTORAGE:
+                this.loggerService.debug('Trying to read token from local storage');
+                if (this.isBrowser && this.localStorage !== null) {
+                    const tokenLocalStorage = this.localStorage.getItem(this.accessTokenKey);
+                    if (tokenLocalStorage !== null) {
+                        this.loggerService.debug('Token read from local storage: ' + tokenLocalStorage);
+                    }
+                    return tokenLocalStorage;
+                }
+                else {
+                    this.loggerService.error('Trying to read from localStorage on not a browser platform!');
+                    return null;
+                }
+            case TokenServiceMode.SESSIONSTORAGE:
+                if (this.isBrowser && this.sessionStorage !== null) {
+                    this.loggerService.debug('Trying to read token from session storage');
+                    const tokenSessionStorage = this.sessionStorage.getItem(this.accessTokenKey);
+                    if (tokenSessionStorage !== null) {
+                        this.loggerService.debug('Token read from session storage: ' + tokenSessionStorage);
+                    }
+                    return tokenSessionStorage;
+                }
+                else {
+                    this.loggerService.error('Trying to read from sessionStorage on not a browser platform!');
+                    return null;
+                }
+            case TokenServiceMode.COOKIE: {
+                this.loggerService.debug('Trying to read token from session cookie');
+                const cookieAccessToken = this.cookieService.get(this.accessTokenKey);
+                if (cookieAccessToken !== null) {
+                    this.loggerService.debug('Token read from cookie: ' + cookieAccessToken);
+                }
+                return cookieAccessToken;
+            }
+        }
+    }
+    delete(mode) {
+        if (mode === null) {
+            this.loggerService.error('Invalid mode for token delete!');
+        }
+        switch (mode) {
+            case TokenServiceMode.LOCALSTORAGE:
+                if (this.localStorage !== null) {
+                    this.loggerService.debug('Token deleted from local storage');
+                    this.localStorage.removeItem(this.accessTokenKey);
+                }
+                break;
+            case TokenServiceMode.SESSIONSTORAGE:
+                if (this.sessionStorage !== null) {
+                    this.loggerService.debug('Token deleted from session storage');
+                    this.sessionStorage.removeItem(this.accessTokenKey);
+                }
+                break;
+            case TokenServiceMode.COOKIE: {
+                this.loggerService.debug('Token deleted from cookie');
+                this.cookieService.delete(this.accessTokenKey);
+                break;
+            }
+        }
+        this.accessToken = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TokenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TokenService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TokenService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class InterceptorsService {
+    constructor() {
+        /**
+         * Skip
+         *
+         * Skip interceptors from next http requests
+         */
+        this.skip = [];
+        /**
+         * ResetSkip
+         *
+         * Resets to `skip` to empty array after first http request
+         */
+        this.resetSkip = true;
+        /**
+         * Precheck
+         *
+         * Tells the `PrecheckInterceptor` to set a header with the given value
+         */
+        this.precheck = null;
+        /**
+         * ResetPrecheck
+         *
+         * Clear `precheck` after first http request
+         */
+        this.resetPrecheck = true;
+        /**
+         * Error callback function
+         *
+         * Function to call after every http error
+         */
+        this.errorCallbackfunction = null;
+        /**
+         * Error skip status codes
+         *
+         * Skips the given status codes from `errorCallbackfunction`
+         */
+        this.errorSkipStatusCodes = [];
+        /**
+         * Mock callback function
+         *
+         * Function to call to mock an http request
+         */
+        this.mockCallbackFunction = null;
+        /**
+         * RequestId HTTP Header name
+         */
+        this.requestIdHttpHeaderName = 'Request-Id';
+        /**
+         * RequestId repeat
+         */
+        this.requestIdRepeat = false;
+        /**
+         * RequestId repeat delay
+         */
+        this.requestIdRepeatDelay = 0;
+        /**
+         * RequestId repeat statuscodes
+         */
+        this.requestIdRepeatStatusCodes = [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: InterceptorsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: InterceptorsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: InterceptorsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class BaseInterceptor {
+    skipInterceptor() {
+        if (this.type !== null && this.interceptorsService.skip.indexOf(InterceptorType.ALL) !== -1) {
+            this.loggerService.warn('Interceptor skipped, reason is ALL skipped: ' + this.type);
+            return true;
+        }
+        const skip = this.type !== null && this.interceptorsService.skip.indexOf(this.type) !== -1;
+        if (skip) {
+            this.loggerService.warn('Interceptor skipped, reason is [' + this.interceptorsService.skip.join(', ') + '] skipped');
+        }
+        return skip;
+    }
+    constructor(type) {
+        this.type = null;
+        this.interceptorsService = inject(InterceptorsService);
+        this.loggerService = inject(LoggerService);
+        this.type = type;
+        this.loggerService.info('Interceptor initialized: ' + this.type);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseInterceptor, deps: [{ token: InterceptorType }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: InterceptorType }]; } });
+
+class TokenInterceptor extends BaseInterceptor {
+    intercept(request, next) {
+        if (this.skipInterceptor()) {
+            return next.handle(request);
+        }
+        const accessToken = this.tokenService.accessToken;
+        if (accessToken !== null) {
+            request = request.clone({
+                setHeaders: {
+                    Token: accessToken
+                }
+            });
+        }
+        return next.handle(request);
+    }
+    constructor() {
+        super(InterceptorType.TOKEN);
+        this.tokenService = inject(TokenService);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TokenInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TokenInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TokenInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+function provideTokenInterceptor() {
+    return makeEnvironmentProviders([{
+            provide: HTTP_INTERCEPTORS,
+            useClass: TokenInterceptor,
+            multi: true
+        }]);
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ALERT_CONFIGURATIONS, ALERT_DEFAULT_BUTTON_CONFIGURATION, AcceptValidationMode, ApiService, CF_PREDEFINED_DIALOGS, CONFIRM_CONFIGURATIONS, DialogConfig, DialogInjector, DialogRef, DialogService, LOG_LEVEL, LogLevel, LoggerService, MESSAGE_DEFAULT_CONFIGURATION, MessagePosition, MessageService, MessageSeverity };
+export { ALERT_CONFIGURATIONS, ALERT_DEFAULT_BUTTON_CONFIGURATION, AcceptValidationMode, ApiService, CF_PREDEFINED_DIALOGS, CONFIRM_CONFIGURATIONS, CookieService, DialogConfig, DialogInjector, DialogRef, DialogService, InterceptorType, LOG_LEVEL, LogLevel, LoggerService, MESSAGE_DEFAULT_CONFIGURATION, MessagePosition, MessageService, MessageSeverity, Precheck, TokenInterceptor, TokenService, TokenServiceMode, isBrowser, localStorage, provideTokenInterceptor, sessionStorage };
 //# sourceMappingURL=codefoxcore.mjs.map