ngx-mask 16.4.0 → 16.4.2

package/fesm2022/ngx-mask.mjs

@@ -116,6 +116,7 @@ class NgxMaskApplierService {
         this.outputTransformFn = this._config.outputTransformFn;
         this.keepCharacterPositions = this._config.keepCharacterPositions;
         this._shift = new Set();
+        this.plusOnePosition = false;
         this.maskExpression = '';
         this.actualValue = '';
         this.showKeepCharacterExp = '';
@@ -222,7 +223,7 @@ class NgxMaskApplierService {
         let backspaceShift = false;
         let shift = 1;
         let stepBack = false;
-        if (inputValue.slice(0, this.prefix.length) === this.prefix && !this.showMaskTyped) {
+        if (inputValue.slice(0, this.prefix.length) === this.prefix) {
             // eslint-disable-next-line no-param-reassign
             inputValue = inputValue.slice(this.prefix.length, inputValue.length);
         }
@@ -306,24 +307,91 @@ class NgxMaskApplierService {
                 // eslint-disable-next-line no-param-reassign
                 inputValue = this._stripToDecimal(inputValue);
             }
-            // eslint-disable-next-line no-param-reassign
-            inputValue =
-                inputValue[0] === '-' && this.allowNegativeNumbers
+            const precision = this.getPrecision(maskExpression);
+            const decimalMarker = Array.isArray(this.decimalMarker)
+                ? "." /* MaskExpression.DOT */
+                : this.decimalMarker;
+            if (precision === 0) {
+                // eslint-disable-next-line no-param-reassign
+                inputValue = this.allowNegativeNumbers
                     ? inputValue.length > 2 &&
-                        inputValue[1] === '0' &&
+                        inputValue[0] === "-" /* MaskExpression.MINUS */ &&
+                        inputValue[1] === "0" /* MaskExpression.NUMBER_ZERO */ &&
                         inputValue[2] !== this.thousandSeparator &&
-                        !this._compareOrIncludes(inputValue[2], this.decimalMarker, this.thousandSeparator) &&
-                        !backspaced
-                        ? inputValue.slice(0, inputValue.length - 1)
-                        : inputValue
+                        inputValue[2] !== "," /* MaskExpression.COMMA */ &&
+                        inputValue[2] !== "." /* MaskExpression.DOT */
+                        ? '-' + inputValue.slice(2, inputValue.length)
+                        : inputValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                            inputValue.length > 1 &&
+                            inputValue[1] !== this.thousandSeparator &&
+                            inputValue[1] !== "," /* MaskExpression.COMMA */ &&
+                            inputValue[1] !== "." /* MaskExpression.DOT */
+                            ? inputValue.slice(1, inputValue.length)
+                            : inputValue
                     : inputValue.length > 1 &&
-                        inputValue[0] === '0' &&
+                        inputValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
                         inputValue[1] !== this.thousandSeparator &&
-                        !this._compareOrIncludes(inputValue[1], this.decimalMarker, this.thousandSeparator) &&
-                        !backspaced
-                        ? inputValue.slice(0, inputValue.length - 1)
+                        inputValue[1] !== "," /* MaskExpression.COMMA */ &&
+                        inputValue[1] !== "." /* MaskExpression.DOT */
+                        ? inputValue.slice(1, inputValue.length)
                         : inputValue;
+            }
+            else {
+                // eslint-disable-next-line no-param-reassign
+                if (inputValue[0] === decimalMarker && inputValue.length > 1) {
+                    // eslint-disable-next-line no-param-reassign
+                    inputValue =
+                        "0" /* MaskExpression.NUMBER_ZERO */ + inputValue.slice(0, inputValue.length + 1);
+                    this.plusOnePosition = true;
+                }
+                if (inputValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                    inputValue[1] !== decimalMarker &&
+                    inputValue[1] !== this.thousandSeparator) {
+                    // eslint-disable-next-line no-param-reassign
+                    inputValue =
+                        inputValue.length > 1
+                            ? inputValue.slice(0, 1) +
+                                decimalMarker +
+                                inputValue.slice(1, inputValue.length + 1)
+                            : inputValue;
+                    this.plusOnePosition = true;
+                }
+                if (this.allowNegativeNumbers &&
+                    inputValue[0] === "-" /* MaskExpression.MINUS */ &&
+                    (inputValue[1] === decimalMarker ||
+                        inputValue[1] === "0" /* MaskExpression.NUMBER_ZERO */)) {
+                    // eslint-disable-next-line no-param-reassign
+                    inputValue =
+                        inputValue[1] === decimalMarker && inputValue.length > 2
+                            ? inputValue.slice(0, 1) +
+                                "0" /* MaskExpression.NUMBER_ZERO */ +
+                                inputValue.slice(1, inputValue.length)
+                            : inputValue[1] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                                inputValue.length > 2 &&
+                                inputValue[2] !== decimalMarker
+                                ? inputValue.slice(0, 2) +
+                                    decimalMarker +
+                                    inputValue.slice(2, inputValue.length)
+                                : inputValue;
+                    this.plusOnePosition = true;
+                }
+            }
             if (backspaced) {
+                if (inputValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                    inputValue[1] === this.decimalMarker &&
+                    (inputValue[position] === "0" /* MaskExpression.NUMBER_ZERO */ ||
+                        inputValue[position] === this.decimalMarker)) {
+                    // eslint-disable-next-line no-param-reassign
+                    inputValue = inputValue.slice(2, inputValue.length);
+                }
+                if (inputValue[0] === "-" /* MaskExpression.MINUS */ &&
+                    inputValue[1] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                    inputValue[2] === this.decimalMarker &&
+                    (inputValue[position] === "0" /* MaskExpression.NUMBER_ZERO */ ||
+                        inputValue[position] === this.decimalMarker)) {
+                    // eslint-disable-next-line no-param-reassign
+                    inputValue = "-" /* MaskExpression.MINUS */ + inputValue.slice(3, inputValue.length);
+                }
                 // eslint-disable-next-line no-param-reassign
                 inputValue = this._compareOrIncludes(inputValue[inputValue.length - 1], this.decimalMarker, this.thousandSeparator)
                     ? inputValue.slice(0, inputValue.length - 1)
@@ -343,13 +411,10 @@ class NgxMaskApplierService {
                 invalidChars = invalidChars.replace(this._charToRegExpExpression(this.decimalMarker), '');
             }
             const invalidCharRegexp = new RegExp('[' + invalidChars + ']');
-            if (inputValue.match(invalidCharRegexp) ||
-                (inputValue.length === 1 &&
-                    this._compareOrIncludes(inputValue, this.decimalMarker, this.thousandSeparator))) {
+            if (inputValue.match(invalidCharRegexp)) {
                 // eslint-disable-next-line no-param-reassign
                 inputValue = inputValue.substring(0, inputValue.length - 1);
             }
-            const precision = this.getPrecision(maskExpression);
             // eslint-disable-next-line no-param-reassign
             inputValue = this.checkInputPrecision(inputValue, precision, this.decimalMarker);
             const strForSep = inputValue.replace(new RegExp(thousandSeparatorCharEscaped, 'g'), '');
@@ -647,7 +712,7 @@ class NgxMaskApplierService {
         if (backspaced) {
             onlySpecial = inputArray.every((char) => this.specialCharacters.includes(char));
         }
-        let res = `${this.prefix}${onlySpecial ? "" /* MaskExpression.EMPTY_STRING */ : result}${this.suffix}`;
+        let res = `${this.prefix}${onlySpecial ? "" /* MaskExpression.EMPTY_STRING */ : result}${this.showMaskTyped ? '' : this.suffix}`;
         if (result.length === 0) {
             res = !this.dropSpecialCharacters ? `${this.prefix}${result}` : `${result}`;
         }
@@ -789,7 +854,7 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         if (!inputValue && this.showMaskTyped) {
             this.formControlResult(this.prefix);
-            return this.prefix + this.maskIsShown;
+            return this.prefix + this.maskIsShown + this.suffix;
         }
         const getSymbol = !!inputValue && typeof this.selStart === 'number'
             ? inputValue[this.selStart] ?? "" /* MaskExpression.EMPTY_STRING */
@@ -908,7 +973,7 @@ class NgxMaskService extends NgxMaskApplierService {
             return result;
         }
         const resLen = result.length;
-        const prefNmask = this.prefix + this.maskIsShown;
+        const prefNmask = this.prefix + this.maskIsShown + this.suffix;
         if (this.maskExpression.includes("H" /* MaskExpression.HOURS */)) {
             const countSkipedSymbol = this._numberSkipedSymbols(result);
             return result + prefNmask.slice(resLen + countSkipedSymbol);
@@ -1228,7 +1293,8 @@ class NgxMaskService extends NgxMaskApplierService {
             : this.specialCharacters;
         if (!this.deletedSpecialCharacter &&
             this._checkPatternForSpace() &&
-            result.includes(" " /* MaskExpression.WHITE_SPACE */)) {
+            result.includes(" " /* MaskExpression.WHITE_SPACE */) &&
+            this.maskExpression.includes("*" /* MaskExpression.SYMBOL_STAR */)) {
             specialCharacters = specialCharacters.filter((char) => char !== " " /* MaskExpression.WHITE_SPACE */);
         }
         return this._removeMask(result, specialCharacters);
@@ -1434,12 +1500,6 @@ class NgxMaskDirective {
                 this._maskService.maskExpression = this._maskValue;
             }
         }
-        if (allowNegativeNumbers) {
-            this._maskService.allowNegativeNumbers = allowNegativeNumbers.currentValue;
-            if (this._maskService.allowNegativeNumbers) {
-                this._maskService.specialCharacters = this._maskService.specialCharacters.filter((c) => c !== "-" /* MaskExpression.MINUS */);
-            }
-        }
         if (specialCharacters) {
             if (!specialCharacters.currentValue || !Array.isArray(specialCharacters.currentValue)) {
                 return;
@@ -1448,6 +1508,12 @@ class NgxMaskDirective {
                 this._maskService.specialCharacters = specialCharacters.currentValue || [];
             }
         }
+        if (allowNegativeNumbers) {
+            this._maskService.allowNegativeNumbers = allowNegativeNumbers.currentValue;
+            if (this._maskService.allowNegativeNumbers) {
+                this._maskService.specialCharacters = this._maskService.specialCharacters.filter((c) => c !== "-" /* MaskExpression.MINUS */);
+            }
+        }
         // Only overwrite the mask available patterns if a pattern has actually been passed in
         if (patterns && patterns.currentValue) {
             this._maskService.patterns = patterns.currentValue;
@@ -1744,13 +1810,33 @@ class NgxMaskDirective {
                             position = position + 1;
                         }
                         else if (checkSymbols) {
+                            if (el.value.length === 1 && position === 1) {
+                                this._maskService.actualValue =
+                                    this.prefix +
+                                        inputSymbol +
+                                        this._maskService.maskIsShown.slice(1, this._maskService.maskIsShown.length) +
+                                        this.suffix;
+                            }
+                            else {
+                                this._maskService.actualValue =
+                                    el.value.slice(0, position - 1) +
+                                        inputSymbol +
+                                        el.value
+                                            .slice(position + 1)
+                                            .split(this.suffix)
+                                            .join('') +
+                                        this.suffix;
+                            }
+                        }
+                        else if (this.prefix &&
+                            el.value.length === 1 &&
+                            position - prefixLength === 1 &&
+                            this._maskService._checkSymbolMask(el.value, this._maskService.maskExpression[position - 1 - prefixLength] ??
+                                "" /* MaskExpression.EMPTY_STRING */)) {
                             this._maskService.actualValue =
-                                el.value.slice(0, position - 1) +
-                                    inputSymbol +
-                                    el.value
-                                        .slice(position + 1)
-                                        .split(this.suffix)
-                                        .join('') +
+                                this.prefix +
+                                    el.value +
+                                    this._maskService.maskIsShown.slice(1, this._maskService.maskIsShown.length) +
                                     this.suffix;
                         }
                     }
@@ -1770,6 +1856,13 @@ class NgxMaskDirective {
                             inputSymbol +
                             this._inputValue.slice(position + 1);
                 }
+                if (this._maskService.maskExpression === "d0/M0/0000" /* MaskExpression.DAYS_MONTHS_YEARS */ &&
+                    this.leadZeroDateTime) {
+                    if ((position < 3 && Number(el.value) > 31 && Number(el.value) < 40) ||
+                        (position === 5 && Number(el.value.slice(3, 5)) > 12)) {
+                        position = position + 2;
+                    }
+                }
                 if (this._maskService.maskExpression === "Hh:m0:s0" /* MaskExpression.HOURS_MINUTES_SECONDS */ &&
                     this.apm) {
                     if (this._justPasted && el.value.slice(0, 2) === "00" /* MaskExpression.DOUBLE_ZERO */) {
@@ -1789,6 +1882,10 @@ class NgxMaskDirective {
                 if (this._getActiveElement() !== el) {
                     return;
                 }
+                if (this._maskService.plusOnePosition) {
+                    position = position + 1;
+                    this._maskService.plusOnePosition = false;
+                }
                 // update position after applyValueChanges to prevent cursor on wrong position when it has an array of maskExpression
                 if (this._maskExpressionArray.length) {
                     if (this._code === "Backspace" /* MaskExpression.BACKSPACE */) {
@@ -1810,7 +1907,10 @@ class NgxMaskDirective {
                     : position +
                         (this._code === "Backspace" /* MaskExpression.BACKSPACE */ && !backspaceShift ? 0 : caretShift);
                 if (positionToApply > this._getActualInputLength()) {
-                    positionToApply = this._getActualInputLength();
+                    positionToApply =
+                        el.value === this._maskService.decimalMarker && el.value.length === 1
+                            ? this._getActualInputLength() + 1
+                            : this._getActualInputLength();
                 }
                 if (positionToApply < 0) {
                     positionToApply = 0;
@@ -1823,6 +1923,10 @@ class NgxMaskDirective {
             }
         }
         else {
+            if (!this._maskValue) {
+                this.onChange(el.value);
+                return;
+            }
             this._maskService.applyValueChanges(el.value.length, this._justPasted, this._code === "Backspace" /* MaskExpression.BACKSPACE */ || this._code === "Delete" /* MaskExpression.DELETE */);
         }
     }
@@ -2010,7 +2114,7 @@ class NgxMaskDirective {
             typeof controlValue === 'number' ||
             controlValue === null ||
             controlValue === undefined) {
-            if (controlValue === null || controlValue === undefined) {
+            if (controlValue === null || controlValue === undefined || controlValue === '') {
                 this._maskService._currentValue = '';
                 this._maskService._previousValue = '';
             }
@@ -2165,7 +2269,8 @@ class NgxMaskDirective {
                 }
             }
             else {
-                const check = this._inputValue
+                const check = this._maskService
+                    .removeMask(this._inputValue)
                     ?.split("" /* MaskExpression.EMPTY_STRING */)
                     .every((character, index) => {
                     const indexMask = mask.charAt(index);