@ngneat/input-mask

![commitizen]()
![spectator]()

> @ngneat/input-mask is an angular library that creates an input mask. Behind the scene, it uses inputmask.

Compatibility with Angular Versions

| @ngneat/input-mask | Angular |
| ------------------ | -------------- |
| 4.x.x | >= 11.2.7 < 13 |
| 5.x.x | 13 |
| 6.x.x | 14 |

Features

- 🔡 Support for form validation
- 🎭 Wrapper function to easily create input-masks
- 🔁 Helps you to convert final values to desired format
- ☝️ Single directive to handle everything
- 🛠 All the configurations of inputmask provided

Installation

$3

You can install it through Angular CLI, which is recommended:

``bash
ng add @ngneat/input-mask
`

or with npm

`bash
npm install @ngneat/input-mask inputmask@5
npm install -D @types/inputmask@5
`

When you install using npm or yarn, you will also need to import InputMaskModule in your app.module:

`typescript
import { InputMaskModule } from '@ngneat/input-mask';

@NgModule({
imports: [InputMaskModule],
})
class AppModule {}
`

Config

There few configuration options available with InputMaskModule:

`typescript
import { InputMaskModule } from '@ngneat/input-mask';

@NgModule({
imports: [InputMaskModule.forRoot({ inputSelector: 'input', isAsync: true })],
})
class AppModule {}
`

| Option | Type | Description | Default Value |
| --------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- |
| inputSelector | string | CSS selector, which will be used with querySelector to get the native input from host element. This is useful when you want to apply input-mask to child of your custom-component | input |
| isAsync | boolean | If set true, MutationObserver will be used to look for changes until it finds input with inputSelector | false |

Usage examples

$3

![](./date.gif)

`typescript
import { Component } from '@angular/core';
import { FormControl } from '@angular/forms';
import { createMask } from '@ngneat/input-mask';

@Component({
selector: 'app-root',
template:
[inputMask]="dateInputMask"
[formControl]="dateFC"
placeholder="dd/mm/yyyy"
/>
,
})
export class AppComponent {
dateInputMask = createMask({
alias: 'datetime',
inputFormat: 'dd/mm/yyyy',
parser: (value: string) => {
const values = value.split('/');
const year = +values[2];
const month = +values[1] - 1;
const date = +values[0];
return new Date(year, month, date);
},
});

dateFC = new FormControl('');
}
`

$3

![](./ip.gif)

`typescript
@Component({
template:
[inputMask]="ipAddressMask"
[formControl]="ipFC"
placeholder="_._._._"
/>
,
})
export class AppComponent {
ipAddressMask = createMask({ alias: 'ip' });
ipFC = new FormControl('');
}
`

$3

![](./currency.gif)

`typescript
@Component({
template:
[inputMask]="currencyInputMask"
[formControl]="currencyFC"
placeholder="$ 0.00"
/>
,
})
export class AppComponent {
currencyInputMask = createMask({
alias: 'numeric',
groupSeparator: ',',
digits: 2,
digitsOptional: false,
prefix: '$ ',
placeholder: '0',
});
currencyFC = new FormControl('');
}
`

$3

![](./license.gif)

`typescript
@Component({
template:
[inputMask]="licenseInputMask"
[formControl]="licenseFC"
placeholder="___-___"
/>
,
})
export class AppComponent {
licenseInputMask = createMask('[9-]AAA-999');
licenseFC = new FormControl('');
}
`

$3

![](./email.gif)

`typescript
@Component({
template:
[inputMask]="emailInputMask"
[formControl]="emailFC"
placeholder="_@_._"
/>
,
})
export class AppComponent {
emailInputMask = createMask({ alias: 'email' });
emailFC = new FormControl('');
}
`

$3

If you have some component and you want to apply input-mask to the inner element of that component, you can do that.

For example, let's assume you have a CustomInputComponent:

`typescript
@Component({
selector: 'app-custom-input',
template:
[formControl]="formControl"
[inputMask]="inputMask"
[placeholder]="placeholder"
/>
,
})
export class CustomInputComponent {
@Input() formControl!: FormControl;
@Input() inputMask!: InputmaskOptions;
@Input() placeholder: string | undefined;
}
`

And your AppComponent looks like this:

`typescript
@Component({
selector: 'app-root',
template:
[formControl]="dateFCCustom"
[inputMask]="dateInputMaskCustom"
placeholder="Date"
>
,
})
export class AppComponent {
dateInputMaskCustom = createMask({
alias: 'datetime',
inputFormat: 'dd/mm/yyyy',
parser: (value: string) => {
const values = value.split('/');
const year = +values[2];
const month = +values[1] - 1;
const date = +values[0];
return new Date(year, month, date);
},
});
dateFCCustom = new FormControl('');
}
`

So to apply input-mask on CustomInputComponent, use configuration with InputMaskModule like below:

`typescript
import { InputMaskModule } from '@ngneat/input-mask';

@NgModule({
imports: [
InputMaskModule.forRoot({
isAsync: false, // set to true if native input is lazy loaded
inputSelector: 'input',
}),
],
})
class AppModule {}
`

$3

All examples are available on stackblitz.

You can create any type of input-mask which is supported by InputMask plugin.

Validation

When [inputMask] is used with [formControl], it adds validation out-of-the box. The validation works based on isValid function.

If the validation fails, the form-control will have below error:

`json
{ "inputMask": true }
`

createMask wrapper function

This library uses inputmask plugin to handle mask related tasks. So, you can use all the options available there.

The recommended way to create an inputmask is to use the createMask function provided with this library.

$3

Apart from inputmask options, we have added one more option called parser. This basically helps you to keep the value of form-control in pre-defined format, without updating UI.

For example, you want your users to enter date in input[type=text] with dd/mm/yyyy format and you want to store a Date value in the form-control:

`typescript
@Component({
template:
[inputMask]="dateInputMask"
[formControl]="dateFC"
placeholder="dd/mm/yyyy"
/>
,
})
export class AppComponent {
dateInputMask = createMask({
alias: 'datetime',
inputFormat: 'dd/mm/yyyy',
parser: (value: string) => {
const values = value.split('/');
const year = +values[2];
const month = +values[1] - 1;
const date = +values[0];
return new Date(year, month, date);
},
});

dateFC = new FormControl('');
}
`

In above example, whenver you try to access dateFC.value, it won't be the string which user entered, but rather a Date created based on the parser function.

$3

Apart from the parser function, we have added one more option called formatter. This helps you if you want to change the format of a date you receive from the Database.

For example, you receive a date from your database in the format 'yyyy-MM-dd' but you want to display it 'dd/MM/yyyy'.

`typescript
@Component({
template:
[inputMask]="dateInputMask"
[formControl]="dateFC"
placeholder="dd/mm/yyyy"
/>
,
})
export class AppComponent {
dateInputMask = createMask({
alias: 'datetime',
inputFormat: 'dd/MM/yyyy',
formatter: (value: string) => {
const values = value.split('-');
const date = +values[2];
const month = +values[1] - 1;
const year = +values[0];
return formatDate(new Date(year, month, date), 'dd/MM/yyyy', 'en-US');
},
});

dateFC = new FormControl('1990-12-28');
}
``

Contributors ✨

Thanks goes to these wonderful people (emoji key):

Dharmen Shah 💻 🖋 📖 💡 🚧 📦

Netanel Basal 🐛 💼 🤔 🧑‍🏫 📆 👀

Robin Herbots 🤔

P. Zontrop 📦

Artur Androsovych 🚧 ⚠️

Pawel Boguslawski 🚧

This project follows the all-contributors specification. Contributions of any kind welcome!!