source: trip-planner-front/node_modules/@angular/forms/esm2015/src/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: 70.2 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 { InjectionToken, ɵisObservable as isObservable, ɵisPromise as isPromise } from '@angular/core';
9import { forkJoin, from } from 'rxjs';
10import { map } from 'rxjs/operators';
11function isEmptyInputValue(value) {
12 // we don't check for string here so it also works with arrays
13 return value == null || value.length === 0;
14}
15function hasValidLength(value) {
16 // non-strict comparison is intentional, to check for both `null` and `undefined` values
17 return value != null && typeof value.length === 'number';
18}
19/**
20 * @description
21 * An `InjectionToken` for registering additional synchronous validators used with
22 * `AbstractControl`s.
23 *
24 * @see `NG_ASYNC_VALIDATORS`
25 *
26 * @usageNotes
27 *
28 * ### Providing a custom validator
29 *
30 * The following example registers a custom validator directive. Adding the validator to the
31 * existing collection of validators requires the `multi: true` option.
32 *
33 * ```typescript
34 * @Directive({
35 * selector: '[customValidator]',
36 * providers: [{provide: NG_VALIDATORS, useExisting: CustomValidatorDirective, multi: true}]
37 * })
38 * class CustomValidatorDirective implements Validator {
39 * validate(control: AbstractControl): ValidationErrors | null {
40 * return { 'custom': true };
41 * }
42 * }
43 * ```
44 *
45 * @publicApi
46 */
47export const NG_VALIDATORS = new InjectionToken('NgValidators');
48/**
49 * @description
50 * An `InjectionToken` for registering additional asynchronous validators used with
51 * `AbstractControl`s.
52 *
53 * @see `NG_VALIDATORS`
54 *
55 * @publicApi
56 */
57export const NG_ASYNC_VALIDATORS = new InjectionToken('NgAsyncValidators');
58/**
59 * A regular expression that matches valid e-mail addresses.
60 *
61 * At a high level, this regexp matches e-mail addresses of the format `local-part@tld`, where:
62 * - `local-part` consists of one or more of the allowed characters (alphanumeric and some
63 * punctuation symbols).
64 * - `local-part` cannot begin or end with a period (`.`).
65 * - `local-part` cannot be longer than 64 characters.
66 * - `tld` consists of one or more `labels` separated by periods (`.`). For example `localhost` or
67 * `foo.com`.
68 * - A `label` consists of one or more of the allowed characters (alphanumeric, dashes (`-`) and
69 * periods (`.`)).
70 * - A `label` cannot begin or end with a dash (`-`) or a period (`.`).
71 * - A `label` cannot be longer than 63 characters.
72 * - The whole address cannot be longer than 254 characters.
73 *
74 * ## Implementation background
75 *
76 * This regexp was ported over from AngularJS (see there for git history):
77 * https://github.com/angular/angular.js/blob/c133ef836/src/ng/directive/input.js#L27
78 * It is based on the
79 * [WHATWG version](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address) with
80 * some enhancements to incorporate more RFC rules (such as rules related to domain names and the
81 * lengths of different parts of the address). The main differences from the WHATWG version are:
82 * - Disallow `local-part` to begin or end with a period (`.`).
83 * - Disallow `local-part` length to exceed 64 characters.
84 * - Disallow total address length to exceed 254 characters.
85 *
86 * See [this commit](https://github.com/angular/angular.js/commit/f3f5cf72e) for more details.
87 */
88const EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
89/**
90 * @description
91 * Provides a set of built-in validators that can be used by form controls.
92 *
93 * A validator is a function that processes a `FormControl` or collection of
94 * controls and returns an error map or null. A null map means that validation has passed.
95 *
96 * @see [Form Validation](/guide/form-validation)
97 *
98 * @publicApi
99 */
100export class Validators {
101 /**
102 * @description
103 * Validator that requires the control's value to be greater than or equal to the provided number.
104 *
105 * @usageNotes
106 *
107 * ### Validate against a minimum of 3
108 *
109 * ```typescript
110 * const control = new FormControl(2, Validators.min(3));
111 *
112 * console.log(control.errors); // {min: {min: 3, actual: 2}}
113 * ```
114 *
115 * @returns A validator function that returns an error map with the
116 * `min` property if the validation check fails, otherwise `null`.
117 *
118 * @see `updateValueAndValidity()`
119 *
120 */
121 static min(min) {
122 return minValidator(min);
123 }
124 /**
125 * @description
126 * Validator that requires the control's value to be less than or equal to the provided number.
127 *
128 * @usageNotes
129 *
130 * ### Validate against a maximum of 15
131 *
132 * ```typescript
133 * const control = new FormControl(16, Validators.max(15));
134 *
135 * console.log(control.errors); // {max: {max: 15, actual: 16}}
136 * ```
137 *
138 * @returns A validator function that returns an error map with the
139 * `max` property if the validation check fails, otherwise `null`.
140 *
141 * @see `updateValueAndValidity()`
142 *
143 */
144 static max(max) {
145 return maxValidator(max);
146 }
147 /**
148 * @description
149 * Validator that requires the control have a non-empty value.
150 *
151 * @usageNotes
152 *
153 * ### Validate that the field is non-empty
154 *
155 * ```typescript
156 * const control = new FormControl('', Validators.required);
157 *
158 * console.log(control.errors); // {required: true}
159 * ```
160 *
161 * @returns An error map with the `required` property
162 * if the validation check fails, otherwise `null`.
163 *
164 * @see `updateValueAndValidity()`
165 *
166 */
167 static required(control) {
168 return requiredValidator(control);
169 }
170 /**
171 * @description
172 * Validator that requires the control's value be true. This validator is commonly
173 * used for required checkboxes.
174 *
175 * @usageNotes
176 *
177 * ### Validate that the field value is true
178 *
179 * ```typescript
180 * const control = new FormControl('', Validators.requiredTrue);
181 *
182 * console.log(control.errors); // {required: true}
183 * ```
184 *
185 * @returns An error map that contains the `required` property
186 * set to `true` if the validation check fails, otherwise `null`.
187 *
188 * @see `updateValueAndValidity()`
189 *
190 */
191 static requiredTrue(control) {
192 return requiredTrueValidator(control);
193 }
194 /**
195 * @description
196 * Validator that requires the control's value pass an email validation test.
197 *
198 * Tests the value using a [regular
199 * expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions)
200 * pattern suitable for common usecases. The pattern is based on the definition of a valid email
201 * address in the [WHATWG HTML
202 * specification](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address) with
203 * some enhancements to incorporate more RFC rules (such as rules related to domain names and the
204 * lengths of different parts of the address).
205 *
206 * The differences from the WHATWG version include:
207 * - Disallow `local-part` (the part before the `@` symbol) to begin or end with a period (`.`).
208 * - Disallow `local-part` to be longer than 64 characters.
209 * - Disallow the whole address to be longer than 254 characters.
210 *
211 * If this pattern does not satisfy your business needs, you can use `Validators.pattern()` to
212 * validate the value against a different pattern.
213 *
214 * @usageNotes
215 *
216 * ### Validate that the field matches a valid email pattern
217 *
218 * ```typescript
219 * const control = new FormControl('bad@', Validators.email);
220 *
221 * console.log(control.errors); // {email: true}
222 * ```
223 *
224 * @returns An error map with the `email` property
225 * if the validation check fails, otherwise `null`.
226 *
227 * @see `updateValueAndValidity()`
228 *
229 */
230 static email(control) {
231 return emailValidator(control);
232 }
233 /**
234 * @description
235 * Validator that requires the length of the control's value to be greater than or equal
236 * to the provided minimum length. This validator is also provided by default if you use the
237 * the HTML5 `minlength` attribute. Note that the `minLength` validator is intended to be used
238 * only for types that have a numeric `length` property, such as strings or arrays. The
239 * `minLength` validator logic is also not invoked for values when their `length` property is 0
240 * (for example in case of an empty string or an empty array), to support optional controls. You
241 * can use the standard `required` validator if empty values should not be considered valid.
242 *
243 * @usageNotes
244 *
245 * ### Validate that the field has a minimum of 3 characters
246 *
247 * ```typescript
248 * const control = new FormControl('ng', Validators.minLength(3));
249 *
250 * console.log(control.errors); // {minlength: {requiredLength: 3, actualLength: 2}}
251 * ```
252 *
253 * ```html
254 * <input minlength="5">
255 * ```
256 *
257 * @returns A validator function that returns an error map with the
258 * `minlength` property if the validation check fails, otherwise `null`.
259 *
260 * @see `updateValueAndValidity()`
261 *
262 */
263 static minLength(minLength) {
264 return minLengthValidator(minLength);
265 }
266 /**
267 * @description
268 * Validator that requires the length of the control's value to be less than or equal
269 * to the provided maximum length. This validator is also provided by default if you use the
270 * the HTML5 `maxlength` attribute. Note that the `maxLength` validator is intended to be used
271 * only for types that have a numeric `length` property, such as strings or arrays.
272 *
273 * @usageNotes
274 *
275 * ### Validate that the field has maximum of 5 characters
276 *
277 * ```typescript
278 * const control = new FormControl('Angular', Validators.maxLength(5));
279 *
280 * console.log(control.errors); // {maxlength: {requiredLength: 5, actualLength: 7}}
281 * ```
282 *
283 * ```html
284 * <input maxlength="5">
285 * ```
286 *
287 * @returns A validator function that returns an error map with the
288 * `maxlength` property if the validation check fails, otherwise `null`.
289 *
290 * @see `updateValueAndValidity()`
291 *
292 */
293 static maxLength(maxLength) {
294 return maxLengthValidator(maxLength);
295 }
296 /**
297 * @description
298 * Validator that requires the control's value to match a regex pattern. This validator is also
299 * provided by default if you use the HTML5 `pattern` attribute.
300 *
301 * @usageNotes
302 *
303 * ### Validate that the field only contains letters or spaces
304 *
305 * ```typescript
306 * const control = new FormControl('1', Validators.pattern('[a-zA-Z ]*'));
307 *
308 * console.log(control.errors); // {pattern: {requiredPattern: '^[a-zA-Z ]*$', actualValue: '1'}}
309 * ```
310 *
311 * ```html
312 * <input pattern="[a-zA-Z ]*">
313 * ```
314 *
315 * ### Pattern matching with the global or sticky flag
316 *
317 * `RegExp` objects created with the `g` or `y` flags that are passed into `Validators.pattern`
318 * can produce different results on the same input when validations are run consecutively. This is
319 * due to how the behavior of `RegExp.prototype.test` is
320 * specified in [ECMA-262](https://tc39.es/ecma262/#sec-regexpbuiltinexec)
321 * (`RegExp` preserves the index of the last match when the global or sticky flag is used).
322 * Due to this behavior, it is recommended that when using
323 * `Validators.pattern` you **do not** pass in a `RegExp` object with either the global or sticky
324 * flag enabled.
325 *
326 * ```typescript
327 * // Not recommended (since the `g` flag is used)
328 * const controlOne = new FormControl('1', Validators.pattern(/foo/g));
329 *
330 * // Good
331 * const controlTwo = new FormControl('1', Validators.pattern(/foo/));
332 * ```
333 *
334 * @param pattern A regular expression to be used as is to test the values, or a string.
335 * If a string is passed, the `^` character is prepended and the `$` character is
336 * appended to the provided string (if not already present), and the resulting regular
337 * expression is used to test the values.
338 *
339 * @returns A validator function that returns an error map with the
340 * `pattern` property if the validation check fails, otherwise `null`.
341 *
342 * @see `updateValueAndValidity()`
343 *
344 */
345 static pattern(pattern) {
346 return patternValidator(pattern);
347 }
348 /**
349 * @description
350 * Validator that performs no operation.
351 *
352 * @see `updateValueAndValidity()`
353 *
354 */
355 static nullValidator(control) {
356 return nullValidator(control);
357 }
358 static compose(validators) {
359 return compose(validators);
360 }
361 /**
362 * @description
363 * Compose multiple async validators into a single function that returns the union
364 * of the individual error objects for the provided control.
365 *
366 * @returns A validator function that returns an error map with the
367 * merged error objects of the async validators if the validation check fails, otherwise `null`.
368 *
369 * @see `updateValueAndValidity()`
370 *
371 */
372 static composeAsync(validators) {
373 return composeAsync(validators);
374 }
375}
376/**
377 * Validator that requires the control's value to be greater than or equal to the provided number.
378 * See `Validators.min` for additional information.
379 */
380export function minValidator(min) {
381 return (control) => {
382 if (isEmptyInputValue(control.value) || isEmptyInputValue(min)) {
383 return null; // don't validate empty values to allow optional controls
384 }
385 const value = parseFloat(control.value);
386 // Controls with NaN values after parsing should be treated as not having a
387 // minimum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-min
388 return !isNaN(value) && value < min ? { 'min': { 'min': min, 'actual': control.value } } : null;
389 };
390}
391/**
392 * Validator that requires the control's value to be less than or equal to the provided number.
393 * See `Validators.max` for additional information.
394 */
395export function maxValidator(max) {
396 return (control) => {
397 if (isEmptyInputValue(control.value) || isEmptyInputValue(max)) {
398 return null; // don't validate empty values to allow optional controls
399 }
400 const value = parseFloat(control.value);
401 // Controls with NaN values after parsing should be treated as not having a
402 // maximum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-max
403 return !isNaN(value) && value > max ? { 'max': { 'max': max, 'actual': control.value } } : null;
404 };
405}
406/**
407 * Validator that requires the control have a non-empty value.
408 * See `Validators.required` for additional information.
409 */
410export function requiredValidator(control) {
411 return isEmptyInputValue(control.value) ? { 'required': true } : null;
412}
413/**
414 * Validator that requires the control's value be true. This validator is commonly
415 * used for required checkboxes.
416 * See `Validators.requiredTrue` for additional information.
417 */
418export function requiredTrueValidator(control) {
419 return control.value === true ? null : { 'required': true };
420}
421/**
422 * Validator that requires the control's value pass an email validation test.
423 * See `Validators.email` for additional information.
424 */
425export function emailValidator(control) {
426 if (isEmptyInputValue(control.value)) {
427 return null; // don't validate empty values to allow optional controls
428 }
429 return EMAIL_REGEXP.test(control.value) ? null : { 'email': true };
430}
431/**
432 * Validator that requires the length of the control's value to be greater than or equal
433 * to the provided minimum length. See `Validators.minLength` for additional information.
434 */
435export function minLengthValidator(minLength) {
436 return (control) => {
437 if (isEmptyInputValue(control.value) || !hasValidLength(control.value)) {
438 // don't validate empty values to allow optional controls
439 // don't validate values without `length` property
440 return null;
441 }
442 return control.value.length < minLength ?
443 { 'minlength': { 'requiredLength': minLength, 'actualLength': control.value.length } } :
444 null;
445 };
446}
447/**
448 * Validator that requires the length of the control's value to be less than or equal
449 * to the provided maximum length. See `Validators.maxLength` for additional information.
450 */
451export function maxLengthValidator(maxLength) {
452 return (control) => {
453 return hasValidLength(control.value) && control.value.length > maxLength ?
454 { 'maxlength': { 'requiredLength': maxLength, 'actualLength': control.value.length } } :
455 null;
456 };
457}
458/**
459 * Validator that requires the control's value to match a regex pattern.
460 * See `Validators.pattern` for additional information.
461 */
462export function patternValidator(pattern) {
463 if (!pattern)
464 return nullValidator;
465 let regex;
466 let regexStr;
467 if (typeof pattern === 'string') {
468 regexStr = '';
469 if (pattern.charAt(0) !== '^')
470 regexStr += '^';
471 regexStr += pattern;
472 if (pattern.charAt(pattern.length - 1) !== '$')
473 regexStr += '$';
474 regex = new RegExp(regexStr);
475 }
476 else {
477 regexStr = pattern.toString();
478 regex = pattern;
479 }
480 return (control) => {
481 if (isEmptyInputValue(control.value)) {
482 return null; // don't validate empty values to allow optional controls
483 }
484 const value = control.value;
485 return regex.test(value) ? null :
486 { 'pattern': { 'requiredPattern': regexStr, 'actualValue': value } };
487 };
488}
489/**
490 * Function that has `ValidatorFn` shape, but performs no operation.
491 */
492export function nullValidator(control) {
493 return null;
494}
495function isPresent(o) {
496 return o != null;
497}
498export function toObservable(r) {
499 const obs = isPromise(r) ? from(r) : r;
500 if (!(isObservable(obs)) && (typeof ngDevMode === 'undefined' || ngDevMode)) {
501 throw new Error(`Expected validator to return Promise or Observable.`);
502 }
503 return obs;
504}
505function mergeErrors(arrayOfErrors) {
506 let res = {};
507 // Not using Array.reduce here due to a Chrome 80 bug
508 // https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
509 arrayOfErrors.forEach((errors) => {
510 res = errors != null ? Object.assign(Object.assign({}, res), errors) : res;
511 });
512 return Object.keys(res).length === 0 ? null : res;
513}
514function executeValidators(control, validators) {
515 return validators.map(validator => validator(control));
516}
517function isValidatorFn(validator) {
518 return !validator.validate;
519}
520/**
521 * Given the list of validators that may contain both functions as well as classes, return the list
522 * of validator functions (convert validator classes into validator functions). This is needed to
523 * have consistent structure in validators list before composing them.
524 *
525 * @param validators The set of validators that may contain validators both in plain function form
526 * as well as represented as a validator class.
527 */
528export function normalizeValidators(validators) {
529 return validators.map(validator => {
530 return isValidatorFn(validator) ?
531 validator :
532 ((c) => validator.validate(c));
533 });
534}
535/**
536 * Merges synchronous validators into a single validator function.
537 * See `Validators.compose` for additional information.
538 */
539function compose(validators) {
540 if (!validators)
541 return null;
542 const presentValidators = validators.filter(isPresent);
543 if (presentValidators.length == 0)
544 return null;
545 return function (control) {
546 return mergeErrors(executeValidators(control, presentValidators));
547 };
548}
549/**
550 * Accepts a list of validators of different possible shapes (`Validator` and `ValidatorFn`),
551 * normalizes the list (converts everything to `ValidatorFn`) and merges them into a single
552 * validator function.
553 */
554export function composeValidators(validators) {
555 return validators != null ? compose(normalizeValidators(validators)) : null;
556}
557/**
558 * Merges asynchronous validators into a single validator function.
559 * See `Validators.composeAsync` for additional information.
560 */
561function composeAsync(validators) {
562 if (!validators)
563 return null;
564 const presentValidators = validators.filter(isPresent);
565 if (presentValidators.length == 0)
566 return null;
567 return function (control) {
568 const observables = executeValidators(control, presentValidators).map(toObservable);
569 return forkJoin(observables).pipe(map(mergeErrors));
570 };
571}
572/**
573 * Accepts a list of async validators of different possible shapes (`AsyncValidator` and
574 * `AsyncValidatorFn`), normalizes the list (converts everything to `AsyncValidatorFn`) and merges
575 * them into a single validator function.
576 */
577export function composeAsyncValidators(validators) {
578 return validators != null ? composeAsync(normalizeValidators(validators)) :
579 null;
580}
581/**
582 * Merges raw control validators with a given directive validator and returns the combined list of
583 * validators as an array.
584 */
585export function mergeValidators(controlValidators, dirValidator) {
586 if (controlValidators === null)
587 return [dirValidator];
588 return Array.isArray(controlValidators) ? [...controlValidators, dirValidator] :
589 [controlValidators, dirValidator];
590}
591/**
592 * Retrieves the list of raw synchronous validators attached to a given control.
593 */
594export function getControlValidators(control) {
595 return control._rawValidators;
596}
597/**
598 * Retrieves the list of raw asynchronous validators attached to a given control.
599 */
600export function getControlAsyncValidators(control) {
601 return control._rawAsyncValidators;
602}
603/**
604 * Accepts a singleton validator, an array, or null, and returns an array type with the provided
605 * validators.
606 *
607 * @param validators A validator, validators, or null.
608 * @returns A validators array.
609 */
610export function makeValidatorsArray(validators) {
611 if (!validators)
612 return [];
613 return Array.isArray(validators) ? validators : [validators];
614}
615/**
616 * Determines whether a validator or validators array has a given validator.
617 *
618 * @param validators The validator or validators to compare against.
619 * @param validator The validator to check.
620 * @returns Whether the validator is present.
621 */
622export function hasValidator(validators, validator) {
623 return Array.isArray(validators) ? validators.includes(validator) : validators === validator;
624}
625/**
626 * Combines two arrays of validators into one. If duplicates are provided, only one will be added.
627 *
628 * @param validators The new validators.
629 * @param currentValidators The base array of currrent validators.
630 * @returns An array of validators.
631 */
632export function addValidators(validators, currentValidators) {
633 const current = makeValidatorsArray(currentValidators);
634 const validatorsToAdd = makeValidatorsArray(validators);
635 validatorsToAdd.forEach((v) => {
636 // Note: if there are duplicate entries in the new validators array,
637 // only the first one would be added to the current list of validarors.
638 // Duplicate ones would be ignored since `hasValidator` would detect
639 // the presence of a validator function and we update the current list in place.
640 if (!hasValidator(current, v)) {
641 current.push(v);
642 }
643 });
644 return current;
645}
646export function removeValidators(validators, currentValidators) {
647 return makeValidatorsArray(currentValidators).filter(v => !hasValidator(validators, v));
648}
649//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../../../../../packages/forms/src/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 {InjectionToken, ɵisObservable as isObservable, ɵisPromise as isPromise} from '@angular/core';\nimport {forkJoin, from, Observable} from 'rxjs';\nimport {map} from 'rxjs/operators';\n\nimport {AsyncValidator, AsyncValidatorFn, ValidationErrors, Validator, ValidatorFn} from './directives/validators';\nimport {AbstractControl} from './model';\n\nfunction isEmptyInputValue(value: any): boolean {\n  // we don't check for string here so it also works with arrays\n  return value == null || value.length === 0;\n}\n\nfunction hasValidLength(value: any): boolean {\n  // non-strict comparison is intentional, to check for both `null` and `undefined` values\n  return value != null && typeof value.length === 'number';\n}\n\n/**\n * @description\n * An `InjectionToken` for registering additional synchronous validators used with\n * `AbstractControl`s.\n *\n * @see `NG_ASYNC_VALIDATORS`\n *\n * @usageNotes\n *\n * ### Providing a custom validator\n *\n * The following example registers a custom validator directive. Adding the validator to the\n * existing collection of validators requires the `multi: true` option.\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 const NG_VALIDATORS = new InjectionToken<Array<Validator|Function>>('NgValidators');\n\n/**\n * @description\n * An `InjectionToken` for registering additional asynchronous validators used with\n * `AbstractControl`s.\n *\n * @see `NG_VALIDATORS`\n *\n * @publicApi\n */\nexport const NG_ASYNC_VALIDATORS =\n    new InjectionToken<Array<Validator|Function>>('NgAsyncValidators');\n\n/**\n * A regular expression that matches valid e-mail addresses.\n *\n * At a high level, this regexp matches e-mail addresses of the format `local-part@tld`, where:\n * - `local-part` consists of one or more of the allowed characters (alphanumeric and some\n *   punctuation symbols).\n * - `local-part` cannot begin or end with a period (`.`).\n * - `local-part` cannot be longer than 64 characters.\n * - `tld` consists of one or more `labels` separated by periods (`.`). For example `localhost` or\n *   `foo.com`.\n * - A `label` consists of one or more of the allowed characters (alphanumeric, dashes (`-`) and\n *   periods (`.`)).\n * - A `label` cannot begin or end with a dash (`-`) or a period (`.`).\n * - A `label` cannot be longer than 63 characters.\n * - The whole address cannot be longer than 254 characters.\n *\n * ## Implementation background\n *\n * This regexp was ported over from AngularJS (see there for git history):\n * https://github.com/angular/angular.js/blob/c133ef836/src/ng/directive/input.js#L27\n * It is based on the\n * [WHATWG version](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address) with\n * some enhancements to incorporate more RFC rules (such as rules related to domain names and the\n * lengths of different parts of the address). The main differences from the WHATWG version are:\n *   - Disallow `local-part` to begin or end with a period (`.`).\n *   - Disallow `local-part` length to exceed 64 characters.\n *   - Disallow total address length to exceed 254 characters.\n *\n * See [this commit](https://github.com/angular/angular.js/commit/f3f5cf72e) for more details.\n */\nconst EMAIL_REGEXP =\n    /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n\n/**\n * @description\n * Provides a set of built-in validators that can be used by form controls.\n *\n * A validator is a function that processes a `FormControl` or collection of\n * controls and returns an error map or null. A null map means that validation has passed.\n *\n * @see [Form Validation](/guide/form-validation)\n *\n * @publicApi\n */\nexport class Validators {\n  /**\n   * @description\n   * Validator that requires the control's value to be greater than or equal to the provided number.\n   *\n   * @usageNotes\n   *\n   * ### Validate against a minimum of 3\n   *\n   * ```typescript\n   * const control = new FormControl(2, Validators.min(3));\n   *\n   * console.log(control.errors); // {min: {min: 3, actual: 2}}\n   * ```\n   *\n   * @returns A validator function that returns an error map with the\n   * `min` property if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static min(min: number): ValidatorFn {\n    return minValidator(min);\n  }\n\n  /**\n   * @description\n   * Validator that requires the control's value to be less than or equal to the provided number.\n   *\n   * @usageNotes\n   *\n   * ### Validate against a maximum of 15\n   *\n   * ```typescript\n   * const control = new FormControl(16, Validators.max(15));\n   *\n   * console.log(control.errors); // {max: {max: 15, actual: 16}}\n   * ```\n   *\n   * @returns A validator function that returns an error map with the\n   * `max` property if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static max(max: number): ValidatorFn {\n    return maxValidator(max);\n  }\n\n  /**\n   * @description\n   * Validator that requires the control have a non-empty value.\n   *\n   * @usageNotes\n   *\n   * ### Validate that the field is non-empty\n   *\n   * ```typescript\n   * const control = new FormControl('', Validators.required);\n   *\n   * console.log(control.errors); // {required: true}\n   * ```\n   *\n   * @returns An error map with the `required` property\n   * if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static required(control: AbstractControl): ValidationErrors|null {\n    return requiredValidator(control);\n  }\n\n  /**\n   * @description\n   * Validator that requires the control's value be true. This validator is commonly\n   * used for required checkboxes.\n   *\n   * @usageNotes\n   *\n   * ### Validate that the field value is true\n   *\n   * ```typescript\n   * const control = new FormControl('', Validators.requiredTrue);\n   *\n   * console.log(control.errors); // {required: true}\n   * ```\n   *\n   * @returns An error map that contains the `required` property\n   * set to `true` if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static requiredTrue(control: AbstractControl): ValidationErrors|null {\n    return requiredTrueValidator(control);\n  }\n\n  /**\n   * @description\n   * Validator that requires the control's value pass an email validation test.\n   *\n   * Tests the value using a [regular\n   * expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions)\n   * pattern suitable for common usecases. The pattern is based on the definition of a valid email\n   * address in the [WHATWG HTML\n   * specification](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address) with\n   * some enhancements to incorporate more RFC rules (such as rules related to domain names and the\n   * lengths of different parts of the address).\n   *\n   * The differences from the WHATWG version include:\n   * - Disallow `local-part` (the part before the `@` symbol) to begin or end with a period (`.`).\n   * - Disallow `local-part` to be longer than 64 characters.\n   * - Disallow the whole address to be longer than 254 characters.\n   *\n   * If this pattern does not satisfy your business needs, you can use `Validators.pattern()` to\n   * validate the value against a different pattern.\n   *\n   * @usageNotes\n   *\n   * ### Validate that the field matches a valid email pattern\n   *\n   * ```typescript\n   * const control = new FormControl('bad@', Validators.email);\n   *\n   * console.log(control.errors); // {email: true}\n   * ```\n   *\n   * @returns An error map with the `email` property\n   * if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static email(control: AbstractControl): ValidationErrors|null {\n    return emailValidator(control);\n  }\n\n  /**\n   * @description\n   * Validator that requires the length of the control's value to be greater than or equal\n   * to the provided minimum length. This validator is also provided by default if you use the\n   * the HTML5 `minlength` attribute. Note that the `minLength` validator is intended to be used\n   * only for types that have a numeric `length` property, such as strings or arrays. The\n   * `minLength` validator logic is also not invoked for values when their `length` property is 0\n   * (for example in case of an empty string or an empty array), to support optional controls. You\n   * can use the standard `required` validator if empty values should not be considered valid.\n   *\n   * @usageNotes\n   *\n   * ### Validate that the field has a minimum of 3 characters\n   *\n   * ```typescript\n   * const control = new FormControl('ng', Validators.minLength(3));\n   *\n   * console.log(control.errors); // {minlength: {requiredLength: 3, actualLength: 2}}\n   * ```\n   *\n   * ```html\n   * <input minlength=\"5\">\n   * ```\n   *\n   * @returns A validator function that returns an error map with the\n   * `minlength` property if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static minLength(minLength: number): ValidatorFn {\n    return minLengthValidator(minLength);\n  }\n\n  /**\n   * @description\n   * Validator that requires the length of the control's value to be less than or equal\n   * to the provided maximum length. This validator is also provided by default if you use the\n   * the HTML5 `maxlength` attribute. Note that the `maxLength` validator is intended to be used\n   * only for types that have a numeric `length` property, such as strings or arrays.\n   *\n   * @usageNotes\n   *\n   * ### Validate that the field has maximum of 5 characters\n   *\n   * ```typescript\n   * const control = new FormControl('Angular', Validators.maxLength(5));\n   *\n   * console.log(control.errors); // {maxlength: {requiredLength: 5, actualLength: 7}}\n   * ```\n   *\n   * ```html\n   * <input maxlength=\"5\">\n   * ```\n   *\n   * @returns A validator function that returns an error map with the\n   * `maxlength` property if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static maxLength(maxLength: number): ValidatorFn {\n    return maxLengthValidator(maxLength);\n  }\n\n  /**\n   * @description\n   * Validator that requires the control's value to match a regex pattern. This validator is also\n   * provided by default if you use the HTML5 `pattern` attribute.\n   *\n   * @usageNotes\n   *\n   * ### Validate that the field only contains letters or spaces\n   *\n   * ```typescript\n   * const control = new FormControl('1', Validators.pattern('[a-zA-Z ]*'));\n   *\n   * console.log(control.errors); // {pattern: {requiredPattern: '^[a-zA-Z ]*$', actualValue: '1'}}\n   * ```\n   *\n   * ```html\n   * <input pattern=\"[a-zA-Z ]*\">\n   * ```\n   *\n   * ### Pattern matching with the global or sticky flag\n   *\n   * `RegExp` objects created with the `g` or `y` flags that are passed into `Validators.pattern`\n   * can produce different results on the same input when validations are run consecutively. This is\n   * due to how the behavior of `RegExp.prototype.test` is\n   * specified in [ECMA-262](https://tc39.es/ecma262/#sec-regexpbuiltinexec)\n   * (`RegExp` preserves the index of the last match when the global or sticky flag is used).\n   * Due to this behavior, it is recommended that when using\n   * `Validators.pattern` you **do not** pass in a `RegExp` object with either the global or sticky\n   * flag enabled.\n   *\n   * ```typescript\n   * // Not recommended (since the `g` flag is used)\n   * const controlOne = new FormControl('1', Validators.pattern(/foo/g));\n   *\n   * // Good\n   * const controlTwo = new FormControl('1', Validators.pattern(/foo/));\n   * ```\n   *\n   * @param pattern A regular expression to be used as is to test the values, or a string.\n   * If a string is passed, the `^` character is prepended and the `$` character is\n   * appended to the provided string (if not already present), and the resulting regular\n   * expression is used to test the values.\n   *\n   * @returns A validator function that returns an error map with the\n   * `pattern` property if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static pattern(pattern: string|RegExp): ValidatorFn {\n    return patternValidator(pattern);\n  }\n\n  /**\n   * @description\n   * Validator that performs no operation.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static nullValidator(control: AbstractControl): ValidationErrors|null {\n    return nullValidator(control);\n  }\n\n  /**\n   * @description\n   * Compose multiple validators into a single function that returns the union\n   * of the individual error maps for the provided control.\n   *\n   * @returns A validator function that returns an error map with the\n   * merged error maps of the validators if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static compose(validators: null): null;\n  static compose(validators: (ValidatorFn|null|undefined)[]): ValidatorFn|null;\n  static compose(validators: (ValidatorFn|null|undefined)[]|null): ValidatorFn|null {\n    return compose(validators);\n  }\n\n  /**\n   * @description\n   * Compose multiple async validators into a single function that returns the union\n   * of the individual error objects for the provided control.\n   *\n   * @returns A validator function that returns an error map with the\n   * merged error objects of the async validators if the validation check fails, otherwise `null`.\n   *\n   * @see `updateValueAndValidity()`\n   *\n   */\n  static composeAsync(validators: (AsyncValidatorFn|null)[]): AsyncValidatorFn|null {\n    return composeAsync(validators);\n  }\n}\n\n/**\n * Validator that requires the control's value to be greater than or equal to the provided number.\n * See `Validators.min` for additional information.\n */\nexport function minValidator(min: number): ValidatorFn {\n  return (control: AbstractControl): ValidationErrors|null => {\n    if (isEmptyInputValue(control.value) || isEmptyInputValue(min)) {\n      return null;  // don't validate empty values to allow optional controls\n    }\n    const value = parseFloat(control.value);\n    // Controls with NaN values after parsing should be treated as not having a\n    // minimum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-min\n    return !isNaN(value) && value < min ? {'min': {'min': min, 'actual': control.value}} : null;\n  };\n}\n\n/**\n * Validator that requires the control's value to be less than or equal to the provided number.\n * See `Validators.max` for additional information.\n */\nexport function maxValidator(max: number): ValidatorFn {\n  return (control: AbstractControl): ValidationErrors|null => {\n    if (isEmptyInputValue(control.value) || isEmptyInputValue(max)) {\n      return null;  // don't validate empty values to allow optional controls\n    }\n    const value = parseFloat(control.value);\n    // Controls with NaN values after parsing should be treated as not having a\n    // maximum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-max\n    return !isNaN(value) && value > max ? {'max': {'max': max, 'actual': control.value}} : null;\n  };\n}\n\n/**\n * Validator that requires the control have a non-empty value.\n * See `Validators.required` for additional information.\n */\nexport function requiredValidator(control: AbstractControl): ValidationErrors|null {\n  return isEmptyInputValue(control.value) ? {'required': true} : null;\n}\n\n/**\n * Validator that requires the control's value be true. This validator is commonly\n * used for required checkboxes.\n * See `Validators.requiredTrue` for additional information.\n */\nexport function requiredTrueValidator(control: AbstractControl): ValidationErrors|null {\n  return control.value === true ? null : {'required': true};\n}\n\n/**\n * Validator that requires the control's value pass an email validation test.\n * See `Validators.email` for additional information.\n */\nexport function emailValidator(control: AbstractControl): ValidationErrors|null {\n  if (isEmptyInputValue(control.value)) {\n    return null;  // don't validate empty values to allow optional controls\n  }\n  return EMAIL_REGEXP.test(control.value) ? null : {'email': true};\n}\n\n/**\n * Validator that requires the length of the control's value to be greater than or equal\n * to the provided minimum length. See `Validators.minLength` for additional information.\n */\nexport function minLengthValidator(minLength: number): ValidatorFn {\n  return (control: AbstractControl): ValidationErrors|null => {\n    if (isEmptyInputValue(control.value) || !hasValidLength(control.value)) {\n      // don't validate empty values to allow optional controls\n      // don't validate values without `length` property\n      return null;\n    }\n\n    return control.value.length < minLength ?\n        {'minlength': {'requiredLength': minLength, 'actualLength': control.value.length}} :\n        null;\n  };\n}\n\n/**\n * Validator that requires the length of the control's value to be less than or equal\n * to the provided maximum length. See `Validators.maxLength` for additional information.\n */\nexport function maxLengthValidator(maxLength: number): ValidatorFn {\n  return (control: AbstractControl): ValidationErrors|null => {\n    return hasValidLength(control.value) && control.value.length > maxLength ?\n        {'maxlength': {'requiredLength': maxLength, 'actualLength': control.value.length}} :\n        null;\n  };\n}\n\n/**\n * Validator that requires the control's value to match a regex pattern.\n * See `Validators.pattern` for additional information.\n */\nexport function patternValidator(pattern: string|RegExp): ValidatorFn {\n  if (!pattern) return nullValidator;\n  let regex: RegExp;\n  let regexStr: string;\n  if (typeof pattern === 'string') {\n    regexStr = '';\n\n    if (pattern.charAt(0) !== '^') regexStr += '^';\n\n    regexStr += pattern;\n\n    if (pattern.charAt(pattern.length - 1) !== '$') regexStr += '$';\n\n    regex = new RegExp(regexStr);\n  } else {\n    regexStr = pattern.toString();\n    regex = pattern;\n  }\n  return (control: AbstractControl): ValidationErrors|null => {\n    if (isEmptyInputValue(control.value)) {\n      return null;  // don't validate empty values to allow optional controls\n    }\n    const value: string = control.value;\n    return regex.test(value) ? null :\n                               {'pattern': {'requiredPattern': regexStr, 'actualValue': value}};\n  };\n}\n\n/**\n * Function that has `ValidatorFn` shape, but performs no operation.\n */\nexport function nullValidator(control: AbstractControl): ValidationErrors|null {\n  return null;\n}\n\nfunction isPresent(o: any): boolean {\n  return o != null;\n}\n\nexport function toObservable(r: any): Observable<any> {\n  const obs = isPromise(r) ? from(r) : r;\n  if (!(isObservable(obs)) && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n    throw new Error(`Expected validator to return Promise or Observable.`);\n  }\n  return obs;\n}\n\nfunction mergeErrors(arrayOfErrors: (ValidationErrors|null)[]): ValidationErrors|null {\n  let res: {[key: string]: any} = {};\n\n  // Not using Array.reduce here due to a Chrome 80 bug\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=1049982\n  arrayOfErrors.forEach((errors: ValidationErrors|null) => {\n    res = errors != null ? {...res!, ...errors} : res!;\n  });\n\n  return Object.keys(res).length === 0 ? null : res;\n}\n\ntype GenericValidatorFn = (control: AbstractControl) => any;\n\nfunction executeValidators<V extends GenericValidatorFn>(\n    control: AbstractControl, validators: V[]): ReturnType<V>[] {\n  return validators.map(validator => validator(control));\n}\n\nfunction isValidatorFn<V>(validator: V|Validator|AsyncValidator): validator is V {\n  return !(validator as Validator).validate;\n}\n\n/**\n * Given the list of validators that may contain both functions as well as classes, return the list\n * of validator functions (convert validator classes into validator functions). This is needed to\n * have consistent structure in validators list before composing them.\n *\n * @param validators The set of validators that may contain validators both in plain function form\n *     as well as represented as a validator class.\n */\nexport function normalizeValidators<V>(validators: (V|Validator|AsyncValidator)[]): V[] {\n  return validators.map(validator => {\n    return isValidatorFn<V>(validator) ?\n        validator :\n        ((c: AbstractControl) => validator.validate(c)) as unknown as V;\n  });\n}\n\n/**\n * Merges synchronous validators into a single validator function.\n * See `Validators.compose` for additional information.\n */\nfunction compose(validators: (ValidatorFn|null|undefined)[]|null): ValidatorFn|null {\n  if (!validators) return null;\n  const presentValidators: ValidatorFn[] = validators.filter(isPresent) as any;\n  if (presentValidators.length == 0) return null;\n\n  return function(control: AbstractControl) {\n    return mergeErrors(executeValidators<ValidatorFn>(control, presentValidators));\n  };\n}\n\n/**\n * Accepts a list of validators of different possible shapes (`Validator` and `ValidatorFn`),\n * normalizes the list (converts everything to `ValidatorFn`) and merges them into a single\n * validator function.\n */\nexport function composeValidators(validators: Array<Validator|ValidatorFn>): ValidatorFn|null {\n  return validators != null ? compose(normalizeValidators<ValidatorFn>(validators)) : null;\n}\n\n/**\n * Merges asynchronous validators into a single validator function.\n * See `Validators.composeAsync` for additional information.\n */\nfunction composeAsync(validators: (AsyncValidatorFn|null)[]): AsyncValidatorFn|null {\n  if (!validators) return null;\n  const presentValidators: AsyncValidatorFn[] = validators.filter(isPresent) as any;\n  if (presentValidators.length == 0) return null;\n\n  return function(control: AbstractControl) {\n    const observables =\n        executeValidators<AsyncValidatorFn>(control, presentValidators).map(toObservable);\n    return forkJoin(observables).pipe(map(mergeErrors));\n  };\n}\n\n/**\n * Accepts a list of async validators of different possible shapes (`AsyncValidator` and\n * `AsyncValidatorFn`), normalizes the list (converts everything to `AsyncValidatorFn`) and merges\n * them into a single validator function.\n */\nexport function composeAsyncValidators(validators: Array<AsyncValidator|AsyncValidatorFn>):\n    AsyncValidatorFn|null {\n  return validators != null ? composeAsync(normalizeValidators<AsyncValidatorFn>(validators)) :\n                              null;\n}\n\n/**\n * Merges raw control validators with a given directive validator and returns the combined list of\n * validators as an array.\n */\nexport function mergeValidators<V>(controlValidators: V|V[]|null, dirValidator: V): V[] {\n  if (controlValidators === null) return [dirValidator];\n  return Array.isArray(controlValidators) ? [...controlValidators, dirValidator] :\n                                            [controlValidators, dirValidator];\n}\n\n/**\n * Retrieves the list of raw synchronous validators attached to a given control.\n */\nexport function getControlValidators(control: AbstractControl): ValidatorFn|ValidatorFn[]|null {\n  return (control as any)._rawValidators as ValidatorFn | ValidatorFn[] | null;\n}\n\n/**\n * Retrieves the list of raw asynchronous validators attached to a given control.\n */\nexport function getControlAsyncValidators(control: AbstractControl): AsyncValidatorFn|\n    AsyncValidatorFn[]|null {\n  return (control as any)._rawAsyncValidators as AsyncValidatorFn | AsyncValidatorFn[] | null;\n}\n\n/**\n * Accepts a singleton validator, an array, or null, and returns an array type with the provided\n * validators.\n *\n * @param validators A validator, validators, or null.\n * @returns A validators array.\n */\nexport function makeValidatorsArray<T extends ValidatorFn|AsyncValidatorFn>(validators: T|T[]|\n                                                                            null): T[] {\n  if (!validators) return [];\n  return Array.isArray(validators) ? validators : [validators];\n}\n\n/**\n * Determines whether a validator or validators array has a given validator.\n *\n * @param validators The validator or validators to compare against.\n * @param validator The validator to check.\n * @returns Whether the validator is present.\n */\nexport function hasValidator<T extends ValidatorFn|AsyncValidatorFn>(\n    validators: T|T[]|null, validator: T): boolean {\n  return Array.isArray(validators) ? validators.includes(validator) : validators === validator;\n}\n\n/**\n * Combines two arrays of validators into one. If duplicates are provided, only one will be added.\n *\n * @param validators The new validators.\n * @param currentValidators The base array of currrent validators.\n * @returns An array of validators.\n */\nexport function addValidators<T extends ValidatorFn|AsyncValidatorFn>(\n    validators: T|T[], currentValidators: T|T[]|null): T[] {\n  const current = makeValidatorsArray(currentValidators);\n  const validatorsToAdd = makeValidatorsArray(validators);\n  validatorsToAdd.forEach((v: T) => {\n    // Note: if there are duplicate entries in the new validators array,\n    // only the first one would be added to the current list of validarors.\n    // Duplicate ones would be ignored since `hasValidator` would detect\n    // the presence of a validator function and we update the current list in place.\n    if (!hasValidator(current, v)) {\n      current.push(v);\n    }\n  });\n  return current;\n}\n\nexport function removeValidators<T extends ValidatorFn|AsyncValidatorFn>(\n    validators: T|T[], currentValidators: T|T[]|null): T[] {\n  return makeValidatorsArray(currentValidators).filter(v => !hasValidator(validators, v));\n}\n"]}
Note: See TracBrowser for help on using the repository browser.