source: trip-planner-front/node_modules/@angular/forms/esm2015/src/directives/validators.js

Last change on this file was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 55.6 KB
Line 
1/**
2 * @license
3 * Copyright Google LLC All Rights Reserved.
4 *
5 * Use of this source code is governed by an MIT-style license that can be
6 * found in the LICENSE file at https://angular.io/license
7 */
8import { Directive, forwardRef, Input } from '@angular/core';
9import { emailValidator, maxLengthValidator, maxValidator, minLengthValidator, minValidator, NG_VALIDATORS, nullValidator, patternValidator, requiredTrueValidator, requiredValidator } from '../validators';
10/**
11 * @description
12 * Method that updates string to integer if not alread a number
13 *
14 * @param value The value to convert to integer
15 * @returns value of parameter in number or integer.
16 */
17function toNumber(value) {
18 return typeof value === 'number' ? value : parseInt(value, 10);
19}
20/**
21 * A base class for Validator-based Directives. The class contains common logic shared across such
22 * Directives.
23 *
24 * For internal use only, this class is not intended for use outside of the Forms package.
25 */
26class AbstractValidatorDirective {
27 constructor() {
28 this._validator = nullValidator;
29 }
30 /**
31 * Helper function invoked from child classes to process changes (from `ngOnChanges` hook).
32 * @nodoc
33 */
34 handleChanges(changes) {
35 if (this.inputName in changes) {
36 const input = this.normalizeInput(changes[this.inputName].currentValue);
37 this._validator = this.createValidator(input);
38 if (this._onChange) {
39 this._onChange();
40 }
41 }
42 }
43 /** @nodoc */
44 validate(control) {
45 return this._validator(control);
46 }
47 /** @nodoc */
48 registerOnValidatorChange(fn) {
49 this._onChange = fn;
50 }
51}
52AbstractValidatorDirective.decorators = [
53 { type: Directive }
54];
55/**
56 * @description
57 * Provider which adds `MaxValidator` to the `NG_VALIDATORS` multi-provider list.
58 */
59export const MAX_VALIDATOR = {
60 provide: NG_VALIDATORS,
61 useExisting: forwardRef(() => MaxValidator),
62 multi: true
63};
64/**
65 * A directive which installs the {@link MaxValidator} for any `formControlName`,
66 * `formControl`, or control with `ngModel` that also has a `max` attribute.
67 *
68 * @see [Form Validation](guide/form-validation)
69 *
70 * @usageNotes
71 *
72 * ### Adding a max validator
73 *
74 * The following example shows how to add a max validator to an input attached to an
75 * ngModel binding.
76 *
77 * ```html
78 * <input type="number" ngModel max="4">
79 * ```
80 *
81 * @ngModule ReactiveFormsModule
82 * @ngModule FormsModule
83 * @publicApi
84 */
85export class MaxValidator extends AbstractValidatorDirective {
86 constructor() {
87 super(...arguments);
88 /** @internal */
89 this.inputName = 'max';
90 /** @internal */
91 this.normalizeInput = (input) => parseFloat(input);
92 /** @internal */
93 this.createValidator = (max) => maxValidator(max);
94 }
95 /**
96 * Declare `ngOnChanges` lifecycle hook at the main directive level (vs keeping it in base class)
97 * to avoid differences in handling inheritance of lifecycle hooks between Ivy and ViewEngine in
98 * AOT mode. This could be refactored once ViewEngine is removed.
99 * @nodoc
100 */
101 ngOnChanges(changes) {
102 this.handleChanges(changes);
103 }
104}
105MaxValidator.decorators = [
106 { type: Directive, args: [{
107 selector: 'input[type=number][max][formControlName],input[type=number][max][formControl],input[type=number][max][ngModel]',
108 providers: [MAX_VALIDATOR],
109 host: { '[attr.max]': 'max ?? null' }
110 },] }
111];
112MaxValidator.propDecorators = {
113 max: [{ type: Input }]
114};
115/**
116 * @description
117 * Provider which adds `MinValidator` to the `NG_VALIDATORS` multi-provider list.
118 */
119export const MIN_VALIDATOR = {
120 provide: NG_VALIDATORS,
121 useExisting: forwardRef(() => MinValidator),
122 multi: true
123};
124/**
125 * A directive which installs the {@link MinValidator} for any `formControlName`,
126 * `formControl`, or control with `ngModel` that also has a `min` attribute.
127 *
128 * @see [Form Validation](guide/form-validation)
129 *
130 * @usageNotes
131 *
132 * ### Adding a min validator
133 *
134 * The following example shows how to add a min validator to an input attached to an
135 * ngModel binding.
136 *
137 * ```html
138 * <input type="number" ngModel min="4">
139 * ```
140 *
141 * @ngModule ReactiveFormsModule
142 * @ngModule FormsModule
143 * @publicApi
144 */
145export class MinValidator extends AbstractValidatorDirective {
146 constructor() {
147 super(...arguments);
148 /** @internal */
149 this.inputName = 'min';
150 /** @internal */
151 this.normalizeInput = (input) => parseFloat(input);
152 /** @internal */
153 this.createValidator = (min) => minValidator(min);
154 }
155 /**
156 * Declare `ngOnChanges` lifecycle hook at the main directive level (vs keeping it in base class)
157 * to avoid differences in handling inheritance of lifecycle hooks between Ivy and ViewEngine in
158 * AOT mode. This could be refactored once ViewEngine is removed.
159 * @nodoc
160 */
161 ngOnChanges(changes) {
162 this.handleChanges(changes);
163 }
164}
165MinValidator.decorators = [
166 { type: Directive, args: [{
167 selector: 'input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]',
168 providers: [MIN_VALIDATOR],
169 host: { '[attr.min]': 'min ?? null' }
170 },] }
171];
172MinValidator.propDecorators = {
173 min: [{ type: Input }]
174};
175/**
176 * @description
177 * Provider which adds `RequiredValidator` to the `NG_VALIDATORS` multi-provider list.
178 */
179export const REQUIRED_VALIDATOR = {
180 provide: NG_VALIDATORS,
181 useExisting: forwardRef(() => RequiredValidator),
182 multi: true
183};
184/**
185 * @description
186 * Provider which adds `CheckboxRequiredValidator` to the `NG_VALIDATORS` multi-provider list.
187 */
188export const CHECKBOX_REQUIRED_VALIDATOR = {
189 provide: NG_VALIDATORS,
190 useExisting: forwardRef(() => CheckboxRequiredValidator),
191 multi: true
192};
193/**
194 * @description
195 * A directive that adds the `required` validator to any controls marked with the
196 * `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
197 *
198 * @see [Form Validation](guide/form-validation)
199 *
200 * @usageNotes
201 *
202 * ### Adding a required validator using template-driven forms
203 *
204 * ```
205 * <input name="fullName" ngModel required>
206 * ```
207 *
208 * @ngModule FormsModule
209 * @ngModule ReactiveFormsModule
210 * @publicApi
211 */
212export class RequiredValidator {
213 constructor() {
214 this._required = false;
215 }
216 /**
217 * @description
218 * Tracks changes to the required attribute bound to this directive.
219 */
220 get required() {
221 return this._required;
222 }
223 set required(value) {
224 this._required = value != null && value !== false && `${value}` !== 'false';
225 if (this._onChange)
226 this._onChange();
227 }
228 /**
229 * Method that validates whether the control is empty.
230 * Returns the validation result if enabled, otherwise null.
231 * @nodoc
232 */
233 validate(control) {
234 return this.required ? requiredValidator(control) : null;
235 }
236 /**
237 * Registers a callback function to call when the validator inputs change.
238 * @nodoc
239 */
240 registerOnValidatorChange(fn) {
241 this._onChange = fn;
242 }
243}
244RequiredValidator.decorators = [
245 { type: Directive, args: [{
246 selector: ':not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]',
247 providers: [REQUIRED_VALIDATOR],
248 host: { '[attr.required]': 'required ? "" : null' }
249 },] }
250];
251RequiredValidator.propDecorators = {
252 required: [{ type: Input }]
253};
254/**
255 * A Directive that adds the `required` validator to checkbox controls marked with the
256 * `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
257 *
258 * @see [Form Validation](guide/form-validation)
259 *
260 * @usageNotes
261 *
262 * ### Adding a required checkbox validator using template-driven forms
263 *
264 * The following example shows how to add a checkbox required validator to an input attached to an
265 * ngModel binding.
266 *
267 * ```
268 * <input type="checkbox" name="active" ngModel required>
269 * ```
270 *
271 * @publicApi
272 * @ngModule FormsModule
273 * @ngModule ReactiveFormsModule
274 */
275export class CheckboxRequiredValidator extends RequiredValidator {
276 /**
277 * Method that validates whether or not the checkbox has been checked.
278 * Returns the validation result if enabled, otherwise null.
279 * @nodoc
280 */
281 validate(control) {
282 return this.required ? requiredTrueValidator(control) : null;
283 }
284}
285CheckboxRequiredValidator.decorators = [
286 { type: Directive, args: [{
287 selector: 'input[type=checkbox][required][formControlName],input[type=checkbox][required][formControl],input[type=checkbox][required][ngModel]',
288 providers: [CHECKBOX_REQUIRED_VALIDATOR],
289 host: { '[attr.required]': 'required ? "" : null' }
290 },] }
291];
292/**
293 * @description
294 * Provider which adds `EmailValidator` to the `NG_VALIDATORS` multi-provider list.
295 */
296export const EMAIL_VALIDATOR = {
297 provide: NG_VALIDATORS,
298 useExisting: forwardRef(() => EmailValidator),
299 multi: true
300};
301/**
302 * A directive that adds the `email` validator to controls marked with the
303 * `email` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
304 *
305 * @see [Form Validation](guide/form-validation)
306 *
307 * @usageNotes
308 *
309 * ### Adding an email validator
310 *
311 * The following example shows how to add an email validator to an input attached to an ngModel
312 * binding.
313 *
314 * ```
315 * <input type="email" name="email" ngModel email>
316 * <input type="email" name="email" ngModel email="true">
317 * <input type="email" name="email" ngModel [email]="true">
318 * ```
319 *
320 * @publicApi
321 * @ngModule FormsModule
322 * @ngModule ReactiveFormsModule
323 */
324export class EmailValidator {
325 constructor() {
326 this._enabled = false;
327 }
328 /**
329 * @description
330 * Tracks changes to the email attribute bound to this directive.
331 */
332 set email(value) {
333 this._enabled = value === '' || value === true || value === 'true';
334 if (this._onChange)
335 this._onChange();
336 }
337 /**
338 * Method that validates whether an email address is valid.
339 * Returns the validation result if enabled, otherwise null.
340 * @nodoc
341 */
342 validate(control) {
343 return this._enabled ? emailValidator(control) : null;
344 }
345 /**
346 * Registers a callback function to call when the validator inputs change.
347 * @nodoc
348 */
349 registerOnValidatorChange(fn) {
350 this._onChange = fn;
351 }
352}
353EmailValidator.decorators = [
354 { type: Directive, args: [{
355 selector: '[email][formControlName],[email][formControl],[email][ngModel]',
356 providers: [EMAIL_VALIDATOR]
357 },] }
358];
359EmailValidator.propDecorators = {
360 email: [{ type: Input }]
361};
362/**
363 * @description
364 * Provider which adds `MinLengthValidator` to the `NG_VALIDATORS` multi-provider list.
365 */
366export const MIN_LENGTH_VALIDATOR = {
367 provide: NG_VALIDATORS,
368 useExisting: forwardRef(() => MinLengthValidator),
369 multi: true
370};
371/**
372 * A directive that adds minimum length validation to controls marked with the
373 * `minlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
374 *
375 * @see [Form Validation](guide/form-validation)
376 *
377 * @usageNotes
378 *
379 * ### Adding a minimum length validator
380 *
381 * The following example shows how to add a minimum length validator to an input attached to an
382 * ngModel binding.
383 *
384 * ```html
385 * <input name="firstName" ngModel minlength="4">
386 * ```
387 *
388 * @ngModule ReactiveFormsModule
389 * @ngModule FormsModule
390 * @publicApi
391 */
392export class MinLengthValidator {
393 constructor() {
394 this._validator = nullValidator;
395 }
396 /** @nodoc */
397 ngOnChanges(changes) {
398 if ('minlength' in changes) {
399 this._createValidator();
400 if (this._onChange)
401 this._onChange();
402 }
403 }
404 /**
405 * Method that validates whether the value meets a minimum length requirement.
406 * Returns the validation result if enabled, otherwise null.
407 * @nodoc
408 */
409 validate(control) {
410 return this.enabled() ? this._validator(control) : null;
411 }
412 /**
413 * Registers a callback function to call when the validator inputs change.
414 * @nodoc
415 */
416 registerOnValidatorChange(fn) {
417 this._onChange = fn;
418 }
419 _createValidator() {
420 this._validator =
421 this.enabled() ? minLengthValidator(toNumber(this.minlength)) : nullValidator;
422 }
423 /** @nodoc */
424 enabled() {
425 return this.minlength != null /* both `null` and `undefined` */;
426 }
427}
428MinLengthValidator.decorators = [
429 { type: Directive, args: [{
430 selector: '[minlength][formControlName],[minlength][formControl],[minlength][ngModel]',
431 providers: [MIN_LENGTH_VALIDATOR],
432 host: { '[attr.minlength]': 'enabled() ? minlength : null' }
433 },] }
434];
435MinLengthValidator.propDecorators = {
436 minlength: [{ type: Input }]
437};
438/**
439 * @description
440 * Provider which adds `MaxLengthValidator` to the `NG_VALIDATORS` multi-provider list.
441 */
442export const MAX_LENGTH_VALIDATOR = {
443 provide: NG_VALIDATORS,
444 useExisting: forwardRef(() => MaxLengthValidator),
445 multi: true
446};
447/**
448 * A directive that adds max length validation to controls marked with the
449 * `maxlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
450 *
451 * @see [Form Validation](guide/form-validation)
452 *
453 * @usageNotes
454 *
455 * ### Adding a maximum length validator
456 *
457 * The following example shows how to add a maximum length validator to an input attached to an
458 * ngModel binding.
459 *
460 * ```html
461 * <input name="firstName" ngModel maxlength="25">
462 * ```
463 *
464 * @ngModule ReactiveFormsModule
465 * @ngModule FormsModule
466 * @publicApi
467 */
468export class MaxLengthValidator {
469 constructor() {
470 this._validator = nullValidator;
471 }
472 /** @nodoc */
473 ngOnChanges(changes) {
474 if ('maxlength' in changes) {
475 this._createValidator();
476 if (this._onChange)
477 this._onChange();
478 }
479 }
480 /**
481 * Method that validates whether the value exceeds the maximum length requirement.
482 * @nodoc
483 */
484 validate(control) {
485 return this.enabled() ? this._validator(control) : null;
486 }
487 /**
488 * Registers a callback function to call when the validator inputs change.
489 * @nodoc
490 */
491 registerOnValidatorChange(fn) {
492 this._onChange = fn;
493 }
494 _createValidator() {
495 this._validator =
496 this.enabled() ? maxLengthValidator(toNumber(this.maxlength)) : nullValidator;
497 }
498 /** @nodoc */
499 enabled() {
500 return this.maxlength != null /* both `null` and `undefined` */;
501 }
502}
503MaxLengthValidator.decorators = [
504 { type: Directive, args: [{
505 selector: '[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]',
506 providers: [MAX_LENGTH_VALIDATOR],
507 host: { '[attr.maxlength]': 'enabled() ? maxlength : null' }
508 },] }
509];
510MaxLengthValidator.propDecorators = {
511 maxlength: [{ type: Input }]
512};
513/**
514 * @description
515 * Provider which adds `PatternValidator` to the `NG_VALIDATORS` multi-provider list.
516 */
517export const PATTERN_VALIDATOR = {
518 provide: NG_VALIDATORS,
519 useExisting: forwardRef(() => PatternValidator),
520 multi: true
521};
522/**
523 * @description
524 * A directive that adds regex pattern validation to controls marked with the
525 * `pattern` attribute. The regex must match the entire control value.
526 * The directive is provided with the `NG_VALIDATORS` multi-provider list.
527 *
528 * @see [Form Validation](guide/form-validation)
529 *
530 * @usageNotes
531 *
532 * ### Adding a pattern validator
533 *
534 * The following example shows how to add a pattern validator to an input attached to an
535 * ngModel binding.
536 *
537 * ```html
538 * <input name="firstName" ngModel pattern="[a-zA-Z ]*">
539 * ```
540 *
541 * @ngModule ReactiveFormsModule
542 * @ngModule FormsModule
543 * @publicApi
544 */
545export class PatternValidator {
546 constructor() {
547 this._validator = nullValidator;
548 }
549 /** @nodoc */
550 ngOnChanges(changes) {
551 if ('pattern' in changes) {
552 this._createValidator();
553 if (this._onChange)
554 this._onChange();
555 }
556 }
557 /**
558 * Method that validates whether the value matches the pattern requirement.
559 * @nodoc
560 */
561 validate(control) {
562 return this._validator(control);
563 }
564 /**
565 * Registers a callback function to call when the validator inputs change.
566 * @nodoc
567 */
568 registerOnValidatorChange(fn) {
569 this._onChange = fn;
570 }
571 _createValidator() {
572 this._validator = patternValidator(this.pattern);
573 }
574}
575PatternValidator.decorators = [
576 { type: Directive, args: [{
577 selector: '[pattern][formControlName],[pattern][formControl],[pattern][ngModel]',
578 providers: [PATTERN_VALIDATOR],
579 host: { '[attr.pattern]': 'pattern ? pattern : null' }
580 },] }
581];
582PatternValidator.propDecorators = {
583 pattern: [{ type: Input }]
584};
585//# 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 {emailValidator, maxLengthValidator, maxValidator, minLengthValidator, minValidator, NG_VALIDATORS, nullValidator, patternValidator, requiredTrueValidator, requiredValidator} from '../validators';\n\n/**\n * @description\n * Method that updates string to integer if not alread a number\n *\n * @param value The value to convert to integer\n * @returns value of parameter in number or integer.\n */\nfunction toNumber(value: string|number): number {\n  return typeof value === 'number' ? value : parseInt(value, 10);\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 * A base class for Validator-based Directives. The class contains common logic shared across such\n * Directives.\n *\n * For internal use only, this class is not intended for use outside of the Forms package.\n */\n@Directive()\nabstract class AbstractValidatorDirective implements Validator {\n  private _validator: ValidatorFn = nullValidator;\n  private _onChange!: () => void;\n\n  /**\n   * Name of an input that matches directive selector attribute (e.g. `minlength` for\n   * `MinLengthDirective`). An input with a given name might contain configuration information (like\n   * `minlength='10'`) or a flag that indicates whether validator should be enabled (like\n   * `[required]='false'`).\n   *\n   * @internal\n   */\n  abstract inputName: string;\n\n  /**\n   * Creates an instance of a validator (specific to a directive that extends this base class).\n   *\n   * @internal\n   */\n  abstract createValidator(input: unknown): ValidatorFn;\n\n  /**\n   * Performs the necessary input normalization based on a specific logic of a Directive.\n   * For example, the function might be used to convert string-based representation of the\n   * `minlength` input to an integer value that can later be used in the `Validators.minLength`\n   * validator.\n   *\n   * @internal\n   */\n  abstract normalizeInput(input: unknown): unknown;\n\n  /**\n   * Helper function invoked from child classes to process changes (from `ngOnChanges` hook).\n   * @nodoc\n   */\n  handleChanges(changes: SimpleChanges): void {\n    if (this.inputName in changes) {\n      const input = this.normalizeInput(changes[this.inputName].currentValue);\n      this._validator = this.createValidator(input);\n      if (this._onChange) {\n        this._onChange();\n      }\n    }\n  }\n\n  /** @nodoc */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this._validator(control);\n  }\n\n  /** @nodoc */\n  registerOnValidatorChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n}\n\n/**\n * @description\n * Provider which adds `MaxValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nexport const MAX_VALIDATOR: StaticProvider = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => MaxValidator),\n  multi: true\n};\n\n/**\n * A directive which installs the {@link MaxValidator} for any `formControlName`,\n * `formControl`, or control with `ngModel` that also has a `max` attribute.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a max validator\n *\n * The following example shows how to add a max validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input type=\"number\" ngModel max=\"4\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\n@Directive({\n  selector:\n      'input[type=number][max][formControlName],input[type=number][max][formControl],input[type=number][max][ngModel]',\n  providers: [MAX_VALIDATOR],\n  host: {'[attr.max]': 'max ?? null'}\n})\nexport class MaxValidator extends AbstractValidatorDirective implements OnChanges {\n  /**\n   * @description\n   * Tracks changes to the max bound to this directive.\n   */\n  @Input() max!: string|number;\n  /** @internal */\n  override inputName = 'max';\n  /** @internal */\n  override normalizeInput = (input: string): number => parseFloat(input);\n  /** @internal */\n  override createValidator = (max: number): ValidatorFn => maxValidator(max);\n  /**\n   * Declare `ngOnChanges` lifecycle hook at the main directive level (vs keeping it in base class)\n   * to avoid differences in handling inheritance of lifecycle hooks between Ivy and ViewEngine in\n   * AOT mode. This could be refactored once ViewEngine is removed.\n   * @nodoc\n   */\n  ngOnChanges(changes: SimpleChanges): void {\n    this.handleChanges(changes);\n  }\n}\n\n/**\n * @description\n * Provider which adds `MinValidator` to the `NG_VALIDATORS` multi-provider list.\n */\nexport const MIN_VALIDATOR: StaticProvider = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => MinValidator),\n  multi: true\n};\n\n/**\n * A directive which installs the {@link MinValidator} for any `formControlName`,\n * `formControl`, or control with `ngModel` that also has a `min` attribute.\n *\n * @see [Form Validation](guide/form-validation)\n *\n * @usageNotes\n *\n * ### Adding a min validator\n *\n * The following example shows how to add a min validator to an input attached to an\n * ngModel binding.\n *\n * ```html\n * <input type=\"number\" ngModel min=\"4\">\n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\n@Directive({\n  selector:\n      'input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]',\n  providers: [MIN_VALIDATOR],\n  host: {'[attr.min]': 'min ?? null'}\n})\nexport class MinValidator extends AbstractValidatorDirective implements OnChanges {\n  /**\n   * @description\n   * Tracks changes to the min bound to this directive.\n   */\n  @Input() min!: string|number;\n  /** @internal */\n  override inputName = 'min';\n  /** @internal */\n  override normalizeInput = (input: string): number => parseFloat(input);\n  /** @internal */\n  override createValidator = (min: number): ValidatorFn => minValidator(min);\n  /**\n   * Declare `ngOnChanges` lifecycle hook at the main directive level (vs keeping it in base class)\n   * to avoid differences in handling inheritance of lifecycle hooks between Ivy and ViewEngine in\n   * AOT mode. This could be refactored once ViewEngine is removed.\n   * @nodoc\n   */\n  ngOnChanges(changes: SimpleChanges): void {\n    this.handleChanges(changes);\n  }\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  private _required = false;\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   * Method that validates whether the control is empty.\n   * Returns the validation result if enabled, otherwise null.\n   * @nodoc\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this.required ? requiredValidator(control) : null;\n  }\n\n  /**\n   * Registers a callback function to call when the validator inputs change.\n   * @nodoc\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   * Method that validates whether or not the checkbox has been checked.\n   * Returns the validation result if enabled, otherwise null.\n   * @nodoc\n   */\n  override validate(control: AbstractControl): ValidationErrors|null {\n    return this.required ? requiredTrueValidator(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  private _enabled = false;\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   * Method that validates whether an email address is valid.\n   * Returns the validation result if enabled, otherwise null.\n   * @nodoc\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this._enabled ? emailValidator(control) : null;\n  }\n\n  /**\n   * Registers a callback function to call when the validator inputs change.\n   * @nodoc\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]': 'enabled() ? minlength : null'}\n})\nexport class MinLengthValidator implements Validator, OnChanges {\n  private _validator: ValidatorFn = nullValidator;\n  private _onChange?: () => void;\n\n  /**\n   * @description\n   * Tracks changes to the minimum length bound to this directive.\n   */\n  @Input()\n  minlength!: string|number|null;  // This input is always defined, since the name matches selector.\n\n  /** @nodoc */\n  ngOnChanges(changes: SimpleChanges): void {\n    if ('minlength' in changes) {\n      this._createValidator();\n      if (this._onChange) this._onChange();\n    }\n  }\n\n  /**\n   * Method that validates whether the value meets a minimum length requirement.\n   * Returns the validation result if enabled, otherwise null.\n   * @nodoc\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this.enabled() ? this._validator(control) : null;\n  }\n\n  /**\n   * Registers a callback function to call when the validator inputs change.\n   * @nodoc\n   */\n  registerOnValidatorChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  private _createValidator(): void {\n    this._validator =\n        this.enabled() ? minLengthValidator(toNumber(this.minlength!)) : nullValidator;\n  }\n\n  /** @nodoc */\n  enabled(): boolean {\n    return this.minlength != null /* both `null` and `undefined` */;\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]': 'enabled() ? maxlength : null'}\n})\nexport class MaxLengthValidator implements Validator, OnChanges {\n  private _validator: ValidatorFn = nullValidator;\n  private _onChange?: () => void;\n\n  /**\n   * @description\n   * Tracks changes to the maximum length bound to this directive.\n   */\n  @Input()\n  maxlength!: string|number|null;  // This input is always defined, since the name matches selector.\n\n  /** @nodoc */\n  ngOnChanges(changes: SimpleChanges): void {\n    if ('maxlength' in changes) {\n      this._createValidator();\n      if (this._onChange) this._onChange();\n    }\n  }\n\n  /**\n   * Method that validates whether the value exceeds the maximum length requirement.\n   * @nodoc\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this.enabled() ? this._validator(control) : null;\n  }\n\n  /**\n   * Registers a callback function to call when the validator inputs change.\n   * @nodoc\n   */\n  registerOnValidatorChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  private _createValidator(): void {\n    this._validator =\n        this.enabled() ? maxLengthValidator(toNumber(this.maxlength!)) : nullValidator;\n  }\n\n  /** @nodoc */\n  enabled(): boolean {\n    return this.maxlength != null /* both `null` and `undefined` */;\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  private _validator: ValidatorFn = nullValidator;\n  private _onChange?: () => void;\n\n  /**\n   * @description\n   * Tracks changes to the pattern bound to this directive.\n   */\n  @Input()\n  pattern!: string|RegExp;  // This input is always defined, since the name matches selector.\n\n  /** @nodoc */\n  ngOnChanges(changes: SimpleChanges): void {\n    if ('pattern' in changes) {\n      this._createValidator();\n      if (this._onChange) this._onChange();\n    }\n  }\n\n  /**\n   * Method that validates whether the value matches the pattern requirement.\n   * @nodoc\n   */\n  validate(control: AbstractControl): ValidationErrors|null {\n    return this._validator(control);\n  }\n\n  /**\n   * Registers a callback function to call when the validator inputs change.\n   * @nodoc\n   */\n  registerOnValidatorChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  private _createValidator(): void {\n    this._validator = patternValidator(this.pattern);\n  }\n}\n"]}
Note: See TracBrowser for help on using the repository browser.