@pepperi-addons/ngx-lib 0.3.15-beta.8 → 0.4.0-angular14.2

package/esm2020/core/http/interceptors/error.interceptor.mjs

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+// import { ToastrService } from 'ngx-toastr';
+export class PepErrorInterceptor {
+    // constructor() {} // private toastr: ToastrService
+    intercept(req, next) {
+        // console.warn('ErrorInterceptor');
+        return next.handle(req).pipe(
+        // retry(2), TODO: Check if we want to retry
+        catchError((error) => {
+            // 401 handled in auth.interceptor
+            if (error.status !== 401) {
+                // TODO: Show error in dialog.
+                // this.toastr.error(error.message);
+            }
+            return throwError(error);
+        }));
+    }
+}
+PepErrorInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepErrorInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PepErrorInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepErrorInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepErrorInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/http/interceptors/loader.interceptor.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { finalize, catchError } from 'rxjs/operators';
+import { PepLoaderService } from '../services/loader.service';
+import * as i0 from "@angular/core";
+export class PepLoaderInterceptor {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    intercept(req, next) {
+        // console.warn('LoaderInterceptor');
+        const loaderService = this.injector.get(PepLoaderService);
+        loaderService.show();
+        return next.handle(req).pipe(
+        // delay(3000),
+        catchError((err) => {
+            loaderService.hide();
+            return throwError(err);
+        }), finalize(() => loaderService.hide()));
+        // return next.handle(req).pipe(map(event => {
+        //     if (event instanceof HttpResponse) {
+        //        loaderService.hide();
+        //     }
+        //     return event;
+        // }));
+    }
+}
+PepLoaderInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepLoaderInterceptor, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+PepLoaderInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepLoaderInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepLoaderInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/http/interceptors/profiler.interceptor.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse, } from '@angular/common/http';
+import { tap, finalize } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class PepProfilerInterceptor {
+    intercept(req, next) {
+        // console.warn('ProfilerInterceptor');
+        const started = Date.now();
+        let ok;
+        return next.handle(req).pipe(tap(
+        // Succeeds when there is a response; ignore other events
+        (event) => {
+            if (event instanceof HttpResponse) {
+                ok = 'succeeded';
+            }
+        }, 
+        // Operation failed; error is an HttpErrorResponse
+        (error) => (ok = 'failed')), 
+        // Log when response observable either completes or errors
+        finalize(() => {
+            const elapsed = Date.now() - started;
+            const msg = `${req.method} "${req.urlWithParams}" ${ok} in ${elapsed} ms.`;
+            console.log(msg);
+        }));
+    }
+}
+PepProfilerInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepProfilerInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PepProfilerInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepProfilerInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepProfilerInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/http/services/http.service.mjs

@@ -0,0 +1,155 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders, } from '@angular/common/http';
+import { throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/services/session.service";
+import * as i2 from "../../common/services/cookie.service";
+import * as i3 from "@angular/common/http";
+export class PepHttpService {
+    constructor(sessionService, cookieService, http) {
+        this.sessionService = sessionService;
+        this.cookieService = cookieService;
+        this.http = http;
+        this.AUTH_HEADER = 'Authorization';
+        this.PEPPERI_TOKEN_HEADER = 'PepperiSessionToken';
+        this.WAPI_TOKEN_KEY = 'auth_token';
+        this.PEPPERI_TOKEN_COOKIE = 'PepperiUserSettings';
+    }
+    handleError(response) {
+        let errorMessage = 'Unknown error!';
+        if (response.error instanceof ErrorEvent) {
+            // Client-side errors
+            errorMessage = `Error: ${response.error.message}`;
+        }
+        else {
+            // Server-side errors
+            errorMessage = this.getServerErrorMessage(response);
+        }
+        return throwError(errorMessage);
+    }
+    getServerErrorMessage(response) {
+        if (response?.error?.fault?.faultstring) {
+            return `${response.error.fault.faultstring}`;
+        }
+        else {
+            switch (response.status) {
+                case 404: {
+                    return `Not Found: ${response.message}`;
+                }
+                case 403: {
+                    return `Access Denied: ${response.message}`;
+                }
+                case 500: {
+                    return `Internal Server Error: ${response.message}`;
+                }
+                default: {
+                    return `Unknown Server Error\nError Code: ${response.status}\nMessage: ${response.message}`;
+                }
+            }
+        }
+    }
+    // Add authorization token if the token exist.
+    addAuthorizationToken(httpOptions = {}) {
+        if (!httpOptions.headers.has(this.AUTH_HEADER)) {
+            const idpToken = this.sessionService.getIdpToken();
+            if (idpToken) {
+                httpOptions.headers = httpOptions.headers.set(this.AUTH_HEADER, `Bearer ${idpToken}`);
+            }
+        }
+        return httpOptions;
+    }
+    // Add web api token if calling to wapi domain.
+    addWebApiToken(url, httpOptions = {}) {
+        if (!httpOptions.headers.has(this.PEPPERI_TOKEN_HEADER)) {
+            const wapiBaseUrl = this.sessionService.getWapiBaseUrl();
+            if (wapiBaseUrl && url.match(new RegExp(wapiBaseUrl, 'g'))) {
+                // TODO:
+                // const webApiToken = this.sessionService.getWapiToken();
+                try {
+                    const userSettingCookie = this.cookieService.get(this.PEPPERI_TOKEN_COOKIE);
+                    const webApiToken = JSON.parse(userSettingCookie).values
+                        .items[this.WAPI_TOKEN_KEY];
+                    if (webApiToken) {
+                        httpOptions.headers = httpOptions.headers.set(this.PEPPERI_TOKEN_HEADER, webApiToken);
+                    }
+                }
+                catch {
+                    // Do nothing.
+                }
+            }
+        }
+        return httpOptions;
+    }
+    setDefaultHeaderOptions(url, httpOptions = {}) {
+        if (!httpOptions.headers) {
+            httpOptions.headers = new HttpHeaders();
+        }
+        // Add content type
+        if (!httpOptions.headers.has('Content-Type')) {
+            httpOptions.headers = httpOptions.headers.set('Content-Type', 'application/json');
+        }
+        httpOptions = this.addAuthorizationToken(httpOptions);
+        httpOptions = this.addWebApiToken(url, httpOptions);
+        return httpOptions;
+    }
+    // getTextFile(filename: string): void {
+    //     // The Observable returned by get() is of type Observable<string>
+    //     // because a text response was specified.
+    //     // There's no need to pass a <string> type parameter to get().
+    //     // return this.http.get(filename, {responseType: 'text'})
+    //     //     .pipe(
+    //     //         tap( // Log the result or error
+    //     //         data => this.log(filename, data),
+    //     //         error => this.logError(filename, error)
+    //     //         )
+    //     // );
+    // }
+    getHttpCall(url, httpOptions = {}) {
+        httpOptions = this.setDefaultHeaderOptions(url, httpOptions);
+        return this.http
+            .get(url, httpOptions)
+            .pipe(catchError(this.handleError.bind(this)));
+        //     .subscribe(
+        //         (res) => console.log(''),
+        //         (error) => console.log(''),
+        //         () => {}
+        // );
+    }
+    postHttpCall(url, body, httpOptions = {}) {
+        httpOptions = this.setDefaultHeaderOptions(url, httpOptions);
+        return this.http
+            .post(url, body, httpOptions)
+            .pipe(catchError(this.handleError.bind(this)));
+        //     .subscribe(
+        //         (res) => console.log(''),
+        //         (error) => console.log(''),
+        //         () => {}
+        // );
+    }
+    getWapiApiCall(url, httpOptions = {}) {
+        const wapiBaseUrl = this.sessionService.getWapiBaseUrl();
+        return this.getHttpCall(`${wapiBaseUrl}${url}`, httpOptions);
+    }
+    postWapiApiCall(url, body, httpOptions = {}) {
+        const wapiBaseUrl = this.sessionService.getWapiBaseUrl();
+        return this.postHttpCall(`${wapiBaseUrl}${url}`, body, httpOptions);
+    }
+    getPapiApiCall(url, httpOptions = {}) {
+        const papiBaseUrl = this.sessionService.getPapiBaseUrl();
+        return this.getHttpCall(`${papiBaseUrl}${url}`, httpOptions);
+    }
+    postPapiApiCall(url, body, httpOptions = {}) {
+        const papiBaseUrl = this.sessionService.getPapiBaseUrl();
+        return this.postHttpCall(`${papiBaseUrl}${url}`, body, httpOptions);
+    }
+}
+PepHttpService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepHttpService, deps: [{ token: i1.PepSessionService }, { token: i2.PepCookieService }, { token: i3.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+PepHttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepHttpService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepHttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PepSessionService }, { type: i2.PepCookieService }, { type: i3.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-lib/src/core/http/services/http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n    HttpClient,\n    HttpErrorResponse,\n    HttpParams,\n    HttpHeaders,\n} from '@angular/common/http';\nimport { throwError, Observable } from 'rxjs';\nimport { retry, catchError, tap } from 'rxjs/operators';\nimport { PepSessionService } from '../../common/services/session.service';\nimport { PepCookieService } from '../../common/services/cookie.service';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class PepHttpService {\n    private readonly AUTH_HEADER = 'Authorization';\n    private readonly PEPPERI_TOKEN_HEADER = 'PepperiSessionToken';\n    private readonly WAPI_TOKEN_KEY = 'auth_token';\n    private readonly PEPPERI_TOKEN_COOKIE = 'PepperiUserSettings';\n\n    constructor(\n        private sessionService: PepSessionService,\n        private cookieService: PepCookieService,\n        private http: HttpClient\n    ) {}\n\n    private handleError(response: HttpErrorResponse): Observable<never> {\n        let errorMessage = 'Unknown error!';\n        if (response.error instanceof ErrorEvent) {\n            // Client-side errors\n            errorMessage = `Error: ${response.error.message}`;\n        } else {\n            // Server-side errors\n            errorMessage = this.getServerErrorMessage(response);\n        }\n\n        return throwError(errorMessage);\n    }\n\n    private getServerErrorMessage(response: HttpErrorResponse): string {\n        if (response?.error?.fault?.faultstring) {\n            return `${response.error.fault.faultstring}`;\n        } else {\n            switch (response.status) {\n                case 404: {\n                    return `Not Found: ${response.message}`;\n                }\n                case 403: {\n                    return `Access Denied: ${response.message}`;\n                }\n                case 500: {\n                    return `Internal Server Error: ${response.message}`;\n                }\n                default: {\n                    return `Unknown Server Error\\nError Code: ${response.status}\\nMessage: ${response.message}`;\n                }\n            }\n        }\n    }\n\n    // Add authorization token if the token exist.\n    private addAuthorizationToken(httpOptions: any = {}): any {\n        if (!httpOptions.headers.has(this.AUTH_HEADER)) {\n            const idpToken = this.sessionService.getIdpToken();\n\n            if (idpToken) {\n                httpOptions.headers = httpOptions.headers.set(\n                    this.AUTH_HEADER,\n                    `Bearer ${idpToken}`\n                );\n            }\n        }\n\n        return httpOptions;\n    }\n\n    // Add web api token if calling to wapi domain.\n    private addWebApiToken(url: string, httpOptions: any = {}): any {\n        if (!httpOptions.headers.has(this.PEPPERI_TOKEN_HEADER)) {\n            const wapiBaseUrl = this.sessionService.getWapiBaseUrl();\n\n            if (wapiBaseUrl && url.match(new RegExp(wapiBaseUrl, 'g'))) {\n                // TODO:\n                // const webApiToken = this.sessionService.getWapiToken();\n                try {\n                    const userSettingCookie = this.cookieService.get(\n                        this.PEPPERI_TOKEN_COOKIE\n                    );\n                    const webApiToken = JSON.parse(userSettingCookie).values\n                        .items[this.WAPI_TOKEN_KEY];\n                    if (webApiToken) {\n                        httpOptions.headers = httpOptions.headers.set(\n                            this.PEPPERI_TOKEN_HEADER,\n                            webApiToken\n                        );\n                    }\n                } catch {\n                    // Do nothing.\n                }\n            }\n        }\n\n        return httpOptions;\n    }\n\n    private setDefaultHeaderOptions(url: string, httpOptions: any = {}): any {\n        if (!httpOptions.headers) {\n            httpOptions.headers = new HttpHeaders();\n        }\n\n        // Add content type\n        if (!httpOptions.headers.has('Content-Type')) {\n            httpOptions.headers = httpOptions.headers.set(\n                'Content-Type',\n                'application/json'\n            );\n        }\n\n        httpOptions = this.addAuthorizationToken(httpOptions);\n        httpOptions = this.addWebApiToken(url, httpOptions);\n\n        return httpOptions;\n    }\n\n    // getTextFile(filename: string): void {\n    //     // The Observable returned by get() is of type Observable<string>\n    //     // because a text response was specified.\n    //     // There's no need to pass a <string> type parameter to get().\n    //     // return this.http.get(filename, {responseType: 'text'})\n    //     //     .pipe(\n    //     //         tap( // Log the result or error\n    //     //         data => this.log(filename, data),\n    //     //         error => this.logError(filename, error)\n    //     //         )\n    //     // );\n    // }\n\n    getHttpCall(url: string, httpOptions: any = {}): Observable<any> {\n        httpOptions = this.setDefaultHeaderOptions(url, httpOptions);\n\n        return this.http\n            .get(url, httpOptions)\n            .pipe(catchError(this.handleError.bind(this)));\n        //     .subscribe(\n        //         (res) => console.log(''),\n        //         (error) => console.log(''),\n        //         () => {}\n        // );\n    }\n\n    postHttpCall(\n        url: string,\n        body: any | null,\n        httpOptions: any = {}\n    ): Observable<any> {\n        httpOptions = this.setDefaultHeaderOptions(url, httpOptions);\n\n        return this.http\n            .post(url, body, httpOptions)\n            .pipe(catchError(this.handleError.bind(this)));\n        //     .subscribe(\n        //         (res) => console.log(''),\n        //         (error) => console.log(''),\n        //         () => {}\n        // );\n    }\n\n    getWapiApiCall(url: string, httpOptions: any = {}): Observable<any> {\n        const wapiBaseUrl = this.sessionService.getWapiBaseUrl();\n        return this.getHttpCall(`${wapiBaseUrl}${url}`, httpOptions);\n    }\n\n    postWapiApiCall(\n        url: string,\n        body: any | null,\n        httpOptions: any = {}\n    ): Observable<any> {\n        const wapiBaseUrl = this.sessionService.getWapiBaseUrl();\n        return this.postHttpCall(`${wapiBaseUrl}${url}`, body, httpOptions);\n    }\n\n    getPapiApiCall(url: string, httpOptions: any = {}): Observable<any> {\n        const papiBaseUrl = this.sessionService.getPapiBaseUrl();\n        return this.getHttpCall(`${papiBaseUrl}${url}`, httpOptions);\n    }\n\n    postPapiApiCall(\n        url: string,\n        body: any | null,\n        httpOptions: any = {}\n    ): Observable<any> {\n        const papiBaseUrl = this.sessionService.getPapiBaseUrl();\n        return this.postHttpCall(`${papiBaseUrl}${url}`, body, httpOptions);\n    }\n}\n"]}

package/esm2020/core/http/services/loader.service.mjs

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { distinctUntilChanged } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class PepLoaderService {
+    constructor() {
+        this.counter = 0;
+        this.showLoaderSubject = new BehaviorSubject(false);
+        // Raise custom event for showing the loader.
+        this.onChanged$.subscribe((show) => {
+            this.showLoaderChanged(show);
+        });
+    }
+    get onChanged$() {
+        return this.showLoaderSubject
+            .asObservable()
+            .pipe(distinctUntilChanged());
+    }
+    showLoaderChanged(show) {
+        const eventData = {
+            detail: {
+                showLoader: show,
+            },
+        };
+        const event = new CustomEvent('toggleLoader', eventData);
+        window.dispatchEvent(event);
+    }
+    show() {
+        this.counter++;
+        this.showLoaderSubject.next(true);
+    }
+    hide() {
+        this.counter--;
+        if (this.counter < 0) {
+            this.counter = 0;
+        }
+        if (this.counter === 0) {
+            this.showLoaderSubject.next(false);
+        }
+    }
+}
+PepLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PepLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepLoaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/layout/layout.service.mjs

@@ -0,0 +1,168 @@
+import { Injectable, Optional } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { distinctUntilChanged } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+// Const BIDI_RTL_LANGS Array
+// BIDI_RTL_LANGS ref: http://en.wikipedia.org/wiki/Right-to-left
+// Table of scripts in Unicode: https://en.wikipedia.org/wiki/Script_(Unicode)
+const _BIDI_RTL_LANGS = [
+    'ae' /* Avestan */,
+    'ar' /* 'العربية', Arabic */,
+    'arc' /* Aramaic */,
+    'bcc' /* 'بلوچی مکرانی', Southern Balochi */,
+    'bqi' /* 'بختياري', Bakthiari */,
+    'ckb' /* 'Soranî / کوردی', Sorani */,
+    'dv' /* Dhivehi */,
+    'fa' /* 'فارسی', Persian */,
+    'glk' /* 'گیلکی', Gilaki */,
+    'he' /* 'עברית', Hebrew */,
+    'ku' /* 'Kurdî / كوردی', Kurdish */,
+    'mzn' /* 'مازِرونی', Mazanderani */,
+    'nqo' /* N'Ko */,
+    'pnb' /* 'پنجابی', Western Punjabi */,
+    'ps' /* 'پښتو', Pashto, */,
+    'sd' /* 'سنڌي', Sindhi */,
+    'ug' /* 'Uyghurche / ئۇيغۇرچە', Uyghur */,
+    'ur' /* 'اردو', Urdu */,
+    'yi' /* 'ייִדיש', Yiddish */,
+];
+export var PepScreenSizeType;
+(function (PepScreenSizeType) {
+    PepScreenSizeType[PepScreenSizeType["XL"] = 0] = "XL";
+    PepScreenSizeType[PepScreenSizeType["LG"] = 1] = "LG";
+    PepScreenSizeType[PepScreenSizeType["MD"] = 2] = "MD";
+    PepScreenSizeType[PepScreenSizeType["SM"] = 3] = "SM";
+    PepScreenSizeType[PepScreenSizeType["XS"] = 4] = "XS";
+})(PepScreenSizeType || (PepScreenSizeType = {}));
+// export type PepScreenSizeType = 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export class PepLayoutService {
+    constructor(translate = null) {
+        this.translate = translate;
+        this.documentMouseoverListener = (event) => {
+            this.deviceHasMouseSubject.next(true);
+            this.deviceHasMouseSubject.complete();
+            document.removeEventListener('mouseover', this.documentMouseoverListener, false);
+        };
+        this.resizeSubject = new BehaviorSubject(PepScreenSizeType.LG);
+        this.deviceHasMouseSubject = new BehaviorSubject(false);
+        document.addEventListener('mouseover', this.documentMouseoverListener, false);
+        // document.addEventListener('touchstart', this._documentTouchstartListener, false);
+    }
+    get onResize$() {
+        return this.resizeSubject.asObservable().pipe(distinctUntilChanged());
+    }
+    get onMouseOver$() {
+        return this.deviceHasMouseSubject
+            .asObservable()
+            .pipe(distinctUntilChanged());
+    }
+    // private _documentTouchstartListener = (event: TouchEvent) => {
+    //     debugger;
+    //     this.isTouchDevice = true;
+    //     document.removeEventListener('touchstart', this._documentTouchstartListener, false);
+    // }
+    /**
+     * Set the current screen size.
+     * @param size The size to change to.
+     */
+    onResize(size) {
+        this.resizeSubject.next(size);
+    }
+    getDeviceHasMouse() {
+        return this.deviceHasMouseSubject.getValue();
+    }
+    getOrintation() {
+        if (window.innerHeight > window.innerWidth) {
+            return 'portrait';
+        }
+        else {
+            return 'landscape';
+        }
+    }
+    getScreenWidth() {
+        let retVal = 250.0;
+        switch (this.resizeSubject.getValue()) {
+            case PepScreenSizeType.XS: {
+                retVal = this.getOrintation() === 'landscape' ? 130.0 : 65.0;
+                break;
+            }
+            case PepScreenSizeType.SM:
+            case PepScreenSizeType.MD: {
+                retVal = this.getOrintation() === 'landscape' ? 220.0 : 140.0;
+                break;
+            }
+            case PepScreenSizeType.LG:
+            case PepScreenSizeType.XL: {
+                retVal = this.getOrintation() === 'landscape' ? 400.0 : 250.0;
+                break;
+            }
+        }
+        return retVal;
+    }
+    getScreenHeight() {
+        let retVal = 250.0;
+        switch (this.resizeSubject.getValue()) {
+            case PepScreenSizeType.XS: {
+                retVal = this.getOrintation() === 'landscape' ? 65.0 : 130.0;
+                break;
+            }
+            case PepScreenSizeType.SM:
+            case PepScreenSizeType.MD: {
+                retVal = this.getOrintation() === 'landscape' ? 140.0 : 220.0;
+                break;
+            }
+            case PepScreenSizeType.LG:
+            case PepScreenSizeType.XL: {
+                retVal = this.getOrintation() === 'landscape' ? 250.0 : 400.0;
+                break;
+            }
+        }
+        return retVal;
+    }
+    getScreenHeightPx() {
+        return (window.innerHeight ||
+            document.documentElement.clientHeight ||
+            document.body.clientHeight);
+    }
+    getScreenWidthPx() {
+        return (window.innerWidth ||
+            document.documentElement.clientWidth ||
+            document.body.clientWidth);
+    }
+    getScrollbarWidth() {
+        // Creating invisible container
+        const outer = document.createElement('div');
+        outer.style.visibility = 'hidden';
+        outer.style.overflow = 'scroll'; // forcing scrollbar to appear
+        // outer.style.msOverflowStyle = 'scrollbar'; // needed for WinJS apps
+        document.body.appendChild(outer);
+        // Creating inner element and placing it in the container
+        const inner = document.createElement('div');
+        outer.appendChild(inner);
+        // Calculating difference between container's full width and the child width
+        const scrollbarWidth = (outer.offsetWidth - inner.offsetWidth);
+        // Removing temporary elements from the DOM
+        outer.parentNode.removeChild(outer);
+        return scrollbarWidth;
+    }
+    getCurrentLanguage() {
+        return this.translate?.getBrowserCultureLang() || navigator.language;
+    }
+    isRtl() {
+        const userLang = this.getCurrentLanguage();
+        const isRtl = _BIDI_RTL_LANGS.indexOf(userLang) >= 0;
+        return isRtl;
+    }
+}
+PepLayoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepLayoutService, deps: [{ token: i1.TranslateService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+PepLayoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepLayoutService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepLayoutService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layout.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-lib/src/core/layout/layout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\nimport { Observable, BehaviorSubject } from 'rxjs';\nimport { distinctUntilChanged } from 'rxjs/operators';\nimport { TranslateService } from '@ngx-translate/core';\n\n// Const BIDI_RTL_LANGS Array\n// BIDI_RTL_LANGS ref: http://en.wikipedia.org/wiki/Right-to-left\n// Table of scripts in Unicode: https://en.wikipedia.org/wiki/Script_(Unicode)\nconst _BIDI_RTL_LANGS = [\n    'ae' /* Avestan */,\n    'ar' /* 'العربية', Arabic */,\n    'arc' /* Aramaic */,\n    'bcc' /* 'بلوچی مکرانی', Southern Balochi */,\n    'bqi' /* 'بختياري', Bakthiari */,\n    'ckb' /* 'Soranî / کوردی', Sorani */,\n    'dv' /* Dhivehi */,\n    'fa' /* 'فارسی', Persian */,\n    'glk' /* 'گیلکی', Gilaki */,\n    'he' /* 'עברית', Hebrew */,\n    'ku' /* 'Kurdî / كوردی', Kurdish */,\n    'mzn' /* 'مازِرونی', Mazanderani */,\n    'nqo' /* N'Ko */,\n    'pnb' /* 'پنجابی', Western Punjabi */,\n    'ps' /* 'پښتو', Pashto, */,\n    'sd' /* 'سنڌي', Sindhi */,\n    'ug' /* 'Uyghurche / ئۇيغۇرچە', Uyghur */,\n    'ur' /* 'اردو', Urdu */,\n    'yi' /* 'ייִדיש', Yiddish */,\n];\n\nexport type PepOrientationType = 'landscape' | 'portrait';\n\nexport enum PepScreenSizeType {\n    XL,\n    LG,\n    MD,\n    SM,\n    XS,\n}\n// export type PepScreenSizeType = 'xl' | 'lg' | 'md' | 'sm' | 'xs';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class PepLayoutService {\n    private resizeSubject: BehaviorSubject<PepScreenSizeType>;\n    private deviceHasMouseSubject: BehaviorSubject<boolean>;\n\n    get onResize$(): Observable<PepScreenSizeType> {\n        return this.resizeSubject.asObservable().pipe(distinctUntilChanged());\n    }\n\n    get onMouseOver$(): Observable<boolean> {\n        return this.deviceHasMouseSubject\n            .asObservable()\n            .pipe(distinctUntilChanged());\n    }\n\n    constructor(@Optional() private translate: TranslateService = null) {\n        this.resizeSubject = new BehaviorSubject(PepScreenSizeType.LG);\n\n        this.deviceHasMouseSubject = new BehaviorSubject(false);\n        document.addEventListener(\n            'mouseover',\n            this.documentMouseoverListener,\n            false\n        );\n        // document.addEventListener('touchstart', this._documentTouchstartListener, false);\n    }\n\n    private documentMouseoverListener = (event: MouseEvent) => {\n        this.deviceHasMouseSubject.next(true);\n        this.deviceHasMouseSubject.complete();\n        document.removeEventListener(\n            'mouseover',\n            this.documentMouseoverListener,\n            false\n        );\n    };\n\n    // private _documentTouchstartListener = (event: TouchEvent) => {\n    //     debugger;\n    //     this.isTouchDevice = true;\n    //     document.removeEventListener('touchstart', this._documentTouchstartListener, false);\n    // }\n\n    /**\n     * Set the current screen size.\n     * @param size The size to change to.\n     */\n    onResize(size: PepScreenSizeType): void {\n        this.resizeSubject.next(size);\n    }\n\n    getDeviceHasMouse(): boolean {\n        return this.deviceHasMouseSubject.getValue();\n    }\n\n    getOrintation(): PepOrientationType {\n        if (window.innerHeight > window.innerWidth) {\n            return 'portrait';\n        } else {\n            return 'landscape';\n        }\n    }\n\n    getScreenWidth(): number {\n        let retVal = 250.0;\n        switch (this.resizeSubject.getValue()) {\n            case PepScreenSizeType.XS: {\n                retVal = this.getOrintation() === 'landscape' ? 130.0 : 65.0;\n                break;\n            }\n            case PepScreenSizeType.SM:\n            case PepScreenSizeType.MD: {\n                retVal = this.getOrintation() === 'landscape' ? 220.0 : 140.0;\n                break;\n            }\n            case PepScreenSizeType.LG:\n            case PepScreenSizeType.XL: {\n                retVal = this.getOrintation() === 'landscape' ? 400.0 : 250.0;\n                break;\n            }\n        }\n        return retVal;\n    }\n\n    getScreenHeight(): number {\n        let retVal = 250.0;\n        switch (this.resizeSubject.getValue()) {\n            case PepScreenSizeType.XS: {\n                retVal = this.getOrintation() === 'landscape' ? 65.0 : 130.0;\n                break;\n            }\n            case PepScreenSizeType.SM:\n            case PepScreenSizeType.MD: {\n                retVal = this.getOrintation() === 'landscape' ? 140.0 : 220.0;\n                break;\n            }\n            case PepScreenSizeType.LG:\n            case PepScreenSizeType.XL: {\n                retVal = this.getOrintation() === 'landscape' ? 250.0 : 400.0;\n                break;\n            }\n        }\n        return retVal;\n    }\n\n    getScreenHeightPx(): number {\n        return (\n            window.innerHeight ||\n            document.documentElement.clientHeight ||\n            document.body.clientHeight\n        );\n    }\n\n    getScreenWidthPx(): number {\n        return (\n            window.innerWidth ||\n            document.documentElement.clientWidth ||\n            document.body.clientWidth\n        );\n    }\n\n    getScrollbarWidth() {\n        // Creating invisible container\n        const outer = document.createElement('div');\n        outer.style.visibility = 'hidden';\n        outer.style.overflow = 'scroll'; // forcing scrollbar to appear\n        // outer.style.msOverflowStyle = 'scrollbar'; // needed for WinJS apps\n        document.body.appendChild(outer);\n\n        // Creating inner element and placing it in the container\n        const inner = document.createElement('div');\n        outer.appendChild(inner);\n\n        // Calculating difference between container's full width and the child width\n        const scrollbarWidth = (outer.offsetWidth - inner.offsetWidth);\n\n        // Removing temporary elements from the DOM\n        outer.parentNode.removeChild(outer);\n\n        return scrollbarWidth;\n    }\n\n    getCurrentLanguage(): string {\n        return this.translate?.getBrowserCultureLang() || navigator.language;\n    }\n\n    isRtl(): boolean {\n        const userLang = this.getCurrentLanguage();\n        const isRtl = _BIDI_RTL_LANGS.indexOf(userLang) >= 0;\n\n        return isRtl;\n    }\n}\n"]}

package/esm2020/core/layout/rtl.directive.mjs

@@ -0,0 +1,44 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./layout.service";
+export class PepRtlClassDirective {
+    constructor(layoutService, renderer, element) {
+        this.layoutService = layoutService;
+        this.renderer = renderer;
+        this.element = element;
+    }
+    ngOnInit() {
+        const isRtl = this.layoutService.isRtl();
+        if (isRtl) {
+            this.renderer.addClass(this.element.nativeElement, 'rtl');
+        }
+    }
+}
+PepRtlClassDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepRtlClassDirective, deps: [{ token: i1.PepLayoutService }, { token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+PepRtlClassDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: PepRtlClassDirective, selector: "[pepRtlClass]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepRtlClassDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[pepRtlClass]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PepLayoutService }, { type: i0.Renderer2 }, { type: i0.ElementRef }]; } });
+export class PepRtlDirectionDirective {
+    constructor(layoutService, renderer, element) {
+        this.layoutService = layoutService;
+        this.renderer = renderer;
+        this.element = element;
+    }
+    ngOnInit() {
+        const isRtl = this.layoutService.isRtl();
+        this.renderer.setAttribute(this.element.nativeElement, 'dir', isRtl ? 'rtl' : 'ltr');
+    }
+}
+PepRtlDirectionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepRtlDirectionDirective, deps: [{ token: i1.PepLayoutService }, { token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+PepRtlDirectionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: PepRtlDirectionDirective, selector: "[pepRtlDirection]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepRtlDirectionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[pepRtlDirection]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PepLayoutService }, { type: i0.Renderer2 }, { type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnRsLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1saWIvc3JjL2NvcmUvbGF5b3V0L3J0bC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBaUMsTUFBTSxlQUFlLENBQUM7OztBQU16RSxNQUFNLE9BQU8sb0JBQW9CO0lBQzdCLFlBQ1ksYUFBK0IsRUFDL0IsUUFBbUIsRUFDbkIsT0FBbUI7UUFGbkIsa0JBQWEsR0FBYixhQUFhLENBQWtCO1FBQy9CLGFBQVEsR0FBUixRQUFRLENBQVc7UUFDbkIsWUFBTyxHQUFQLE9BQU8sQ0FBWTtJQUM1QixDQUFDO0lBRUosUUFBUTtRQUNKLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFekMsSUFBSSxLQUFLLEVBQUU7WUFDUCxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSxLQUFLLENBQUMsQ0FBQztTQUM3RDtJQUNMLENBQUM7O2lIQWJRLG9CQUFvQjtxR0FBcEIsb0JBQW9COzJGQUFwQixvQkFBb0I7a0JBSGhDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLGVBQWU7aUJBQzVCOztBQW9CRCxNQUFNLE9BQU8sd0JBQXdCO0lBQ2pDLFlBQ1ksYUFBK0IsRUFDL0IsUUFBbUIsRUFDbkIsT0FBbUI7UUFGbkIsa0JBQWEsR0FBYixhQUFhLENBQWtCO1FBQy9CLGFBQVEsR0FBUixRQUFRLENBQVc7UUFDbkIsWUFBTyxHQUFQLE9BQU8sQ0FBWTtJQUM1QixDQUFDO0lBRUosUUFBUTtRQUNKLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFekMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQ3RCLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxFQUMxQixLQUFLLEVBQ0wsS0FBSyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FDeEIsQ0FBQztJQUNOLENBQUM7O3FIQWZRLHdCQUF3Qjt5R0FBeEIsd0JBQXdCOzJGQUF4Qix3QkFBd0I7a0JBSHBDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLG1CQUFtQjtpQkFDaEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIFJlbmRlcmVyMiwgRWxlbWVudFJlZiwgT25Jbml0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBQZXBMYXlvdXRTZXJ2aWNlIH0gZnJvbSAnLi9sYXlvdXQuc2VydmljZSc7XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnW3BlcFJ0bENsYXNzXScsXG59KVxuZXhwb3J0IGNsYXNzIFBlcFJ0bENsYXNzRGlyZWN0aXZlIGltcGxlbWVudHMgT25Jbml0IHtcbiAgICBjb25zdHJ1Y3RvcihcbiAgICAgICAgcHJpdmF0ZSBsYXlvdXRTZXJ2aWNlOiBQZXBMYXlvdXRTZXJ2aWNlLFxuICAgICAgICBwcml2YXRlIHJlbmRlcmVyOiBSZW5kZXJlcjIsXG4gICAgICAgIHByaXZhdGUgZWxlbWVudDogRWxlbWVudFJlZlxuICAgICkge31cblxuICAgIG5nT25Jbml0KCk6IHZvaWQge1xuICAgICAgICBjb25zdCBpc1J0bCA9IHRoaXMubGF5b3V0U2VydmljZS5pc1J0bCgpO1xuXG4gICAgICAgIGlmIChpc1J0bCkge1xuICAgICAgICAgICAgdGhpcy5yZW5kZXJlci5hZGRDbGFzcyh0aGlzLmVsZW1lbnQubmF0aXZlRWxlbWVudCwgJ3J0bCcpO1xuICAgICAgICB9XG4gICAgfVxufVxuXG5ARGlyZWN0aXZlKHtcbiAgICBzZWxlY3RvcjogJ1twZXBSdGxEaXJlY3Rpb25dJyxcbn0pXG5leHBvcnQgY2xhc3MgUGVwUnRsRGlyZWN0aW9uRGlyZWN0aXZlIGltcGxlbWVudHMgT25Jbml0IHtcbiAgICBjb25zdHJ1Y3RvcihcbiAgICAgICAgcHJpdmF0ZSBsYXlvdXRTZXJ2aWNlOiBQZXBMYXlvdXRTZXJ2aWNlLFxuICAgICAgICBwcml2YXRlIHJlbmRlcmVyOiBSZW5kZXJlcjIsXG4gICAgICAgIHByaXZhdGUgZWxlbWVudDogRWxlbWVudFJlZlxuICAgICkge31cblxuICAgIG5nT25Jbml0KCk6IHZvaWQge1xuICAgICAgICBjb25zdCBpc1J0bCA9IHRoaXMubGF5b3V0U2VydmljZS5pc1J0bCgpO1xuXG4gICAgICAgIHRoaXMucmVuZGVyZXIuc2V0QXR0cmlidXRlKFxuICAgICAgICAgICAgdGhpcy5lbGVtZW50Lm5hdGl2ZUVsZW1lbnQsXG4gICAgICAgICAgICAnZGlyJyxcbiAgICAgICAgICAgIGlzUnRsID8gJ3J0bCcgOiAnbHRyJ1xuICAgICAgICApO1xuICAgIH1cbn1cbiJdfQ==