cargdev/angular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(Type): merge Type and ConcreType<?> into Type<?> (#10616)

Browse Source 
Closes #9729

BREAKING CHANGE:

`Type` is now `Type<T>` which means that in most cases you have to
use `Type<any>` in place of `Type`.

We don't expect that any user applications use the `Type` type.
This commit is contained in:
Miško Hevery
2016-08-10 18:21:28 -07:00
committed by vikerman
parent 6f4ee6101c
commit b96869afd2
91 changed files with 637 additions and 714 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
modules/@angular/compiler/testing/directive_resolver_mock.ts
View File

@ -6,11 +6,12 @@
* found in the LICENSE file at https://angular.io/license
*/
import {AnimationEntryMetadata, BaseException, Compiler, ComponentMetadata, DirectiveMetadata, Injectable, Injector, ViewMetadata, resolveForwardRef} from '@angular/core';
import {AnimationEntryMetadata, Compiler, ComponentMetadata, DirectiveMetadata, Injectable, Injector, Type, ViewMetadata, resolveForwardRef} from '@angular/core';
import {DirectiveResolver} from '../src/directive_resolver';
import {Map} from '../src/facade/collection';
import {Type, isArray, isPresent, stringify} from '../src/facade/lang';
import {BaseException} from '../src/facade/exceptions';
import {isArray, isPresent, stringify} from '../src/facade/lang';
@ -20,21 +21,21 @@ import {Type, isArray, isPresent, stringify} from '../src/facade/lang';
*/
@Injectable()
export class MockDirectiveResolver extends DirectiveResolver {
private _directives = new Map<Type, DirectiveMetadata>();
private _providerOverrides = new Map<Type, any[]>();
private _viewProviderOverrides = new Map<Type, any[]>();
private _views = new Map<Type, ViewMetadata>();
private _inlineTemplates = new Map<Type, string>();
private _animations = new Map<Type, AnimationEntryMetadata[]>();
private _directiveOverrides = new Map<Type, Map<Type, Type>>();
private _directives = new Map<Type<any>, DirectiveMetadata>();
private _providerOverrides = new Map<Type<any>, any[]>();
private _viewProviderOverrides = new Map<Type<any>, any[]>();
private _views = new Map<Type<any>, ViewMetadata>();
private _inlineTemplates = new Map<Type<any>, string>();
private _animations = new Map<Type<any>, AnimationEntryMetadata[]>();
private _directiveOverrides = new Map<Type<any>, Map<Type<any>, Type<any>>>();
constructor(private _injector: Injector) { super(); }
private get _compiler(): Compiler { return this._injector.get(Compiler); }
private _clearCacheFor(component: Type) { this._compiler.clearCacheFor(component); }
private _clearCacheFor(component: Type<any>) { this._compiler.clearCacheFor(component); }
resolve(type: Type, throwIfNotFound = true): DirectiveMetadata {
resolve(type: Type<any>, throwIfNotFound = true): DirectiveMetadata {
let metadata = this._directives.get(type);
if (!metadata) {
metadata = super.resolve(type, throwIfNotFound);
@ -134,17 +135,17 @@ export class MockDirectiveResolver extends DirectiveResolver {
/**
* Overrides the {@link DirectiveMetadata} for a directive.
*/
setDirective(type: Type, metadata: DirectiveMetadata): void {
setDirective(type: Type<any>, metadata: DirectiveMetadata): void {
this._directives.set(type, metadata);
this._clearCacheFor(type);
}
setProvidersOverride(type: Type, providers: any[]): void {
setProvidersOverride(type: Type<any>, providers: any[]): void {
this._providerOverrides.set(type, providers);
this._clearCacheFor(type);
}
setViewProvidersOverride(type: Type, viewProviders: any[]): void {
setViewProvidersOverride(type: Type<any>, viewProviders: any[]): void {
this._viewProviderOverrides.set(type, viewProviders);
this._clearCacheFor(type);
}
@ -152,19 +153,19 @@ export class MockDirectiveResolver extends DirectiveResolver {
/**
* Overrides the {@link ViewMetadata} for a component.
*/
setView(component: Type, view: ViewMetadata): void {
setView(component: Type<any>, view: ViewMetadata): void {
this._views.set(component, view);
this._clearCacheFor(component);
}
/**
* Overrides the inline template for a component - other configuration remains unchanged.
*/
setInlineTemplate(component: Type, template: string): void {
setInlineTemplate(component: Type<any>, template: string): void {
this._inlineTemplates.set(component, template);
this._clearCacheFor(component);
}
setAnimations(component: Type, animations: AnimationEntryMetadata[]): void {
setAnimations(component: Type<any>, animations: AnimationEntryMetadata[]): void {
this._animations.set(component, animations);
this._clearCacheFor(component);
}
@ -172,11 +173,11 @@ export class MockDirectiveResolver extends DirectiveResolver {
/**
* Overrides a directive from the component {@link ViewMetadata}.
*/
overrideViewDirective(component: Type, from: Type, to: Type): void {
overrideViewDirective(component: Type<any>, from: Type<any>, to: Type<any>): void {
var overrides = this._directiveOverrides.get(component);
if (!overrides) {
overrides = new Map<Type, Type>();
overrides = new Map<Type<any>, Type<any>>();
this._directiveOverrides.set(component, overrides);
}
@ -185,7 +186,7 @@ export class MockDirectiveResolver extends DirectiveResolver {
}
}
function flattenArray(tree: any[], out: Array<Type|any[]>): void {
function flattenArray(tree: any[], out: Array<Type<any>|any[]>): void {
if (!isPresent(tree)) return;
for (var i = 0; i < tree.length; i++) {
var item = resolveForwardRef(tree[i]);

5
modules/@angular/compiler/testing/metadata_overrider.ts
View File

@ -6,10 +6,9 @@
* found in the LICENSE file at https://angular.io/license
*/
import {BaseException} from '@angular/core';
import {MetadataOverride} from '@angular/core/testing';
import {ConcreteType, stringify} from '../src/facade/lang';
import {BaseException} from '../src/facade/exceptions';
import {stringify} from '../src/facade/lang';
type StringMap = {
[key: string]: any

8
modules/@angular/compiler/testing/ng_module_resolver_mock.ts
View File

@ -13,18 +13,18 @@ import {Map} from '../src/facade/collection';
@Injectable()
export class MockNgModuleResolver extends NgModuleResolver {
private _ngModules = new Map<Type, NgModuleMetadata>();
private _ngModules = new Map<Type<any>, NgModuleMetadata>();
constructor(private _injector: Injector) { super(); }
private get _compiler(): Compiler { return this._injector.get(Compiler); }
private _clearCacheFor(component: Type) { this._compiler.clearCacheFor(component); }
private _clearCacheFor(component: Type<any>) { this._compiler.clearCacheFor(component); }
/**
* Overrides the {@link NgModuleMetadata} for a module.
*/
setNgModule(type: Type, metadata: NgModuleMetadata): void {
setNgModule(type: Type<any>, metadata: NgModuleMetadata): void {
this._ngModules.set(type, metadata);
this._clearCacheFor(type);
}
@ -35,7 +35,7 @@ export class MockNgModuleResolver extends NgModuleResolver {
* default
* `NgModuleResolver`, see `setNgModule`.
*/
resolve(type: Type, throwIfNotFound = true): NgModuleMetadata {
resolve(type: Type<any>, throwIfNotFound = true): NgModuleMetadata {
var metadata = this._ngModules.get(type);
if (!metadata) {
metadata = super.resolve(type, throwIfNotFound);

8
modules/@angular/compiler/testing/pipe_resolver_mock.ts
View File

@ -13,18 +13,18 @@ import {Map} from '../src/facade/collection';
@Injectable()
export class MockPipeResolver extends PipeResolver {
private _pipes = new Map<Type, PipeMetadata>();
private _pipes = new Map<Type<any>, PipeMetadata>();
constructor(private _injector: Injector) { super(); }
private get _compiler(): Compiler { return this._injector.get(Compiler); }
private _clearCacheFor(pipe: Type) { this._compiler.clearCacheFor(pipe); }
private _clearCacheFor(pipe: Type<any>) { this._compiler.clearCacheFor(pipe); }
/**
* Overrides the {@link PipeMetadata} for a pipe.
*/
setPipe(type: Type, metadata: PipeMetadata): void {
setPipe(type: Type<any>, metadata: PipeMetadata): void {
this._pipes.set(type, metadata);
this._clearCacheFor(type);
}
@ -35,7 +35,7 @@ export class MockPipeResolver extends PipeResolver {
* default
* `PipeResolver`, see `setPipe`.
*/
resolve(type: Type, throwIfNotFound = true): PipeMetadata {
resolve(type: Type<any>, throwIfNotFound = true): PipeMetadata {
var metadata = this._pipes.get(type);
if (!metadata) {
metadata = super.resolve(type, throwIfNotFound);

36
modules/@angular/compiler/testing/test_component_builder.ts
View File

@ -6,12 +6,13 @@
* found in the LICENSE file at https://angular.io/license
*/
import {AnimationEntryMetadata, Compiler, ComponentFactory, Inject, Injectable, Injector, NgZone, ViewMetadata} from '@angular/core';
import {AnimationEntryMetadata, Compiler, ComponentFactory, Inject, Injectable, Injector, NgZone, Type, ViewMetadata} from '@angular/core';
import {ComponentFixture, ComponentFixtureNoNgZone, TestBed, TestComponentBuilder} from '@angular/core/testing';
import {DirectiveResolver} from '../index';
import {MapWrapper} from '../src/facade/collection';
import {ConcreteType, Type, isPresent} from '../src/facade/lang';
import {isPresent} from '../src/facade/lang';
/**
@ -23,17 +24,17 @@ import {ConcreteType, Type, isPresent} from '../src/facade/lang';
@Injectable()
export class OverridingTestComponentBuilder extends TestComponentBuilder {
/** @internal */
_bindingsOverrides = new Map<Type, any[]>();
_bindingsOverrides = new Map<Type<any>, any[]>();
/** @internal */
_directiveOverrides = new Map<Type, Map<Type, Type>>();
_directiveOverrides = new Map<Type<any>, Map<Type<any>, Type<any>>>();
/** @internal */
_templateOverrides = new Map<Type, string>();
_templateOverrides = new Map<Type<any>, string>();
/** @internal */
_animationOverrides = new Map<Type, AnimationEntryMetadata[]>();
_animationOverrides = new Map<Type<any>, AnimationEntryMetadata[]>();
/** @internal */
_viewBindingsOverrides = new Map<Type, any[]>();
_viewBindingsOverrides = new Map<Type<any>, any[]>();
/** @internal */
_viewOverrides = new Map<Type, ViewMetadata>();
_viewOverrides = new Map<Type<any>, ViewMetadata>();
constructor(@Inject(TestBed) injector: Injector) { super(injector); }
@ -48,54 +49,55 @@ export class OverridingTestComponentBuilder extends TestComponentBuilder {
return clone;
}
overrideTemplate(componentType: Type, template: string): OverridingTestComponentBuilder {
overrideTemplate(componentType: Type<any>, template: string): OverridingTestComponentBuilder {
let clone = this._clone();
clone._templateOverrides.set(componentType, template);
return clone;
}
overrideAnimations(componentType: Type, animations: AnimationEntryMetadata[]):
overrideAnimations(componentType: Type<any>, animations: AnimationEntryMetadata[]):
TestComponentBuilder {
var clone = this._clone();
clone._animationOverrides.set(componentType, animations);
return clone;
}
overrideView(componentType: Type, view: ViewMetadata): OverridingTestComponentBuilder {
overrideView(componentType: Type<any>, view: ViewMetadata): OverridingTestComponentBuilder {
let clone = this._clone();
clone._viewOverrides.set(componentType, view);
return clone;
}
overrideDirective(componentType: Type, from: Type, to: Type): OverridingTestComponentBuilder {
overrideDirective(componentType: Type<any>, from: Type<any>, to: Type<any>):
OverridingTestComponentBuilder {
let clone = this._clone();
let overridesForComponent = clone._directiveOverrides.get(componentType);
if (!isPresent(overridesForComponent)) {
clone._directiveOverrides.set(componentType, new Map<Type, Type>());
clone._directiveOverrides.set(componentType, new Map<Type<any>, Type<any>>());
overridesForComponent = clone._directiveOverrides.get(componentType);
}
overridesForComponent.set(from, to);
return clone;
}
overrideProviders(type: Type, providers: any[]): OverridingTestComponentBuilder {
overrideProviders(type: Type<any>, providers: any[]): OverridingTestComponentBuilder {
let clone = this._clone();
clone._bindingsOverrides.set(type, providers);
return clone;
}
overrideViewProviders(type: Type, providers: any[]): OverridingTestComponentBuilder {
overrideViewProviders(type: Type<any>, providers: any[]): OverridingTestComponentBuilder {
let clone = this._clone();
clone._viewBindingsOverrides.set(type, providers);
return clone;
}
createAsync<T>(rootComponentType: ConcreteType<T>): Promise<ComponentFixture<T>> {
createAsync<T>(rootComponentType: Type<T>): Promise<ComponentFixture<T>> {
this._applyMetadataOverrides();
return super.createAsync(rootComponentType);
}
createSync<T>(rootComponentType: ConcreteType<T>): ComponentFixture<T> {
createSync<T>(rootComponentType: Type<T>): ComponentFixture<T> {
this._applyMetadataOverrides();
return super.createSync(rootComponentType);
}