TypeScript core.forwardRef函数代码示例

export function ValidatorProviderFactory(type: Type<any>): Provider {
    return {
        provide: NG_VALIDATORS,
        useExisting: forwardRef(() => type),
        multi: true
    };
}

 public static createAccessorProvider(component:any):any {
     return {
         provide: NG_VALUE_ACCESSOR,
         useExisting: forwardRef(() => component),
         multi: true
     };
 }

export function ControlValueAccessorProviderFactory(type: Type<any>): Provider {
    return {
        provide: NG_VALUE_ACCESSOR,
        useExisting: forwardRef(() => type),
        multi: true
    };
}

import { Directive, forwardRef } from '@angular/core';
import { NG_VALIDATORS, Validator, AbstractControl } from '@angular/forms';

import { url } from './';

const URL_VALIDATOR: any = {
  provide: NG_VALIDATORS,
  useExisting: forwardRef(() => UrlValidator),
  multi: true
};

@Directive({
  selector: '[url][formControlName],[url][formControl],[url][ngModel]',
  providers: [URL_VALIDATOR]
})
export class UrlValidator implements Validator {
  validate(c: AbstractControl): {[key: string]: any} {
    return url(c);
  }
}

import { Directive, ElementRef, forwardRef } from "@angular/core";
import { NG_VALUE_ACCESSOR } from "@angular/forms";
import { BaseValueAccessor } from "./base-value-accessor";
import { View } from "tns-core-modules/ui/core/view";

const TEXT_VALUE_ACCESSOR = {
    provide: NG_VALUE_ACCESSOR,
    useExisting: forwardRef(() => TextValueAccessor),
    multi: true,
};

export type TextView = {text: string} & View;

/**
 * The accessor for writing a text and listening to changes that is used by the
 * {@link NgModel} directives.
 *
 *  ### Example
 *  ```
 *  <TextField [(ngModel)]="model.test">
 *  ```
 */
@Directive({
    selector:
        "TextField[ngModel],TextField[formControlName],TextField[formControl]," +
        "textField[ngModel],textField[formControlName],textField[formControl]," +
        "textfield[ngModel],textfield[formControlName],textfield[formControl]," +
        "text-field[ngModel],text-field[formControlName],text-field[formControl]," +

        "TextView[ngModel],TextView[formControlName],TextView[formControl]," +
        "textView[ngModel],textView[formControlName],textView[formControl]," +

import { Directive, ElementRef, forwardRef } from "@angular/core";
import { NG_VALUE_ACCESSOR } from "@angular/forms";
import { BaseValueAccessor } from "./base-value-accessor";
import { Slider } from "tns-core-modules/ui/slider";

const NUMBER_VALUE_ACCESSOR = {
    provide: NG_VALUE_ACCESSOR,
    useExisting: forwardRef(() => NumberValueAccessor),
    multi: true,
};

/**
 * The accessor for setting a value and listening to changes that is used by the
 * {@link NgModel}
 *
 *  ### Example
 *  ```
 *  <Slider [(ngModel)]="model.test">
 *  ```
 */
@Directive({
    selector:
        "Slider[ngModel],Slider[formControlName],Slider[formControl]," +
        "slider[ngModel],slider[formControlName],slider[formControl]",
    providers: [NUMBER_VALUE_ACCESSOR],
    host: {
        "(valueChange)": "onChange($event.value)",
    },
})
export class NumberValueAccessor extends BaseValueAccessor<Slider> { // tslint:disable-line:directive-class-suffix
    constructor(elementRef: ElementRef) {

                 .then((compFixture) => {
                   let nestedChildCompEl = compFixture.debugElement.children[0].children[0];
                   let nestedChildComp: NestedChildComp = nestedChildCompEl.componentInstance;
                   expect(nestedChildComp.cfr.resolveComponentFactory(ChildComp).componentType)
                       .toBe(ChildComp);
                   expect(() => nestedChildComp.cfr.resolveComponentFactory(NestedChildComp))
                       .toThrow(new NoComponentFactoryError(NestedChildComp));
                   async.done();
                 });
           }));

  });
}

var DIRECTIVES: any[] = [
  forwardRef(() => NestedChildComp),
  forwardRef(() => ChildComp),
  forwardRef(() => MainComp),
];

@Component({selector: 'nested', directives: DIRECTIVES, template: ''})
class NestedChildComp {
  constructor(public cfr: ComponentFactoryResolver) {}
}

@Component({selector: 'child', precompile: [NestedChildComp], directives: DIRECTIVES, template: ''})
class ChildComp {
  constructor(public cfr: ComponentFactoryResolver) {}
}

@Component({

import { Directive, Input, forwardRef, OnInit } from '@angular/core';
import { NG_VALIDATORS, Validator, ValidatorFn, AbstractControl } from '@angular/forms';

import { CustomValidators } from '../';

const EQUAL_TO_VALIDATOR: any = {
    provide: NG_VALIDATORS,
    useExisting: forwardRef(() => EqualToValidator),
    multi: true
};

@Directive({
    selector: '[equalTo][formControlName],[equalTo][formControl],[equalTo][ngModel]',
    providers: [EQUAL_TO_VALIDATOR]
})
export class EqualToValidator implements Validator, OnInit {
    @Input() equalTo: AbstractControl;

    private validator: ValidatorFn;

    ngOnInit() {
        this.validator = CustomValidators.equalTo(this.equalTo);
    }

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

 *
 * @stable
 */
export interface Validator {
  validate(c: AbstractControl): ValidationErrors|null;
  registerOnValidatorChange?(fn: () => void): void;
}

/** @experimental */
export interface AsyncValidator extends Validator {
  validate(c: AbstractControl): Promise<ValidationErrors|null>|Observable<ValidationErrors|null>;
}

export const REQUIRED_VALIDATOR: Provider = {
  provide: NG_VALIDATORS,
  useExisting: forwardRef(() => RequiredValidator),
  multi: true
};

export const CHECKBOX_REQUIRED_VALIDATOR: Provider = {
  provide: NG_VALIDATORS,
  useExisting: forwardRef(() => CheckboxRequiredValidator),
  multi: true
};


/**
 * A Directive that adds the `required` validator to any controls marked with the
 * `required` attribute, via the {@link NG_VALIDATORS} binding.
 *
 * ### Example