@pepperi-addons/ngx-lib 0.5.0-ng15.2 → 0.5.0-ng16.1

package/esm2022/core/common/services/validator.service.mjs

@@ -0,0 +1,273 @@
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { Injectable, Optional } from '@angular/core';
+import { FormControl, Validators, } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class PepValidatorService {
+    translate;
+    //  Regular expressions
+    integerUnsigned = '^[0-9]*$';
+    integerSigned = '^-?[0-9]+$';
+    decimalUnsigned = '^[0-9]+(.[0-9]+)?$';
+    decimalSigned = '^-?[0-9]+(.[0-9]+)?$';
+    phone = '^[+]*[(]{0,1}[0-9]{1,4}[)]{0,1}[-s./0-9]*$';
+    decimalSeparator = '.';
+    constructor(translate = null) {
+        this.translate = translate;
+        const currentLang = this.translate?.currentLang || navigator.language;
+        // Check for number with thousands separator and if === ',' then the decimal separator is '.' else ','
+        const tmp = new Intl.NumberFormat(currentLang, {
+            maximumSignificantDigits: 2,
+        }).format(1000);
+        this.decimalSeparator = tmp.indexOf(',') === 1 ? '.' : ',';
+        this.decimalUnsigned = `^[0-9]+(${this.decimalSeparator}[0-9]+)?$`;
+        this.decimalSigned = `^-?[0-9]+(${this.decimalSeparator}[0-9]+)?$`;
+    }
+    /*
+        ValidatorFn functions
+    */
+    isEqual(target) {
+        return (control) => {
+            if (control.value) {
+                return target.value !== control.value
+                    ? { equal: { value: true } }
+                    : null;
+            }
+            else {
+                return null;
+            }
+        };
+    }
+    isGreaterThan(target) {
+        return (control) => {
+            if (control.value && typeof target.value === 'number') {
+                return target.value > control.value
+                    ? { greater: { value: true } }
+                    : null;
+            }
+            else if (control.value && typeof target.value === 'string') {
+                const controlValueNumer = coerceNumberProperty(control.value);
+                const targetValueNumer = coerceNumberProperty(target.value);
+                return targetValueNumer > controlValueNumer
+                    ? { greater: { value: true } }
+                    : null;
+            }
+            else {
+                return null;
+            }
+        };
+    }
+    isLessThan(target) {
+        return (control) => {
+            if (control.value && typeof target.value === 'number') {
+                return target.value < control.value
+                    ? { less: { value: true } }
+                    : null;
+            }
+            else if (control.value && typeof target.value === 'string') {
+                const controlValueNumer = coerceNumberProperty(control.value);
+                const targetValueNumer = coerceNumberProperty(target.value);
+                return targetValueNumer < controlValueNumer
+                    ? { less: { value: true } }
+                    : null;
+            }
+            else {
+                return null;
+            }
+        };
+    }
+    checkEmails(separator) {
+        return (control) => {
+            if (control.value) {
+                const emails = control.value.split(separator ? separator : ',');
+                const ctrl = new FormControl('', [
+                    Validators.required,
+                    Validators.email,
+                ]);
+                const result = emails.every((val) => {
+                    ctrl.setValue(val);
+                    return ctrl.valid;
+                });
+                return !result ? { emails: { value: true } } : null;
+            }
+            else {
+                return null;
+            }
+        };
+    }
+    zipCodeValidator() {
+        return Validators.pattern(/^(\d{5}(-\d{4})?|[A-Z]\d[A-Z] *\d[A-Z]\d)$/);
+    }
+    allowableCharactersValidator() {
+        return Validators.pattern(/^[a-zA-Z0-9`~!@#$%^&*()_+}{|":?><,./;'\\\]\[=\- ]+$/);
+    }
+    allowableCharactersWithoutNumberValidator() {
+        return Validators.pattern(/^[a-zA-Z`~!@#$%^&*()_+}{|":?><,./;'\\\]\[=\- ]+$/);
+    }
+    allowableCharactersWithoutSpecialValidator() {
+        return Validators.pattern(/^[a-zA-Z0-9 ]+$/);
+    }
+    dateValidator() {
+        return Validators.pattern(/^(?:(0[1-9]|1[012])[\/.](0[1-9]|[12][0-9]|3[01])[\/.](19|20)[0-9]{2})$/);
+    }
+    numberValidator() {
+        return Validators.pattern(/^[0-9]*$/);
+    }
+    /*
+        RegExp functions
+    */
+    validateNumber(value, allowDecimal) {
+        // choose the appropiate regular expression
+        let regex;
+        if (allowDecimal) {
+            regex = this.decimalSigned;
+        }
+        else {
+            regex = this.integerSigned;
+        }
+        // when a numbers begins with a decimal separator,
+        // fix it adding a zero in the beginning
+        const firstCharacter = value.charAt(0);
+        if (firstCharacter == this.decimalSeparator)
+            value = 0 + value;
+        // when a numbers ends with a decimal separator,
+        // fix it adding a zero in the end
+        const lastCharacter = value.charAt(value.length - 1);
+        if (lastCharacter == this.decimalSeparator)
+            value = value + 0;
+        // test number with regular expression, when
+        // number is invalid, replace it with a zero
+        // console.log(`regex is ${regex} and value is ${value}`);
+        const valid = new RegExp(regex).test(value);
+        return valid ? value : null;
+    }
+    validatePhone(value) {
+        // test phone with regular expression
+        const valid = new RegExp(this.phone).test(value);
+        return valid;
+    }
+    getName(e) {
+        if (e.key) {
+            return e.key;
+        }
+        else {
+            // for old browsers
+            if (e.keyCode && String.fromCharCode) {
+                switch (e.keyCode) {
+                    case 8:
+                        return 'Backspace';
+                    case 9:
+                        return 'Tab';
+                    case 27:
+                        return 'Escape';
+                    case 37:
+                        return 'ArrowLeft';
+                    case 39:
+                        return 'ArrowRight';
+                    case 188:
+                        return ',';
+                    case 190:
+                        return '.';
+                    case 109:
+                        return '-'; // minus in numbpad
+                    case 173:
+                        return '-'; // minus in alphabet keyboard in firefox
+                    case 189:
+                        return '-'; // minus in alphabet keyboard in chrome
+                    default:
+                        return String.fromCharCode(e.keyCode);
+                }
+            }
+        }
+    }
+    allowKeyboardNonNumericCharacters(allowedKeys, key, controlOrCommand) {
+        const defaultAllowedKeys = [
+            'Backspace',
+            'ArrowLeft',
+            'ArrowRight',
+            'Escape',
+            'Tab',
+            'Home',
+            'End',
+            'Delete',
+        ];
+        // allow some non-numeric characters
+        if (defaultAllowedKeys.indexOf(key) != -1 ||
+            allowedKeys.indexOf(key) != -1 ||
+            // Allow: Ctrl+A and Command+A
+            (key == 'a' && controlOrCommand) ||
+            // Allow: Ctrl+C and Command+C
+            (key == 'c' && controlOrCommand) ||
+            // Allow: Ctrl+V and Command+V
+            (key == 'v' && controlOrCommand) ||
+            // Allow: Ctrl+X and Command+X
+            (key == 'x' && controlOrCommand) ||
+            key.startsWith('F')) {
+            // let it happen, don't do anything
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    isPhone(e) {
+        const key = this.getName(e);
+        const controlOrCommand = e.ctrlKey === true || e.metaKey === true;
+        // allowed keys apart from numeric characters
+        const allowedKeys = ['.', '-', '+', '(', ')', '*', '#'];
+        // allow some non-numeric characters
+        if (this.allowKeyboardNonNumericCharacters(allowedKeys, key, controlOrCommand)) {
+            return true;
+        }
+        // allow phone characters only
+        const isPhone = new RegExp(this.phone).test(key);
+        return isPhone;
+    }
+    isNumber(e, allowDecimal) {
+        const cursorPosition = e.target['selectionStart'];
+        const originalValue = e.target['value'];
+        const key = this.getName(e);
+        const controlOrCommand = e.ctrlKey === true || e.metaKey === true;
+        const signExists = originalValue.includes('-');
+        const separatorExists = originalValue.includes(this.decimalSeparator);
+        // allowed keys apart from numeric characters
+        const allowedKeys = [];
+        // when decimals are allowed, add
+        // decimal separator to allowed codes when
+        // its position is not close to the the sign (-. and .-)
+        const separatorIsCloseToSign = signExists && cursorPosition <= 1;
+        if (allowDecimal && !separatorIsCloseToSign && !separatorExists) {
+            if (this.decimalSeparator == '.')
+                allowedKeys.push('.');
+            else
+                allowedKeys.push(',');
+        }
+        // when minus sign is allowed, add its
+        // key to allowed key only when the
+        // cursor is in the first position, and
+        // first character is different from
+        // decimal separator
+        const firstCharacterIsSeparator = originalValue.charAt(0) != this.decimalSeparator;
+        if (!signExists && firstCharacterIsSeparator && cursorPosition == 0) {
+            allowedKeys.push('-');
+        }
+        // allow some non-numeric characters
+        if (this.allowKeyboardNonNumericCharacters(allowedKeys, key, controlOrCommand)) {
+            return true;
+        }
+        // allow number characters only
+        const isNumber = new RegExp(this.integerUnsigned).test(key);
+        return isNumber;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepValidatorService, deps: [{ token: i1.TranslateService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepValidatorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepValidatorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validator.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-lib/src/core/common/services/validator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceNumberProperty } from '@angular/cdk/coercion';\nimport { Injectable, Optional } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport {\n    AbstractControl,\n    ValidatorFn,\n    FormControl,\n    Validators,\n} from '@angular/forms';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class PepValidatorService {\n    //  Regular expressions\n    readonly integerUnsigned = '^[0-9]*$';\n    readonly integerSigned = '^-?[0-9]+$';\n    decimalUnsigned = '^[0-9]+(.[0-9]+)?$';\n    decimalSigned = '^-?[0-9]+(.[0-9]+)?$';\n    readonly phone = '^[+]*[(]{0,1}[0-9]{1,4}[)]{0,1}[-s./0-9]*$';\n\n    decimalSeparator = '.';\n\n    constructor(@Optional() private translate: TranslateService = null) {\n        const currentLang = this.translate?.currentLang || navigator.language;\n\n        // Check for number with thousands separator and if === ',' then the decimal separator is '.' else ','\n        const tmp = new Intl.NumberFormat(currentLang, {\n            maximumSignificantDigits: 2,\n        }).format(1000);\n        this.decimalSeparator = tmp.indexOf(',') === 1 ? '.' : ',';\n\n        this.decimalUnsigned = `^[0-9]+(${this.decimalSeparator}[0-9]+)?$`;\n        this.decimalSigned = `^-?[0-9]+(${this.decimalSeparator}[0-9]+)?$`;\n    }\n\n    /*\n        ValidatorFn functions\n    */\n    isEqual(target: FormControl | AbstractControl): ValidatorFn {\n        return (control: AbstractControl): { [key: string]: any } | null => {\n            if (control.value) {\n                return target.value !== control.value\n                    ? { equal: { value: true } }\n                    : null;\n            } else {\n                return null;\n            }\n        };\n    }\n\n    isGreaterThan(target: FormControl | AbstractControl): ValidatorFn {\n        return (control: AbstractControl): { [key: string]: any } | null => {\n            if (control.value && typeof target.value === 'number') {\n                return target.value > control.value\n                    ? { greater: { value: true } }\n                    : null;\n            } else if (control.value && typeof target.value === 'string') {\n                const controlValueNumer = coerceNumberProperty(control.value);\n                const targetValueNumer = coerceNumberProperty(target.value);\n\n                return targetValueNumer > controlValueNumer\n                    ? { greater: { value: true } }\n                    : null;\n            } else {\n                return null;\n            }\n        };\n    }\n\n    isLessThan(target: FormControl | AbstractControl): ValidatorFn {\n        return (control: AbstractControl): { [key: string]: any } | null => {\n            if (control.value && typeof target.value === 'number') {\n                return target.value < control.value\n                    ? { less: { value: true } }\n                    : null;\n            } else if (control.value && typeof target.value === 'string') {\n                const controlValueNumer = coerceNumberProperty(control.value);\n                const targetValueNumer = coerceNumberProperty(target.value);\n\n                return targetValueNumer < controlValueNumer\n                    ? { less: { value: true } }\n                    : null;\n            } else {\n                return null;\n            }\n        };\n    }\n\n    checkEmails(separator?: string): ValidatorFn {\n        return (control: AbstractControl): { [key: string]: any } | null => {\n            if (control.value) {\n                const emails = control.value.split(separator ? separator : ',');\n                const ctrl = new FormControl('', [\n                    Validators.required,\n                    Validators.email,\n                ]);\n                const result = emails.every((val: string) => {\n                    ctrl.setValue(val);\n                    return ctrl.valid;\n                });\n\n                return !result ? { emails: { value: true } } : null;\n            } else {\n                return null;\n            }\n        };\n    }\n\n    zipCodeValidator(): ValidatorFn {\n        return Validators.pattern(/^(\\d{5}(-\\d{4})?|[A-Z]\\d[A-Z] *\\d[A-Z]\\d)$/);\n    }\n\n    allowableCharactersValidator(): ValidatorFn {\n        return Validators.pattern(\n            /^[a-zA-Z0-9`~!@#$%^&*()_+}{|\":?><,./;'\\\\\\]\\[=\\- ]+$/\n        );\n    }\n\n    allowableCharactersWithoutNumberValidator(): ValidatorFn {\n        return Validators.pattern(\n            /^[a-zA-Z`~!@#$%^&*()_+}{|\":?><,./;'\\\\\\]\\[=\\- ]+$/\n        );\n    }\n\n    allowableCharactersWithoutSpecialValidator(): ValidatorFn {\n        return Validators.pattern(/^[a-zA-Z0-9 ]+$/);\n    }\n\n    dateValidator(): ValidatorFn {\n        return Validators.pattern(\n            /^(?:(0[1-9]|1[012])[\\/.](0[1-9]|[12][0-9]|3[01])[\\/.](19|20)[0-9]{2})$/\n        );\n    }\n\n    numberValidator(): ValidatorFn {\n        return Validators.pattern(/^[0-9]*$/);\n    }\n\n    /*\n        RegExp functions\n    */\n    validateNumber(value: string, allowDecimal: boolean): string {\n        // choose the appropiate regular expression\n        let regex: string;\n\n        if (allowDecimal) {\n            regex = this.decimalSigned;\n        } else {\n            regex = this.integerSigned;\n        }\n\n        // when a numbers begins with a decimal separator,\n        // fix it adding a zero in the beginning\n        const firstCharacter = value.charAt(0);\n        if (firstCharacter == this.decimalSeparator) value = 0 + value;\n\n        // when a numbers ends with a decimal separator,\n        // fix it adding a zero in the end\n        const lastCharacter = value.charAt(value.length - 1);\n        if (lastCharacter == this.decimalSeparator) value = value + 0;\n\n        // test number with regular expression, when\n        // number is invalid, replace it with a zero\n        // console.log(`regex is ${regex} and value is ${value}`);\n        const valid: boolean = new RegExp(regex).test(value);\n\n        return valid ? value : null;\n    }\n\n    validatePhone(value: string): boolean {\n        // test phone with regular expression\n        const valid: boolean = new RegExp(this.phone).test(value);\n        return valid;\n    }\n\n    private getName(e): string {\n        if (e.key) {\n            return e.key;\n        } else {\n            // for old browsers\n            if (e.keyCode && String.fromCharCode) {\n                switch (e.keyCode) {\n                    case 8:\n                        return 'Backspace';\n                    case 9:\n                        return 'Tab';\n                    case 27:\n                        return 'Escape';\n                    case 37:\n                        return 'ArrowLeft';\n                    case 39:\n                        return 'ArrowRight';\n                    case 188:\n                        return ',';\n                    case 190:\n                        return '.';\n                    case 109:\n                        return '-'; // minus in numbpad\n                    case 173:\n                        return '-'; // minus in alphabet keyboard in firefox\n                    case 189:\n                        return '-'; // minus in alphabet keyboard in chrome\n                    default:\n                        return String.fromCharCode(e.keyCode);\n                }\n            }\n        }\n    }\n\n    private allowKeyboardNonNumericCharacters(\n        allowedKeys: Array<string>,\n        key: string,\n        controlOrCommand: boolean\n    ): boolean {\n        const defaultAllowedKeys = [\n            'Backspace',\n            'ArrowLeft',\n            'ArrowRight',\n            'Escape',\n            'Tab',\n            'Home',\n            'End',\n            'Delete',\n        ];\n\n        // allow some non-numeric characters\n        if (\n            defaultAllowedKeys.indexOf(key) != -1 ||\n            allowedKeys.indexOf(key) != -1 ||\n            // Allow: Ctrl+A and Command+A\n            (key == 'a' && controlOrCommand) ||\n            // Allow: Ctrl+C and Command+C\n            (key == 'c' && controlOrCommand) ||\n            // Allow: Ctrl+V and Command+V\n            (key == 'v' && controlOrCommand) ||\n            // Allow: Ctrl+X and Command+X\n            (key == 'x' && controlOrCommand) ||\n            key.startsWith('F')\n        ) {\n            // let it happen, don't do anything\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    isPhone(e: KeyboardEvent): boolean {\n        const key: string = this.getName(e);\n        const controlOrCommand = e.ctrlKey === true || e.metaKey === true;\n\n        // allowed keys apart from numeric characters\n        const allowedKeys = ['.', '-', '+', '(', ')', '*', '#'];\n\n        // allow some non-numeric characters\n        if (\n            this.allowKeyboardNonNumericCharacters(\n                allowedKeys,\n                key,\n                controlOrCommand\n            )\n        ) {\n            return true;\n        }\n\n        // allow phone characters only\n        const isPhone = new RegExp(this.phone).test(key);\n        return isPhone;\n    }\n\n    isNumber(e: KeyboardEvent, allowDecimal: boolean): boolean {\n        const cursorPosition: number = e.target['selectionStart'];\n        const originalValue: string = e.target['value'];\n        const key: string = this.getName(e);\n        const controlOrCommand = e.ctrlKey === true || e.metaKey === true;\n        const signExists = originalValue.includes('-');\n        const separatorExists = originalValue.includes(this.decimalSeparator);\n\n        // allowed keys apart from numeric characters\n        const allowedKeys = [];\n\n        // when decimals are allowed, add\n        // decimal separator to allowed codes when\n        // its position is not close to the the sign (-. and .-)\n        const separatorIsCloseToSign = signExists && cursorPosition <= 1;\n        if (allowDecimal && !separatorIsCloseToSign && !separatorExists) {\n            if (this.decimalSeparator == '.') allowedKeys.push('.');\n            else allowedKeys.push(',');\n        }\n\n        // when minus sign is allowed, add its\n        // key to allowed key only when the\n        // cursor is in the first position, and\n        // first character is different from\n        // decimal separator\n        const firstCharacterIsSeparator =\n            originalValue.charAt(0) != this.decimalSeparator;\n        if (!signExists && firstCharacterIsSeparator && cursorPosition == 0) {\n            allowedKeys.push('-');\n        }\n\n        // allow some non-numeric characters\n        if (\n            this.allowKeyboardNonNumericCharacters(\n                allowedKeys,\n                key,\n                controlOrCommand\n            )\n        ) {\n            return true;\n        }\n\n        // allow number characters only\n        const isNumber = new RegExp(this.integerUnsigned).test(key);\n        return isNumber;\n    }\n}\n"]}

package/esm2022/core/common/services/window-scrolling.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PepWindowScrollingService {
+    // Inject a STYLE element for overrides the scroll behavior, this way we can add | remove it in order to the behavior.
+    styleTag;
+    constructor() {
+        this.styleTag = this.buildStyleElement();
+    }
+    // Disable the scrolling feature on the main viewport.
+    disable() {
+        document.body.appendChild(this.styleTag);
+    }
+    // Re-enable the scrolling feature on the main viewport.
+    enable() {
+        document.body.removeChild(this.styleTag);
+    }
+    // Return a Style element that will prevent scrolling on the body.
+    buildStyleElement() {
+        const style = document.createElement('style');
+        style.type = 'text/css';
+        style.setAttribute('data-debug', 'Injected by WindowScrolling service.');
+        style.textContent = `
+            body {
+                overflow: hidden !important ;
+            }
+        `;
+        return style;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepWindowScrollingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepWindowScrollingService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepWindowScrollingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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