angular-docs-cn/modules/angular2/src/common/forms/directives/validators.ts

import {forwardRef, Provider, Attribute, Directive} from 'angular2/core';
import {CONST_EXPR} from 'angular2/src/facade/lang';
import {Validators, NG_VALIDATORS} from '../validators';
import {AbstractControl} from '../model';
import * as modelModule from '../model';
import {NumberWrapper} from 'angular2/src/facade/lang';



/**
 * An interface that can be implemented by classes that can act as validators.
 *
 * ## Usage
 *
 * ```typescript
 * @Directive({
 *   selector: '[custom-validator]',
 *   providers: [provide(NG_VALIDATORS, {useExisting: CustomValidatorDirective, multi: true})]
 * })
 * class CustomValidatorDirective implements Validator {
 *   validate(c: Control): {[key: string]: any} {
 *     return {"custom": true};
 *   }
 * }
 * ```
 */
export interface Validator { validate(c: modelModule.AbstractControl): {[key: string]: any}; }

const REQUIRED = Validators.required;

const REQUIRED_VALIDATOR =
    CONST_EXPR(new Provider(NG_VALIDATORS, {useValue: REQUIRED, multi: true}));

/**
 * A Directive that adds the `required` validator to any controls marked with the
 * `required` attribute, via the {@link NG_VALIDATORS} binding.
 *
 * ### Example
 *
 * ```
 * <input ngControl="fullName" required>
 * ```
 */
@Directive({
  selector: '[required][ngControl],[required][ngFormControl],[required][ngModel]',
  providers: [REQUIRED_VALIDATOR]
})
export class RequiredValidator {
}

export interface ValidatorFn { (c: AbstractControl): {[key: string]: any}; }
export interface AsyncValidatorFn {
  (c: AbstractControl): any /*Promise<{[key: string]: any}>|Observable<{[key: string]: any}>*/;
}

/**
 * Provivder which adds {@link MinLengthValidator} to {@link NG_VALIDATORS}.
 *
 * ## Example:
 *
 * {@example common/forms/ts/validators/validators.ts region='min'}
 */
const MIN_LENGTH_VALIDATOR = CONST_EXPR(
    new Provider(NG_VALIDATORS, {useExisting: forwardRef(() => MinLengthValidator), multi: true}));

/**
 * A directive which installs the {@link MinLengthValidator} for any `ngControl`,
 * `ngFormControl`, or control with `ngModel` that also has a `minlength` attribute.
 */
@Directive({
  selector: '[minlength][ngControl],[minlength][ngFormControl],[minlength][ngModel]',
  providers: [MIN_LENGTH_VALIDATOR]
})
export class MinLengthValidator implements Validator {
  private _validator: ValidatorFn;

  constructor(@Attribute('minlength') minLength: string) {
    this._validator = Validators.minLength(NumberWrapper.parseInt(minLength, 10));
  }

  validate(c: AbstractControl): {[key: string]: any} { return this._validator(c); }
}

/**
 * Provider which adds {@link MaxLengthValidator} to {@link NG_VALIDATORS}.
 *
 * ## Example:
 *
 * {@example common/forms/ts/validators/validators.ts region='max'}
 */
const MAX_LENGTH_VALIDATOR = CONST_EXPR(
    new Provider(NG_VALIDATORS, {useExisting: forwardRef(() => MaxLengthValidator), multi: true}));

/**
 * A directive which installs the {@link MaxLengthValidator} for any `ngControl, `ngFormControl`,
 * or control with `ngModel` that also has a `maxlength` attribute.
 */
@Directive({
  selector: '[maxlength][ngControl],[maxlength][ngFormControl],[maxlength][ngModel]',
  providers: [MAX_LENGTH_VALIDATOR]
})
export class MaxLengthValidator implements Validator {
  private _validator: ValidatorFn;

  constructor(@Attribute('maxlength') maxLength: string) {
    this._validator = Validators.maxLength(NumberWrapper.parseInt(maxLength, 10));
  }

  validate(c: AbstractControl): {[key: string]: any} { return this._validator(c); }
}


/**
 * A Directive that adds the `pattern` validator to any controls marked with the
 * `pattern` attribute, via the {@link NG_VALIDATORS} binding. Uses attribute value
 * as the regex to validate Control value against.  Follows pattern attribute
 * semantics; i.e. regex must match entire Control value.
 *
 * ### Example
 *
 * ```
 * <input [ngControl]="fullName" pattern="[a-zA-Z ]*">
 * ```
 */
const PATTERN_VALIDATOR = CONST_EXPR(
    new Provider(NG_VALIDATORS, {useExisting: forwardRef(() => PatternValidator), multi: true}));
@Directive({
  selector: '[pattern][ngControl],[pattern][ngFormControl],[pattern][ngModel]',
  providers: [PATTERN_VALIDATOR]
})
export class PatternValidator implements Validator {
  private _validator: ValidatorFn;

  constructor(@Attribute('pattern') pattern: string) {
    this._validator = Validators.pattern(pattern);
  }

  validate(c: AbstractControl): {[key: string]: any} { return this._validator(c); }
}