ngx-mask-2
Version:
awesome ngx mask
831 lines (821 loc) • 85.9 kB
JavaScript
import { InjectionToken, Inject, Injectable, ElementRef, Renderer2, Directive, forwardRef, HostListener, Input, Pipe, NgModule } from '@angular/core';
import { DOCUMENT } from '@angular/common';
import { __awaiter } from 'tslib';
import { NG_VALUE_ACCESSOR } from '@angular/forms';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/** @type {?} */
const config = new InjectionToken('config');
/** @type {?} */
const NEW_CONFIG = new InjectionToken('NEW_CONFIG');
/** @type {?} */
const INITIAL_CONFIG = new InjectionToken('INITIAL_CONFIG');
/** @type {?} */
const initialConfig = {
sufix: '',
prefix: '',
clearIfNotMatch: false,
showTemplate: false,
showMaskTyped: false,
dropSpecialCharacters: true,
specialCharacters: ['/', '(', ')', '.', ':', '-', ' ', '+', ',', '@', '[', ']', '\"', '\''],
appendPrefixToModel: false,
patterns: {
'0': {
pattern: new RegExp('\\d'),
},
'9': {
pattern: new RegExp('\\d'),
optional: true
},
'A': {
pattern: new RegExp('\[a-zA-Z0-9\]')
},
'S': {
pattern: new RegExp('\[a-zA-Z\]')
},
'd': {
pattern: new RegExp('\\d'),
},
'm': {
pattern: new RegExp('\\d'),
},
}
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class MaskApplierService {
/**
* @param {?} _config
*/
constructor(_config) {
this._config = _config;
this.maskExpression = '';
this._shift = new Set();
this.maskSpecialCharacters = /** @type {?} */ ((this._config)).specialCharacters;
this.maskAvailablePatterns = this._config.patterns;
this.clearIfNotMatch = this._config.clearIfNotMatch;
this.dropSpecialCharacters = this._config.dropSpecialCharacters;
this.maskSpecialCharacters = /** @type {?} */ ((this._config)).specialCharacters;
this.maskAvailablePatterns = this._config.patterns;
this.prefix = this._config.prefix;
this.sufix = this._config.sufix;
this.appendPrefixToModel = this._config.appendPrefixToModel;
}
/**
* @param {?} inputValue
* @param {?} maskAndPattern
* @return {?}
*/
applyMaskWithPattern(inputValue, maskAndPattern) {
const [mask, customPattern] = maskAndPattern;
this.customPattern = customPattern;
return this.applyMask(inputValue, mask);
}
/**
* @param {?} inputValue
* @param {?} maskExpression
* @param {?=} position
* @param {?=} cb
* @return {?}
*/
applyMask(inputValue, maskExpression, position = 0, cb = () => { }) {
if (inputValue === undefined || inputValue === null || maskExpression === undefined) {
return '';
}
/** @type {?} */
let cursor = 0;
/** @type {?} */
let result = ``;
/** @type {?} */
let multi = false;
if (inputValue.slice(0, this.prefix.length) === this.prefix) {
inputValue = inputValue.slice(this.prefix.length, inputValue.length);
}
/** @type {?} */
const inputArray = inputValue.toString()
.split('');
// tslint:disable-next-line
for (let i = 0, inputSymbol = inputArray[0]; i
< inputArray.length; i++, inputSymbol = inputArray[i]) {
if (cursor === maskExpression.length) {
break;
}
if (this._checkSymbolMask(inputSymbol, maskExpression[cursor]) && maskExpression[cursor + 1] === '?') {
result += inputSymbol;
cursor += 2;
}
else if (maskExpression[cursor + 1] === '*' && multi
&& this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2])) {
result += inputSymbol;
cursor += 3;
multi = false;
}
else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor])
&& maskExpression[cursor + 1]
=== '*') {
result += inputSymbol;
multi = true;
}
else if (maskExpression[cursor + 1] === '?' && this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2])) {
result += inputSymbol;
cursor += 3;
}
else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor])) {
if (maskExpression[cursor] === 'd') {
if (Number(inputSymbol) > 3) {
result += 0;
cursor += 1;
/** @type {?} */
const shiftStep = /\*|\?/g.test(maskExpression.slice(0, cursor))
? inputArray.length
: cursor;
this._shift.add(shiftStep + this.prefix.length || 0);
i--;
continue;
}
}
if (maskExpression[cursor - 1] === 'd') {
if (Number(inputValue.slice(cursor - 1, cursor + 1)) > 31) {
continue;
}
}
if (maskExpression[cursor] === 'm') {
if (Number(inputSymbol) > 1) {
result += 0;
cursor += 1;
/** @type {?} */
const shiftStep = /\*|\?/g.test(maskExpression.slice(0, cursor))
? inputArray.length
: cursor;
this._shift.add(shiftStep + this.prefix.length || 0);
i--;
continue;
}
}
if (maskExpression[cursor - 1] === 'm') {
if (Number(inputValue.slice(cursor - 1, cursor + 1)) > 12) {
continue;
}
}
result += inputSymbol;
cursor++;
}
else if (this.maskSpecialCharacters.indexOf(maskExpression[cursor]) !== -1) {
result += maskExpression[cursor];
cursor++;
/** @type {?} */
const shiftStep = /\*|\?/g.test(maskExpression.slice(0, cursor))
? inputArray.length
: cursor;
this._shift.add(shiftStep + this.prefix.length || 0);
i--;
}
else if (this.maskSpecialCharacters.indexOf(inputSymbol) > -1
&& this.maskAvailablePatterns[maskExpression[cursor]]
&& this.maskAvailablePatterns[maskExpression[cursor]].optional) {
cursor++;
i--;
}
else if ((this.maskExpression[cursor + 1] === '*')
&& (this._findSpecialChar(this.maskExpression[cursor + 2]))
&& (this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2])) {
cursor += 3;
result += inputSymbol;
}
}
if (result.length + 1 === maskExpression.length
&& this.maskSpecialCharacters.indexOf(maskExpression[maskExpression.length - 1]) !== -1) {
result += maskExpression[maskExpression.length - 1];
}
/** @type {?} */
let shift = 1;
/** @type {?} */
let newPosition = position + 1;
while (this._shift.has(newPosition)) {
shift++;
newPosition++;
}
cb(this._shift.has(position) ? shift : 0);
/** @type {?} */
let res = `${this.prefix}${result}`;
res = this.sufix &&
cursor === maskExpression.length
? `${this.prefix}${result}${this.sufix}`
: `${this.prefix}${result}`;
return res;
}
/**
* @param {?} inputSymbol
* @return {?}
*/
_findSpecialChar(inputSymbol) {
/** @type {?} */
const symbol = this.maskSpecialCharacters
.find((val) => val === inputSymbol);
return symbol;
}
/**
* @param {?} inputSymbol
* @param {?} maskSymbol
* @return {?}
*/
_checkSymbolMask(inputSymbol, maskSymbol) {
this.maskAvailablePatterns = this.customPattern
? this.customPattern
: this.maskAvailablePatterns;
return this.maskAvailablePatterns[maskSymbol]
&& this.maskAvailablePatterns[maskSymbol].pattern
&& this.maskAvailablePatterns[maskSymbol].pattern.test(inputSymbol);
}
}
MaskApplierService.decorators = [
{ type: Injectable }
];
/** @nocollapse */
MaskApplierService.ctorParameters = () => [
{ type: undefined, decorators: [{ type: Inject, args: [config,] }] }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class MaskService extends MaskApplierService {
/**
* @param {?} document
* @param {?} _config
* @param {?} _elementRef
* @param {?} _renderer
*/
constructor(
// tslint:disable-next-line
document, _config, _elementRef, _renderer) {
super(_config);
this.document = document;
this._config = _config;
this._elementRef = _elementRef;
this._renderer = _renderer;
this.maskExpression = '';
this.isNumberValue = false;
this.showMaskTyped = false;
this.maskIsShown = '';
this.onChange = (_) => { };
this.onTouch = () => { };
this._formElement = this._elementRef.nativeElement;
}
/**
* @param {?} inputValue
* @param {?} maskExpression
* @param {?=} position
* @param {?=} cb
* @return {?}
*/
applyMask(inputValue, maskExpression, position = 0, cb = () => { }) {
this.maskIsShown = this.showMaskTyped
? this.maskExpression.replace(/[0-9]/g, '_')
: '';
if (!inputValue && this.showMaskTyped) {
return this.prefix + this.maskIsShown;
}
/** @type {?} */
const result = super.applyMask(inputValue, maskExpression, position, cb);
/** @type {?} */
let finalResult = Array.isArray(this.dropSpecialCharacters)
? (this._removeMask(this._removeSufix((this.appendPrefixToModel ? result : this._removePrefix(result))), this.dropSpecialCharacters))
: (this.dropSpecialCharacters === true
? (this.isNumberValue
? Number(this._removeMask(this._removeSufix((this.appendPrefixToModel ? result : this._removePrefix(result))), this.maskSpecialCharacters))
: this._removeMask(this._removeSufix((this.appendPrefixToModel ? result : this._removePrefix(result))), this.maskSpecialCharacters))
: (this._removeSufix((this.appendPrefixToModel ? result : this._removePrefix(result)))));
if (this.prefix === finalResult || this.prefix.replace(' ', '') === finalResult
|| this._removeMask(this.prefix, this.maskSpecialCharacters) === finalResult) {
finalResult = '';
}
this.onChange(finalResult);
/** @type {?} */
let ifMaskIsShown = '';
if (!this.showMaskTyped) {
return result;
}
/** @type {?} */
const resLen = result.length;
/** @type {?} */
const prefNmask = this.prefix + this.maskIsShown;
ifMaskIsShown = prefNmask.slice(resLen);
return result + ifMaskIsShown;
}
/**
* @param {?=} position
* @param {?=} cb
* @return {?}
*/
applyValueChanges(position = 0, cb = () => { }) {
/** @type {?} */
const maskedInput = this.applyMask(this._formElement.value, this.maskExpression, position, cb);
this._formElement.value = maskedInput;
if (this._formElement === this.document.activeElement) {
return;
}
this.clearIfNotMatchFn();
}
/**
* @return {?}
*/
showMaskInInput() {
if (this.showMaskTyped) {
this.maskIsShown = this.maskExpression.replace(/[0-9]/g, '_');
}
}
/**
* @return {?}
*/
clearIfNotMatchFn() {
if (this.clearIfNotMatch === true &&
this.maskExpression.length !== this._formElement.value.length) {
this.formElementProperty = ['value', ''];
this.applyMask(this._formElement.value, this.maskExpression);
}
}
/**
* @param {?} __0
* @return {?}
*/
set formElementProperty([name, value]) {
this._renderer.setProperty(this._formElement, name, value);
}
/**
* @param {?} value
* @param {?} specialCharactersForRemove
* @return {?}
*/
_removeMask(value, specialCharactersForRemove) {
return value
? value.replace(this._regExpForRemove(specialCharactersForRemove), '')
: value;
}
/**
* @param {?} value
* @return {?}
*/
_removePrefix(value) {
if (!this.prefix) {
return value;
}
return value
? value.replace(this.prefix, '')
: value;
}
/**
* @param {?} value
* @return {?}
*/
_removeSufix(value) {
if (!this.sufix) {
return value;
}
return value
? value.replace(this.sufix, '')
: value;
}
/**
* @param {?} specialCharactersForRemove
* @return {?}
*/
_regExpForRemove(specialCharactersForRemove) {
return new RegExp(specialCharactersForRemove.map((item) => `\\${item}`).join('|'), 'gi');
}
}
MaskService.decorators = [
{ type: Injectable }
];
/** @nocollapse */
MaskService.ctorParameters = () => [
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
{ type: undefined, decorators: [{ type: Inject, args: [config,] }] },
{ type: ElementRef },
{ type: Renderer2 }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class MaskDirective {
/**
* @param {?} document
* @param {?} _maskService
*/
constructor(
// tslint:disable-next-line
document, _maskService) {
this.document = document;
this._maskService = _maskService;
this._position = null;
this.onChange = (_) => { };
this.onTouch = () => { };
}
/**
* @param {?} value
* @return {?}
*/
set maskExpression(value) {
this._maskValue = value || '';
if (!this._maskValue) {
return;
}
this._maskService.maskExpression = this._repeatPatternSymbols(this._maskValue);
this._maskService.formElementProperty = [
'value',
this._maskService.applyMask(this._inputValue, this._maskService.maskExpression)
];
}
/**
* @param {?} value
* @return {?}
*/
set specialCharacters(value) {
if (!value ||
!Array.isArray(value) ||
(Array.isArray(value) && !value.length)) {
return;
}
this._maskService.maskSpecialCharacters = value;
}
/**
* @param {?} value
* @return {?}
*/
set patterns(value) {
if (!value) {
return;
}
this._maskService.maskAvailablePatterns = value;
}
/**
* @param {?} value
* @return {?}
*/
set prefix(value) {
if (!value) {
return;
}
this._maskService.prefix = value;
}
/**
* @param {?} value
* @return {?}
*/
set sufix(value) {
if (!value) {
return;
}
this._maskService.sufix = value;
}
/**
* @param {?} value
* @return {?}
*/
set dropSpecialCharacters(value) {
this._maskService.dropSpecialCharacters = value;
}
/**
* @param {?} value
* @return {?}
*/
set showMaskTyped(value) {
if (!value) {
return;
}
this._maskService.showMaskTyped = value;
}
/**
* @param {?} value
* @return {?}
*/
set showTemplate(value) {
this._maskService.showTemplate = value;
}
/**
* @param {?} value
* @return {?}
*/
set clearIfNotMatch(value) {
this._maskService.clearIfNotMatch = value;
}
/**
* @param {?} value
* @return {?}
*/
set appendPrefixToModel(value) {
this._maskService.appendPrefixToModel = value;
}
/**
* @param {?} e
* @return {?}
*/
onInput(e) {
/** @type {?} */
const el = /** @type {?} */ (e.target);
this._inputValue = el.value;
if (!this._maskValue) {
this.onChange(el.value);
return;
}
/** @type {?} */
const position = (/** @type {?} */ (el.selectionStart)) === 1
? (/** @type {?} */ (el.selectionStart)) + this._maskService.prefix.length
: /** @type {?} */ (el.selectionStart);
/** @type {?} */
let caretShift = 0;
this._maskService.applyValueChanges(position, (shift) => (caretShift = shift));
// only set the selection if the element is active
if (this.document.activeElement !== el) {
return;
}
el.selectionStart = el.selectionEnd =
this._position !== null
? this._position
: position +
// tslint:disable-next-line
((/** @type {?} */ (e)).inputType === 'deleteContentBackward' ? 0 : caretShift);
this._position = null;
}
/**
* @return {?}
*/
onBlur() {
this._maskService.clearIfNotMatchFn();
this.onTouch();
}
/**
* @param {?} e
* @return {?}
*/
onFocus(e) {
/** @type {?} */
const el = /** @type {?} */ (e.target);
if (el !== null && el.selectionStart !== null &&
el.selectionStart === el.selectionEnd &&
el.selectionStart > this._maskService.prefix.length &&
// tslint:disable-next-line
(/** @type {?} */ (e)).keyCode !== 38) {
return;
}
if (this._maskService.showMaskTyped) {
this._maskService.maskIsShown = this._maskService.maskExpression.replace(/[0-9]/g, '_');
}
el.value = !el.value || el.value === this._maskService.prefix
? this._maskService.prefix + this._maskService.maskIsShown
: el.value;
/** fix of cursor position with prefix when mouse click occur */
if (((/** @type {?} */ (el.selectionStart)) || (/** @type {?} */ (el.selectionEnd))) <= this._maskService.prefix.length) {
el.selectionStart = this._maskService.prefix.length;
return;
}
}
/**
* @param {?} e
* @return {?}
*/
a(e) {
/** @type {?} */
const el = /** @type {?} */ (e.target);
if (e.keyCode === 38) {
e.preventDefault();
}
if (e.keyCode === 37 || e.keyCode === 8) {
if ((/** @type {?} */ (el.selectionStart)) <= this._maskService.prefix.length
&& (/** @type {?} */ (el.selectionEnd)) <= this._maskService.prefix.length) {
e.preventDefault();
}
this.onFocus(e);
if (e.keyCode === 8
&& el.selectionStart === 0
&& el.selectionEnd === el.value.length) {
el.value = this._maskService.prefix;
this._position = this._maskService.prefix ? this._maskService.prefix.length : 1;
this.onInput(e);
}
}
}
/**
* @return {?}
*/
onPaste() {
this._position = Number.MAX_SAFE_INTEGER;
}
/**
* It writes the value in the input
* @param {?} inputValue
* @return {?}
*/
writeValue(inputValue) {
return __awaiter(this, void 0, void 0, function* () {
if (inputValue === undefined) {
inputValue = '';
}
if (inputValue && inputValue.indexOf(this._maskService.prefix) === 0) {
inputValue = inputValue.replace(this._maskService.prefix, '');
}
if (inputValue && inputValue.indexOf(this._maskService.prefix.replace(' ', '')) === 0) {
inputValue = inputValue.replace(this._maskService.prefix.replace(' ', ''), '');
}
if (typeof inputValue === 'number') {
inputValue = String(inputValue);
this._maskService.isNumberValue = true;
}
inputValue && this._maskService.maskExpression ||
this._maskService.maskExpression && (this._maskService.prefix || this._maskService.showMaskTyped)
? (this._maskService.formElementProperty = [
'value',
this._maskService.applyMask(inputValue, this._maskService.maskExpression)
])
: (this._maskService.formElementProperty = ['value', inputValue]);
this._inputValue = inputValue;
});
}
/**
* @param {?} fn
* @return {?}
*/
registerOnChange(fn) {
this.onChange = fn;
this._maskService.onChange = this.onChange;
}
/**
* @param {?} fn
* @return {?}
*/
registerOnTouched(fn) {
this.onTouch = fn;
}
/**
* It disables the input element
* @param {?} isDisabled
* @return {?}
*/
setDisabledState(isDisabled) {
this._maskService.formElementProperty = ['disabled', isDisabled];
}
/**
* @param {?} maskExp
* @return {?}
*/
_repeatPatternSymbols(maskExp) {
return maskExp.match(/{[0-9a-zA-Z]}/)
&& maskExp.split('')
.reduce((accum, currval, index) => {
this._start = (currval === '{') ? index : this._start;
if (currval !== '}') {
return this._maskService._findSpecialChar(currval) ? accum + currval : accum;
}
this._end = index;
/** @type {?} */
const repeatNumber = Number(maskExp
.slice(this._start + 1, this._end));
/** @type {?} */
const repaceWith = new Array(repeatNumber + 1)
.join(maskExp[this._start - 1]);
return accum + repaceWith;
}, '') || maskExp;
}
}
MaskDirective.decorators = [
{ type: Directive, args: [{
selector: '[mask]',
providers: [
{
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => MaskDirective),
multi: true
},
MaskService
]
},] }
];
/** @nocollapse */
MaskDirective.ctorParameters = () => [
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
{ type: MaskService }
];
MaskDirective.propDecorators = {
maskExpression: [{ type: Input, args: ['mask',] }],
specialCharacters: [{ type: Input }],
patterns: [{ type: Input }],
prefix: [{ type: Input }],
sufix: [{ type: Input }],
dropSpecialCharacters: [{ type: Input }],
showMaskTyped: [{ type: Input }],
showTemplate: [{ type: Input }],
clearIfNotMatch: [{ type: Input }],
appendPrefixToModel: [{ type: Input }],
onInput: [{ type: HostListener, args: ['input', ['$event'],] }],
onBlur: [{ type: HostListener, args: ['blur',] }],
onFocus: [{ type: HostListener, args: ['click', ['$event'],] }],
a: [{ type: HostListener, args: ['keydown', ['$event'],] }],
onPaste: [{ type: HostListener, args: ['paste',] }]
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class MaskPipe {
/**
* @param {?} _maskService
*/
constructor(_maskService) {
this._maskService = _maskService;
}
/**
* @param {?} value
* @param {?} mask
* @return {?}
*/
transform(value, mask) {
if (!value) {
return '';
}
if (typeof mask === 'string') {
return this._maskService.applyMask(`${value}`, mask);
}
return this._maskService.applyMaskWithPattern(`${value}`, mask);
}
}
MaskPipe.decorators = [
{ type: Pipe, args: [{
name: 'mask',
pure: true
},] }
];
/** @nocollapse */
MaskPipe.ctorParameters = () => [
{ type: MaskApplierService }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class NgxMaskModule {
/**
* @param {?=} configValue
* @return {?}
*/
static forRoot(configValue) {
return {
ngModule: NgxMaskModule,
providers: [
{
provide: NEW_CONFIG,
useValue: configValue
},
{
provide: INITIAL_CONFIG,
useValue: initialConfig
},
{
provide: config,
useFactory: _configFactory,
deps: [INITIAL_CONFIG, NEW_CONFIG]
},
]
};
}
/**
* @param {?=} configValue
* @return {?}
*/
static forChild(configValue) {
return {
ngModule: NgxMaskModule,
};
}
}
NgxMaskModule.decorators = [
{ type: NgModule, args: [{
providers: [MaskApplierService],
exports: [MaskDirective, MaskPipe],
declarations: [MaskDirective, MaskPipe]
},] }
];
/**
* \@internal
* @param {?} initConfig
* @param {?} configValue
* @return {?}
*/
function _configFactory(initConfig, configValue) {
return (typeof configValue === 'function') ? configValue() : Object.assign({}, initConfig, configValue);
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
export { config, NEW_CONFIG, INITIAL_CONFIG, initialConfig, MaskDirective, MaskService, _configFactory, NgxMaskModule, MaskPipe, MaskApplierService as ɵa };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-mask-2.js.map","sources":["ng://ngx-mask-2/app/ngx-mask/config.ts","ng://ngx-mask-2/app/ngx-mask/mask-applier.service.ts","ng://ngx-mask-2/app/ngx-mask/mask.service.ts","ng://ngx-mask-2/app/ngx-mask/mask.directive.ts","ng://ngx-mask-2/app/ngx-mask/mask.pipe.ts","ng://ngx-mask-2/app/ngx-mask/ngx-mask.module.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\r\n\r\nexport interface IConfig {\r\n    sufix: string;\r\n    prefix: string;\r\n    clearIfNotMatch: boolean;\r\n    showTemplate: boolean;\r\n    showMaskTyped: boolean;\r\n    dropSpecialCharacters: boolean | string[];\r\n    specialCharacters: string[];\r\n    appendPrefixToModel: boolean;\r\n    patterns: {\r\n        [character: string]: {\r\n            pattern: RegExp,\r\n            optional?: boolean\r\n        }\r\n    };\r\n}\r\n\r\nexport type optionsConfig = Partial<IConfig>;\r\nexport const config: InjectionToken<string> = new InjectionToken('config');\r\nexport const NEW_CONFIG: InjectionToken<string> = new InjectionToken('NEW_CONFIG');\r\nexport const INITIAL_CONFIG: InjectionToken<IConfig> = new InjectionToken('INITIAL_CONFIG');\r\n\r\nexport const initialConfig: IConfig = {\r\n    sufix: '',\r\n    prefix: '',\r\n    clearIfNotMatch: false,\r\n    showTemplate: false,\r\n    showMaskTyped: false,\r\n    dropSpecialCharacters: true,\r\n    specialCharacters: ['/', '(', ')', '.', ':', '-', ' ', '+', ',', '@', '[', ']', '\\\"', '\\''],\r\n    appendPrefixToModel: false,\r\n    patterns: {\r\n        '0': {\r\n            pattern: new RegExp('\\\\d'),\r\n        },\r\n        '9': {\r\n            pattern: new RegExp('\\\\d'),\r\n            optional: true\r\n        },\r\n        'A': {\r\n            pattern: new RegExp('\\[a-zA-Z0-9\\]')\r\n        },\r\n        'S': {\r\n            pattern: new RegExp('\\[a-zA-Z\\]')\r\n        },\r\n        'd': {\r\n          pattern: new RegExp('\\\\d'),\r\n        },\r\n        'm': {\r\n          pattern: new RegExp('\\\\d'),\r\n        },\r\n    }\r\n};\r\n","import { Inject, Injectable } from '@angular/core';\r\nimport { config, IConfig } from './config';\r\n\r\n@Injectable()\r\nexport class MaskApplierService {\r\n\r\n    public dropSpecialCharacters: IConfig['dropSpecialCharacters'];\r\n    public showTemplate: IConfig['showTemplate'];\r\n    public clearIfNotMatch: IConfig['clearIfNotMatch'];\r\n    public maskExpression: string = '';\r\n    public maskSpecialCharacters: IConfig['specialCharacters'];\r\n    public maskAvailablePatterns: IConfig['patterns'];\r\n    public prefix: IConfig['prefix'];\r\n    public sufix: IConfig['sufix'];\r\n    public customPattern: IConfig['patterns'];\r\n    public appendPrefixToModel: IConfig['appendPrefixToModel'];\r\n\r\n\r\n    private _shift: Set<number>;\r\n\r\n    public constructor(\r\n        @Inject(config) protected _config: IConfig\r\n    ) {\r\n        this._shift = new Set();\r\n        this.maskSpecialCharacters = this._config!.specialCharacters;\r\n        this.maskAvailablePatterns = this._config.patterns;\r\n        this.clearIfNotMatch = this._config.clearIfNotMatch;\r\n        this.dropSpecialCharacters = this._config.dropSpecialCharacters;\r\n        this.maskSpecialCharacters = this._config!.specialCharacters;\r\n        this.maskAvailablePatterns = this._config.patterns;\r\n        this.prefix = this._config.prefix;\r\n        this.sufix = this._config.sufix;\r\n        this.appendPrefixToModel = this._config.appendPrefixToModel;\r\n\r\n    }\r\n    // tslint:disable-next-line:no-any\r\n    public applyMaskWithPattern(inputValue: string, maskAndPattern: [string, IConfig['patterns']]): string {\r\n      const [mask, customPattern] = maskAndPattern;\r\n      this.customPattern = customPattern;\r\n      return this.applyMask(inputValue, mask);\r\n    }\r\n    public applyMask(\r\n        inputValue: string,\r\n        maskExpression: string,\r\n        position: number = 0,\r\n        cb: Function = () => {}\r\n      ): string {\r\n        if (inputValue === undefined || inputValue === null || maskExpression === undefined) {\r\n            return '';\r\n        }\r\n\r\n        let cursor: number = 0;\r\n        let result: string = ``;\r\n        let multi: boolean = false;\r\n\r\n        if (inputValue.slice(0, this.prefix.length) === this.prefix) {\r\n            inputValue = inputValue.slice(this.prefix.length, inputValue.length);\r\n        }\r\n\r\n        const inputArray: string[] = inputValue.toString()\r\n            .split('');\r\n\r\n        // tslint:disable-next-line\r\n        for (let i: number = 0, inputSymbol: string = inputArray[0]; i\r\n        < inputArray.length; i++, inputSymbol = inputArray[i]) {\r\n            if (cursor === maskExpression.length) {\r\n                break;\r\n            }\r\n            if (this._checkSymbolMask(inputSymbol, maskExpression[cursor]) && maskExpression[cursor + 1] === '?') {\r\n                result += inputSymbol;\r\n                cursor += 2;\r\n            } else if (\r\n              maskExpression[cursor + 1] === '*' && multi\r\n              && this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2])\r\n            ) {\r\n              result += inputSymbol;\r\n              cursor += 3;\r\n              multi = false;\r\n            } else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor])\r\n                && maskExpression[cursor + 1]\r\n                === '*') {\r\n                result += inputSymbol;\r\n                multi = true;\r\n            } else if (maskExpression[cursor + 1] === '?' && this._checkSymbolMask(\r\n                inputSymbol,\r\n                maskExpression[cursor + 2]\r\n            )) {\r\n                result += inputSymbol;\r\n                cursor += 3;\r\n            } else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor])) {\r\n                if (maskExpression[cursor] === 'd') {\r\n                  if (Number(inputSymbol) > 3) {\r\n                    result += 0;\r\n                    cursor += 1;\r\n                    const shiftStep: number = /\\*|\\?/g.test(maskExpression.slice(0, cursor))\r\n                      ? inputArray.length\r\n                      : cursor;\r\n                    this._shift.add( shiftStep + this.prefix.length || 0);\r\n                    i--;\r\n                    continue;\r\n                  }\r\n                }\r\n              if (maskExpression[cursor - 1] === 'd') {\r\n                  if (Number(inputValue.slice(cursor - 1, cursor + 1)) > 31 ) {\r\n                    continue;\r\n                  }\r\n              }\r\n              if (maskExpression[cursor] === 'm') {\r\n                if (Number(inputSymbol) > 1) {\r\n                  result += 0;\r\n                  cursor += 1;\r\n                  const shiftStep: number = /\\*|\\?/g.test(maskExpression.slice(0, cursor))\r\n                    ? inputArray.length\r\n                    : cursor;\r\n                  this._shift.add( shiftStep + this.prefix.length || 0);\r\n                  i--;\r\n                  continue;\r\n                }\r\n              }\r\n              if (maskExpression[cursor - 1] === 'm') {\r\n                if (Number(inputValue.slice(cursor - 1, cursor + 1)) > 12 ) {\r\n                  continue;\r\n                }\r\n              }\r\n                result += inputSymbol;\r\n                cursor++;\r\n            } else if (this.maskSpecialCharacters.indexOf(maskExpression[cursor]) !== -1) {\r\n                result += maskExpression[cursor];\r\n                cursor++;\r\n                const shiftStep: number = /\\*|\\?/g.test(maskExpression.slice(0, cursor))\r\n                    ? inputArray.length\r\n                    : cursor;\r\n                this._shift.add(shiftStep + this.prefix.length || 0);\r\n                i--;\r\n            } else if (this.maskSpecialCharacters.indexOf(inputSymbol) > -1\r\n                && this.maskAvailablePatterns[maskExpression[cursor]]\r\n                && this.maskAvailablePatterns[maskExpression[cursor]].optional) {\r\n                cursor++;\r\n                i--;\r\n            } else if ( (this.maskExpression[cursor + 1] === '*')\r\n              && (this._findSpecialChar(this.maskExpression[cursor + 2]))\r\n              && (this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2]) ) {\r\n              cursor += 3;\r\n              result += inputSymbol;\r\n            }\r\n        }\r\n\r\n\r\n        if (result.length + 1 === maskExpression.length\r\n            && this.maskSpecialCharacters.indexOf(maskExpression[maskExpression.length - 1]) !== -1) {\r\n            result += maskExpression[maskExpression.length - 1];\r\n        }\r\n\r\n\r\n        let shift: number = 1;\r\n        let newPosition: number = position + 1;\r\n\r\n        while (this._shift.has(newPosition)) {\r\n            shift++;\r\n            newPosition++;\r\n        }\r\n\r\n        cb(this._shift.has(position) ? shift : 0);\r\n        let res: string = `${this.prefix}${result}`;\r\n        res = this.sufix &&\r\n              cursor === maskExpression.length\r\n            ? `${this.prefix}${result}${this.sufix}`\r\n            : `${this.prefix}${result}`;\r\n        return res;\r\n    }\r\n    public _findSpecialChar (inputSymbol: string): undefined | string {\r\n      const symbol: string | undefined = this.maskSpecialCharacters\r\n          .find( (val: string) => val === inputSymbol);\r\n      return symbol ;\r\n    }\r\n\r\n    private _checkSymbolMask(inputSymbol: string, maskSymbol: string): boolean {\r\n      this.maskAvailablePatterns = this.customPattern\r\n        ? this.customPattern\r\n        : this.maskAvailablePatterns;\r\n        return this.maskAvailablePatterns[maskSymbol]\r\n            && this.maskAvailablePatterns[maskSymbol].pattern\r\n            && this.maskAvailablePatterns[maskSymbol].pattern.test(inputSymbol);\r\n    }\r\n}\r\n","import { ElementRef, Inject, Injectable, Renderer2 } from '@angular/core';\r\nimport { config, IConfig } from './config';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { MaskApplierService } from './mask-applier.service';\r\n\r\n@Injectable()\r\nexport class MaskService extends MaskApplierService {\r\n  public maskExpression: string = '';\r\n  public isNumberValue: boolean = false;\r\n  public showMaskTyped: boolean = false;\r\n  public maskIsShown: string = '';\r\n  private _formElement: HTMLInputElement;\r\n  // tslint:disable-next-line\r\n  public onChange = (_: any) => {};\r\n  public onTouch = () => {};\r\n  public constructor(\r\n    // tslint:disable-next-line\r\n    @Inject(DOCUMENT) private document: any,\r\n    @Inject(config) protected _config: IConfig,\r\n    private _elementRef: ElementRef,\r\n    private _renderer: Renderer2\r\n  ) {\r\n    super(_config);\r\n    this._formElement = this._elementRef.nativeElement;\r\n  }\r\n\r\n  public applyMask(\r\n    inputValue: string,\r\n    maskExpression: string,\r\n    position: number = 0,\r\n    cb: Function = () => {}\r\n  ): string  {\r\n    this.maskIsShown = this.showMaskTyped\r\n        ? this.maskExpression.replace(/[0-9]/g, '_')\r\n        : '';\r\n    if (!inputValue && this.showMaskTyped) {\r\n      return this.prefix + this.maskIsShown;\r\n    }\r\n    const result: string  = super.applyMask(\r\n      inputValue,\r\n      maskExpression,\r\n      position,\r\n      cb\r\n    );\r\n\r\n    let finalResult: string | number = Array.isArray(this.dropSpecialCharacters)\r\n        ? (this._removeMask(this._removeSufix(\r\n        (this.appendPrefixToModel ? result : this._removePrefix(result))\r\n        ), this.dropSpecialCharacters))\r\n        : (this.dropSpecialCharacters === true\r\n         ? (\r\n         this.isNumberValue\r\n             ? Number(this._removeMask(this._removeSufix(\r\n             (this.appendPrefixToModel ? result : this._removePrefix(result))), this.maskSpecialCharacters))\r\n             : this._removeMask(this._removeSufix(\r\n             (this.appendPrefixToModel ? result : this._removePrefix(result))), this.maskSpecialCharacters)\r\n            )\r\n         : (this._removeSufix((this.appendPrefixToModel ? result : this._removePrefix(result)))));\r\n\r\n    if (this.prefix === finalResult || this.prefix.replace(' ', '') === finalResult\r\n        || this._removeMask(this.prefix, this.maskSpecialCharacters) === finalResult) {\r\n        finalResult = '';\r\n    }\r\n    this.onChange(finalResult);\r\n\r\n    let ifMaskIsShown: string = '';\r\n    if (!this.showMaskTyped) {\r\n        return result;\r\n    }\r\n    const resLen: number = result.length;\r\n    const prefNmask: string = this.prefix + this.maskIsShown;\r\n    ifMaskIsShown = prefNmask.slice(resLen);\r\n\r\n    return result + ifMaskIsShown;\r\n  }\r\n\r\n  public applyValueChanges(\r\n    position: number = 0,\r\n    cb: Function = () => {}\r\n  ): void {\r\n    const maskedInput: string | number = this.applyMask(\r\n      this._formElement.value,\r\n      this.maskExpression,\r\n      position,\r\n      cb\r\n    );\r\n\r\n    this._formElement.value = maskedInput;\r\n    if (this._formElement === this.document.activeElement) {\r\n      return;\r\n    }\r\n    this.clearIfNotMatchFn();\r\n  }\r\n\r\n  public showMaskInInput(): void {\r\n    if (this.showMaskTyped) {\r\n      this.maskIsShown = this.maskExpression.replace(/[0-9]/g, '_');\r\n    }\r\n  }\r\n\r\n  public clearIfNotMatchFn(): void {\r\n    if (\r\n      this.clearIfNotMatch === true &&\r\n      this.maskExpression.length !== this._formElement.value.length\r\n    ) {\r\n      this.formElementProperty = ['value', ''];\r\n      this.applyMask(this._formElement.value, this.maskExpression);\r\n    }\r\n  }\r\n\r\n  public set formElementProperty([name, value]: [string, string | boolean]) {\r\n    this._renderer.setProperty(this._formElement, name, value);\r\n  }\r\n\r\n  public _removeMask(\r\n    value: string,\r\n    specialCharactersForRemove: string[]\r\n  ): string {\r\n    return value\r\n      ? value.replace(this._regExpForRemove(specialCharactersForRemove), '')\r\n      : value;\r\n  }\r\n\r\n  public _removePrefix(value: string): string {\r\n    if (!this.prefix) {\r\n      return value;\r\n    }\r\n    return value\r\n      ? value.replace(this.prefix, '')\r\n      : value;\r\n  }\r\n\r\n  private _removeSufix(value: string): string {\r\n    if (!this.sufix) {\r\n      return value;\r\n    }\r\n    return value\r\n      ? value.replace(this.sufix, '')\r\n      : value;\r\n  }\r\n\r\n  private _regExpForRemove(specialCharactersForRemove: string[]): RegExp {\r\n    return new RegExp(\r\n      specialCharactersForRemove.map((item: string) => `\\\\${item}`).join('|'),\r\n      'gi'\r\n    );\r\n  }\r\n}\r\n","import {\r\n  Directive,\r\n  forwardRef,\r\n  HostListener,\r\n  Inject,\r\n  Input\r\n} from '@angular/core';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { MaskService } from './mask.service';\r\nimport { IConfig } from './config';\r\n\r\n@Directive({\r\n  selector: '[mask]',\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => MaskDirective),\r\n      multi: true\r\n    },\r\n    MaskService\r\n  ]\r\n})\r\nexport class MaskDirective implements ControlValueAccessor {\r\n  private _maskValue: string;\r\n  private _inputValue: string;\r\n  private _position: number | null = null;\r\n  // tslint:disable-next-line\r\n  private _start: number;\r\n  private _end: number;\r\n  // tslint:disable-next-line\r\n  public onChange = (_: any) => { };\r\n  public onTouch = () => { };\r\n  public constructor(\r\n    // tslint:disable-next-line\r\n    @Inject(DOCUMENT) private document: any,\r\n    private _maskService: MaskService\r\n  ) { }\r\n\r\n\r\n  @Input('mask')\r\n  public set maskExpression(value: string) {\r\n    this._maskValue = value || '';\r\n    if (!this._maskValue) {\r\n      return;\r\n    }\r\n    this._maskService.maskExpression = this._repeatPatternSymbols(this._maskValue);\r\n    this._maskService.formElementProperty = [\r\n      'value',\r\n      this._maskService.applyMask(\r\n        this._inputValue,\r\n        this._maskService.maskExpression\r\n      )\r\n    ];\r\n  }\r\n\r\n  @Input()\r\n  public set specialCharacters(value: IConfig['specialCharacters']) {\r\n    if (\r\n      !value ||\r\n      !Array.isArray(value) ||\r\n      (Array.isArray(value) && !value.length)\r\n    ) {\r\n      return;\r\n    }\r\n    this._maskService.maskSpecialCharacters = value;\r\n  }\r\n\r\n  @Input()\r\n  public set patterns(value: IConfig['p