@angular/forms
Version:
Angular - directives and services for creating forms
425 lines • 42.2 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { Directive, forwardRef, Input } from '@angular/core';
import { NG_VALIDATORS, Validators } from '../validators';
/**
* @description
* Provider which adds `RequiredValidator` to the `NG_VALIDATORS` multi-provider list.
*/
export const REQUIRED_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => RequiredValidator),
multi: true
};
/**
* @description
* Provider which adds `CheckboxRequiredValidator` to the `NG_VALIDATORS` multi-provider list.
*/
export const CHECKBOX_REQUIRED_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => CheckboxRequiredValidator),
multi: true
};
/**
* @description
* A directive that adds the `required` validator to any controls marked with the
* `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
*
* @see [Form Validation](guide/form-validation)
*
* @usageNotes
*
* ### Adding a required validator using template-driven forms
*
* ```
* <input name="fullName" ngModel required>
* ```
*
* @ngModule FormsModule
* @ngModule ReactiveFormsModule
* @publicApi
*/
export class RequiredValidator {
/**
* @description
* Tracks changes to the required attribute bound to this directive.
*/
get required() {
return this._required;
}
set required(value) {
this._required = value != null && value !== false && `${value}` !== 'false';
if (this._onChange)
this._onChange();
}
/**
* @description
* Method that validates whether the control is empty.
* Returns the validation result if enabled, otherwise null.
*/
validate(control) {
return this.required ? Validators.required(control) : null;
}
/**
* @description
* Registers a callback function to call when the validator inputs change.
*
* @param fn The callback function
*/
registerOnValidatorChange(fn) {
this._onChange = fn;
}
}
RequiredValidator.decorators = [
{ type: Directive, args: [{
selector: ':not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]',
providers: [REQUIRED_VALIDATOR],
host: { '[attr.required]': 'required ? "" : null' }
},] }
];
RequiredValidator.propDecorators = {
required: [{ type: Input }]
};
/**
* A Directive that adds the `required` validator to checkbox controls marked with the
* `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
*
* @see [Form Validation](guide/form-validation)
*
* @usageNotes
*
* ### Adding a required checkbox validator using template-driven forms
*
* The following example shows how to add a checkbox required validator to an input attached to an
* ngModel binding.
*
* ```
* <input type="checkbox" name="active" ngModel required>
* ```
*
* @publicApi
* @ngModule FormsModule
* @ngModule ReactiveFormsModule
*/
export class CheckboxRequiredValidator extends RequiredValidator {
/**
* @description
* Method that validates whether or not the checkbox has been checked.
* Returns the validation result if enabled, otherwise null.
*/
validate(control) {
return this.required ? Validators.requiredTrue(control) : null;
}
}
CheckboxRequiredValidator.decorators = [
{ type: Directive, args: [{
selector: 'input[type=checkbox][required][formControlName],input[type=checkbox][required][formControl],input[type=checkbox][required][ngModel]',
providers: [CHECKBOX_REQUIRED_VALIDATOR],
host: { '[attr.required]': 'required ? "" : null' }
},] }
];
/**
* @description
* Provider which adds `EmailValidator` to the `NG_VALIDATORS` multi-provider list.
*/
export const EMAIL_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => EmailValidator),
multi: true
};
/**
* A directive that adds the `email` validator to controls marked with the
* `email` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
*
* @see [Form Validation](guide/form-validation)
*
* @usageNotes
*
* ### Adding an email validator
*
* The following example shows how to add an email validator to an input attached to an ngModel
* binding.
*
* ```
* <input type="email" name="email" ngModel email>
* <input type="email" name="email" ngModel email="true">
* <input type="email" name="email" ngModel [email]="true">
* ```
*
* @publicApi
* @ngModule FormsModule
* @ngModule ReactiveFormsModule
*/
export class EmailValidator {
/**
* @description
* Tracks changes to the email attribute bound to this directive.
*/
set email(value) {
this._enabled = value === '' || value === true || value === 'true';
if (this._onChange)
this._onChange();
}
/**
* @description
* Method that validates whether an email address is valid.
* Returns the validation result if enabled, otherwise null.
*/
validate(control) {
return this._enabled ? Validators.email(control) : null;
}
/**
* @description
* Registers a callback function to call when the validator inputs change.
*
* @param fn The callback function
*/
registerOnValidatorChange(fn) {
this._onChange = fn;
}
}
EmailValidator.decorators = [
{ type: Directive, args: [{
selector: '[email][formControlName],[email][formControl],[email][ngModel]',
providers: [EMAIL_VALIDATOR]
},] }
];
EmailValidator.propDecorators = {
email: [{ type: Input }]
};
/**
* @description
* Provider which adds `MinLengthValidator` to the `NG_VALIDATORS` multi-provider list.
*/
export const MIN_LENGTH_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => MinLengthValidator),
multi: true
};
/**
* A directive that adds minimum length validation to controls marked with the
* `minlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
*
* @see [Form Validation](guide/form-validation)
*
* @usageNotes
*
* ### Adding a minimum length validator
*
* The following example shows how to add a minimum length validator to an input attached to an
* ngModel binding.
*
* ```html
* <input name="firstName" ngModel minlength="4">
* ```
*
* @ngModule ReactiveFormsModule
* @ngModule FormsModule
* @publicApi
*/
export class MinLengthValidator {
/**
* @description
* A lifecycle method called when the directive's inputs change. For internal use
* only.
*
* @param changes A object of key/value pairs for the set of changed inputs.
*/
ngOnChanges(changes) {
if ('minlength' in changes) {
this._createValidator();
if (this._onChange)
this._onChange();
}
}
/**
* @description
* Method that validates whether the value meets a minimum length
* requirement. Returns the validation result if enabled, otherwise null.
*/
validate(control) {
return this.minlength == null ? null : this._validator(control);
}
/**
* @description
* Registers a callback function to call when the validator inputs change.
*
* @param fn The callback function
*/
registerOnValidatorChange(fn) {
this._onChange = fn;
}
_createValidator() {
this._validator = Validators.minLength(typeof this.minlength === 'number' ? this.minlength : parseInt(this.minlength, 10));
}
}
MinLengthValidator.decorators = [
{ type: Directive, args: [{
selector: '[minlength][formControlName],[minlength][formControl],[minlength][ngModel]',
providers: [MIN_LENGTH_VALIDATOR],
host: { '[attr.minlength]': 'minlength ? minlength : null' }
},] }
];
MinLengthValidator.propDecorators = {
minlength: [{ type: Input }]
};
/**
* @description
* Provider which adds `MaxLengthValidator` to the `NG_VALIDATORS` multi-provider list.
*/
export const MAX_LENGTH_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => MaxLengthValidator),
multi: true
};
/**
* A directive that adds max length validation to controls marked with the
* `maxlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
*
* @see [Form Validation](guide/form-validation)
*
* @usageNotes
*
* ### Adding a maximum length validator
*
* The following example shows how to add a maximum length validator to an input attached to an
* ngModel binding.
*
* ```html
* <input name="firstName" ngModel maxlength="25">
* ```
*
* @ngModule ReactiveFormsModule
* @ngModule FormsModule
* @publicApi
*/
export class MaxLengthValidator {
/**
* @description
* A lifecycle method called when the directive's inputs change. For internal use
* only.
*
* @param changes A object of key/value pairs for the set of changed inputs.
*/
ngOnChanges(changes) {
if ('maxlength' in changes) {
this._createValidator();
if (this._onChange)
this._onChange();
}
}
/**
* @description
* Method that validates whether the value exceeds
* the maximum length requirement.
*/
validate(control) {
return this.maxlength != null ? this._validator(control) : null;
}
/**
* @description
* Registers a callback function to call when the validator inputs change.
*
* @param fn The callback function
*/
registerOnValidatorChange(fn) {
this._onChange = fn;
}
_createValidator() {
this._validator = Validators.maxLength(typeof this.maxlength === 'number' ? this.maxlength : parseInt(this.maxlength, 10));
}
}
MaxLengthValidator.decorators = [
{ type: Directive, args: [{
selector: '[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]',
providers: [MAX_LENGTH_VALIDATOR],
host: { '[attr.maxlength]': 'maxlength ? maxlength : null' }
},] }
];
MaxLengthValidator.propDecorators = {
maxlength: [{ type: Input }]
};
/**
* @description
* Provider which adds `PatternValidator` to the `NG_VALIDATORS` multi-provider list.
*/
export const PATTERN_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => PatternValidator),
multi: true
};
/**
* @description
* A directive that adds regex pattern validation to controls marked with the
* `pattern` attribute. The regex must match the entire control value.
* The directive is provided with the `NG_VALIDATORS` multi-provider list.
*
* @see [Form Validation](guide/form-validation)
*
* @usageNotes
*
* ### Adding a pattern validator
*
* The following example shows how to add a pattern validator to an input attached to an
* ngModel binding.
*
* ```html
* <input name="firstName" ngModel pattern="[a-zA-Z ]*">
* ```
*
* @ngModule ReactiveFormsModule
* @ngModule FormsModule
* @publicApi
*/
export class PatternValidator {
/**
* @description
* A lifecycle method called when the directive's inputs change. For internal use
* only.
*
* @param changes A object of key/value pairs for the set of changed inputs.
*/
ngOnChanges(changes) {
if ('pattern' in changes) {
this._createValidator();
if (this._onChange)
this._onChange();
}
}
/**
* @description
* Method that validates whether the value matches the
* the pattern requirement.
*/
validate(control) {
return this._validator(control);
}
/**
* @description
* Registers a callback function to call when the validator inputs change.
*
* @param fn The callback function
*/
registerOnValidatorChange(fn) {
this._onChange = fn;
}
_createValidator() {
this._validator = Validators.pattern(this.pattern);
}
}
PatternValidator.decorators = [
{ type: Directive, args: [{
selector: '[pattern][formControlName],[pattern][formControl],[pattern][ngModel]',
providers: [PATTERN_VALIDATOR],
host: { '[attr.pattern]': 'pattern ? pattern : null' }
},] }
];
PatternValidator.propDecorators = {
pattern: [{ type: Input }]
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../../../../../../packages/forms/src/directives/validators.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Directive, forwardRef, Input, OnChanges, SimpleChanges, StaticProvider} from '@angular/core';\nimport {Observable} from 'rxjs';\n\nimport {AbstractControl} from '../model';\nimport {NG_VALIDATORS, Validators} from '../validators';\n\n\n/**\n * @description\n * Defines the map of errors returned from failed validation checks.\n *\n * @publicApi\n */\nexport type ValidationErrors = {\n  [key: string]: any\n};\n\n/**\n * @description\n * An interface implemented by classes that perform synchronous validation.\n *\n * @usageNotes\n *\n * ### Provide a custom validator\n *\n * The following example implements the `Validator` interface to create a\n * validator directive with a custom error key.\n *\n * ```typescript\n * @Directive({\n *   selector: '[customValidator]',\n *   providers: [{provide: NG_VALIDATORS, useExisting: CustomValidatorDirective, multi: true}]\n * })\n * class CustomValidatorDirective implements Validator {\n *   validate(control: AbstractControl): ValidationErrors|null {\n *     return {'custom': true};\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nexport interface Validator {\n  /**\n   * @description\n   * Method that performs synchronous validation against the provided control.\n   *\n   * @param control The control to validate against.\n   *\n   * @returns A map of validation errors if validation fails,\n   * otherwise null.\n   */\n  validate(control: AbstractControl): ValidationErrors|null;\n\n  /**\n   * @description\n   * Registers a callback function to call when the validator inputs change.\n   *\n   * @param fn The callback function\n   */\n  registerOnValidatorChange?(fn: () => void): void;\n}\n\n/**\n * @description\n * An interface implemented by classes that perform asynchronous validation.\n *\n * @usageNotes\n *\n * ### Provide a custom async validator directive\n *\n * The following example implements the `AsyncValidator` interface to create an\n * async validator directive with a custom error key.\n *\n * ```typescript\n * import { of } from 'rxjs';\n *\n * @Directive({\n *   selector: '[customAsyncValidator]',\n *   providers: [{provide: NG_ASYNC_VALIDATORS, useExisting: CustomAsyncValidatorDirective, multi:\n * true}]\n * })\n * class CustomAsyncValidatorDirective implements AsyncValidator {\n *   validate(control: AbstractControl): Observable<ValidationErrors|null> {\n *     return of({'custom': true});\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nexport interface AsyncValidator extends Validator {\n  /**\n   * @description\n   * Method that performs async validation against the provided control.\n   *\n   * @param control The control to validate against.\n   *\n   * @returns A promise or observable that resolves a map of validation errors\n   * if validation fails, otherwise null.\n   */\n  validate(control: AbstractControl):\n      Promise<ValidationErrors|null>|Observable<ValidationErrors|null>;\n}\n\n/**\n * @description\n * Provider which adds `RequiredValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nexport const REQUIRED_VALIDATOR: StaticProvider = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => RequiredValidator),\n  multi: true\n};\n\n/**\n * @description\n * Provider which adds `CheckboxRequiredValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nexport const CHECKBOX_REQUIRED_VALIDATOR: StaticProvider = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => CheckboxRequiredValidator),\n  multi: true\n};\n\n\n/**\n * @description\n * A directive that adds the `required` validator to any controls marked with the\n * `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a required validator using template-driven forms\n *\n * ```\n * <input name=\"fullName\" ngModel required>\n * ```\n *\n * @ngModule FormsModule\n * @ngModule ReactiveFormsModule\n * @publicApi\n */\n@Directive({\n  selector:\n      ':not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]',\n  providers: [REQUIRED_VALIDATOR],\n  host: {'[attr.required]': 'required ? \"\" : null'}\n})\nexport class RequiredValidator implements Validator {\n  // TODO(issue/24571): remove '!'.\n  private _required!: boolean;\n  // TODO(issue/24571): remove '!'.\n  private _onChange!: () => void;\n\n  /**\n   * @description\n   * Tracks changes to the required attribute bound to this directive.\n   */\n  @Input()\n  get required(): boolean|string {\n    return this._required;\n  }\n\n  set required(value: boolean|string) {\n    this._required = value != null && value !== false && `${value}` !== 'false';\n    if (this._onChange) this._onChange();\n  }\n\n  /**\n   * @description\n   * Method that validates whether the control is empty.\n   * Returns the validation result if enabled, otherwise null.\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this.required ? Validators.required(control) : null;\n  }\n\n  /**\n   * @description\n   * Registers a callback function to call when the validator inputs change.\n   *\n   * @param fn The callback function\n   */\n  registerOnValidatorChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n}\n\n\n/**\n * A Directive that adds the `required` validator to checkbox controls marked with the\n * `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a required checkbox validator using template-driven forms\n *\n * The following example shows how to add a checkbox required validator to an input attached to an\n * ngModel binding.\n *\n * ```\n * <input type=\"checkbox\" name=\"active\" ngModel required>\n * ```\n *\n * @publicApi\n * @ngModule FormsModule\n * @ngModule ReactiveFormsModule\n */\n@Directive({\n  selector:\n      'input[type=checkbox][required][formControlName],input[type=checkbox][required][formControl],input[type=checkbox][required][ngModel]',\n  providers: [CHECKBOX_REQUIRED_VALIDATOR],\n  host: {'[attr.required]': 'required ? \"\" : null'}\n})\nexport class CheckboxRequiredValidator extends RequiredValidator {\n  /**\n   * @description\n   * Method that validates whether or not the checkbox has been checked.\n   * Returns the validation result if enabled, otherwise null.\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this.required ? Validators.requiredTrue(control) : null;\n  }\n}\n\n/**\n * @description\n * Provider which adds `EmailValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nexport const EMAIL_VALIDATOR: any = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => EmailValidator),\n  multi: true\n};\n\n/**\n * A directive that adds the `email` validator to controls marked with the\n * `email` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding an email validator\n *\n * The following example shows how to add an email validator to an input attached to an ngModel\n * binding.\n *\n * ```\n * <input type=\"email\" name=\"email\" ngModel email>\n * <input type=\"email\" name=\"email\" ngModel email=\"true\">\n * <input type=\"email\" name=\"email\" ngModel [email]=\"true\">\n * ```\n *\n * @publicApi\n * @ngModule FormsModule\n * @ngModule ReactiveFormsModule\n */\n@Directive({\n  selector: '[email][formControlName],[email][formControl],[email][ngModel]',\n  providers: [EMAIL_VALIDATOR]\n})\nexport class EmailValidator implements Validator {\n  // TODO(issue/24571): remove '!'.\n  private _enabled!: boolean;\n  // TODO(issue/24571): remove '!'.\n  private _onChange!: () => void;\n\n  /**\n   * @description\n   * Tracks changes to the email attribute bound to this directive.\n   */\n  @Input()\n  set email(value: boolean|string) {\n    this._enabled = value === '' || value === true || value === 'true';\n    if (this._onChange) this._onChange();\n  }\n\n  /**\n   * @description\n   * Method that validates whether an email address is valid.\n   * Returns the validation result if enabled, otherwise null.\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this._enabled ? Validators.email(control) : null;\n  }\n\n  /**\n   * @description\n   * Registers a callback function to call when the validator inputs change.\n   *\n   * @param fn The callback function\n   */\n  registerOnValidatorChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n}\n\n/**\n * @description\n * A function that receives a control and synchronously returns a map of\n * validation errors if present, otherwise null.\n *\n * @publicApi\n */\nexport interface ValidatorFn {\n  (control: AbstractControl): ValidationErrors|null;\n}\n\n/**\n * @description\n * A function that receives a control and returns a Promise or observable\n * that emits validation errors if present, otherwise null.\n *\n * @publicApi\n */\nexport interface AsyncValidatorFn {\n  (control: AbstractControl): Promise<ValidationErrors|null>|Observable<ValidationErrors|null>;\n}\n\n/**\n * @description\n * Provider which adds `MinLengthValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nexport const MIN_LENGTH_VALIDATOR: any = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => MinLengthValidator),\n  multi: true\n};\n\n/**\n * A directive that adds minimum length validation to controls marked with the\n * `minlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a minimum length validator\n *\n * The following example shows how to add a minimum length validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input name=\"firstName\" ngModel minlength=\"4\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\n@Directive({\n  selector: '[minlength][formControlName],[minlength][formControl],[minlength][ngModel]',\n  providers: [MIN_LENGTH_VALIDATOR],\n  host: {'[attr.minlength]': 'minlength ? minlength : null'}\n})\nexport class MinLengthValidator implements Validator, OnChanges {\n  // TODO(issue/24571): remove '!'.\n  private _validator!: ValidatorFn;\n  // TODO(issue/24571): remove '!'.\n  private _onChange!: () => void;\n\n  /**\n   * @description\n   * Tracks changes to the the minimum length bound to this directive.\n   */\n  // TODO(issue/24571): remove '!'.\n  @Input() minlength!: string|number;\n\n  /**\n   * @description\n   * A lifecycle method called when the directive's inputs change. For internal use\n   * only.\n   *\n   * @param changes A object of key/value pairs for the set of changed inputs.\n   */\n  ngOnChanges(changes: SimpleChanges): void {\n    if ('minlength' in changes) {\n      this._createValidator();\n      if (this._onChange) this._onChange();\n    }\n  }\n\n  /**\n   * @description\n   * Method that validates whether the value meets a minimum length\n   * requirement. Returns the validation result if enabled, otherwise null.\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this.minlength == null ? null : this._validator(control);\n  }\n\n  /**\n   * @description\n   * Registers a callback function to call when the validator inputs change.\n   *\n   * @param fn The callback function\n   */\n  registerOnValidatorChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  private _createValidator(): void {\n    this._validator = Validators.minLength(\n        typeof this.minlength === 'number' ? this.minlength : parseInt(this.minlength, 10));\n  }\n}\n\n/**\n * @description\n * Provider which adds `MaxLengthValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nexport const MAX_LENGTH_VALIDATOR: any = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => MaxLengthValidator),\n  multi: true\n};\n\n/**\n * A directive that adds max length validation to controls marked with the\n * `maxlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a maximum length validator\n *\n * The following example shows how to add a maximum length validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input name=\"firstName\" ngModel maxlength=\"25\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\n@Directive({\n  selector: '[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]',\n  providers: [MAX_LENGTH_VALIDATOR],\n  host: {'[attr.maxlength]': 'maxlength ? maxlength : null'}\n})\nexport class MaxLengthValidator implements Validator, OnChanges {\n  // TODO(issue/24571): remove '!'.\n  private _validator!: ValidatorFn;\n  // TODO(issue/24571): remove '!'.\n  private _onChange!: () => void;\n\n  /**\n   * @description\n   * Tracks changes to the the maximum length bound to this directive.\n   */\n  // TODO(issue/24571): remove '!'.\n  @Input() maxlength!: string|number;\n\n  /**\n   * @description\n   * A lifecycle method called when the directive's inputs change. For internal use\n   * only.\n   *\n   * @param changes A object of key/value pairs for the set of changed inputs.\n   */\n  ngOnChanges(changes: SimpleChanges): void {\n    if ('maxlength' in changes) {\n      this._createValidator();\n      if (this._onChange) this._onChange();\n    }\n  }\n\n  /**\n   * @description\n   * Method that validates whether the value exceeds\n   * the maximum length requirement.\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this.maxlength != null ? this._validator(control) : null;\n  }\n\n  /**\n   * @description\n   * Registers a callback function to call when the validator inputs change.\n   *\n   * @param fn The callback function\n   */\n  registerOnValidatorChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  private _createValidator(): void {\n    this._validator = Validators.maxLength(\n        typeof this.maxlength === 'number' ? this.maxlength : parseInt(this.maxlength, 10));\n  }\n}\n\n/**\n * @description\n * Provider which adds `PatternValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nexport const PATTERN_VALIDATOR: any = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => PatternValidator),\n  multi: true\n};\n\n\n/**\n * @description\n * A directive that adds regex pattern validation to controls marked with the\n * `pattern` attribute. The regex must match the entire control value.\n * The directive is provided with the `NG_VALIDATORS` multi-provider list.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a pattern validator\n *\n * The following example shows how to add a pattern validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input name=\"firstName\" ngModel pattern=\"[a-zA-Z ]*\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\n@Directive({\n  selector: '[pattern][formControlName],[pattern][formControl],[pattern][ngModel]',\n  providers: [PATTERN_VALIDATOR],\n  host: {'[attr.pattern]': 'pattern ? pattern : null'}\n})\nexport class PatternValidator implements Validator, OnChanges {\n  // TODO(issue/24571): remove '!'.\n  private _validator!: ValidatorFn;\n  // TODO(issue/24571): remove '!'.\n  private _onChange!: () => void;\n\n  /**\n   * @description\n   * Tracks changes to the pattern bound to this directive.\n   */\n  // TODO(issue/24571): remove '!'.\n  @Input() pattern!: string|RegExp;\n\n  /**\n   * @description\n   * A lifecycle method called when the directive's inputs change. For internal use\n   * only.\n   *\n   * @param changes A object of key/value pairs for the set of changed inputs.\n   */\n  ngOnChanges(changes: SimpleChanges): void {\n    if ('pattern' in changes) {\n      this._createValidator();\n      if (this._onChange) this._onChange();\n    }\n  }\n\n  /**\n   * @description\n   * Method that validates whether the value matches the\n   * the pattern requirement.\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this._validator(control);\n  }\n\n  /**\n   * @description\n   * Registers a callback function to call when the validator inputs change.\n   *\n   * @param fn The callback function\n   */\n  registerOnValidatorChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  private _createValidator(): void {\n    this._validator = Validators.pattern(this.pattern);\n  }\n}\n"]}