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

style(lint): re-format modules/@angular

Browse Source
This commit is contained in:
Alex Eagle
2016-06-08 16:38:52 -07:00
parent bbed364e7b
commit f39c9c9e75
589 changed files with 21829 additions and 24259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
modules/@angular/core/src/di/decorators.ts
View File

@ -1,13 +1,8 @@
import {
InjectMetadata,
OptionalMetadata,
InjectableMetadata,
SelfMetadata,
HostMetadata,
SkipSelfMetadata
} from './metadata';
import {makeDecorator, makeParamDecorator} from '../util/decorators';
import {HostMetadata, InjectMetadata, InjectableMetadata, OptionalMetadata, SelfMetadata, SkipSelfMetadata} from './metadata';
/**
* Factory for creating {@link InjectMetadata}.
* @stable

3
modules/@angular/core/src/di/forward_ref.ts
View File

@ -1,4 +1,5 @@
import {Type, stringify, isFunction} from '../facade/lang';
import {Type, isFunction, stringify} from '../facade/lang';
/**
* An interface that a function passed into {@link forwardRef} has to implement.

37
modules/@angular/core/src/di/provider.ts
View File

@ -1,5 +1,6 @@
import {normalizeBool, Type, isType, isBlank, isFunction, stringify} from '../facade/lang';
import {BaseException} from '../facade/exceptions';
import {Type, isBlank, isFunction, isType, normalizeBool, stringify} from '../facade/lang';
/**
* Describes how the {@link Injector} should instantiate a given token.
@ -148,14 +149,15 @@ export class Provider {
/** @internal */
_multi: boolean;
constructor(token: any /** TODO #9100 */, {useClass, useValue, useExisting, useFactory, deps, multi}: {
useClass?: Type,
useValue?: any,
useExisting?: any,
useFactory?: Function,
deps?: Object[],
multi?: boolean
}) {
constructor(
token: any /** TODO #9100 */, {useClass, useValue, useExisting, useFactory, deps, multi}: {
useClass?: Type,
useValue?: any,
useExisting?: any,
useFactory?: Function,
deps?: Object[],
multi?: boolean
}) {
this.token = token;
this.useClass = useClass;
this.useValue = useValue;
@ -388,14 +390,15 @@ export class ProviderBuilder {
* <!-- TODO: improve the docs -->
* @deprecated
*/
export function provide(token: any /** TODO #9100 */, {useClass, useValue, useExisting, useFactory, deps, multi}: {
useClass?: Type,
useValue?: any,
useExisting?: any,
useFactory?: Function,
deps?: Object[],
multi?: boolean
}): Provider {
export function provide(
token: any /** TODO #9100 */, {useClass, useValue, useExisting, useFactory, deps, multi}: {
useClass?: Type,
useValue?: any,
useExisting?: any,
useFactory?: Function,
deps?: Object[],
multi?: boolean
}): Provider {
return new Provider(token, {
useClass: useClass,
useValue: useValue,

34
modules/@angular/core/src/di/reflective_exceptions.ts
View File

@ -1,8 +1,9 @@
import {ListWrapper} from '../facade/collection';
import {stringify, isBlank} from '../facade/lang';
import {BaseException, WrappedException} from '../facade/exceptions';
import {ReflectiveKey} from './reflective_key';
import {isBlank, stringify} from '../facade/lang';
import {ReflectiveInjector} from './reflective_injector';
import {ReflectiveKey} from './reflective_key';
function findFirstClosedCycle(keys: any[]): any[] {
var res: any[] /** TODO #9100 */ = [];
@ -21,9 +22,9 @@ function constructResolvingPath(keys: any[]): string {
if (keys.length > 1) {
var reversed = findFirstClosedCycle(ListWrapper.reversed(keys));
var tokenStrs = reversed.map(k => stringify(k.token));
return " (" + tokenStrs.join(' -> ') + ")";
return ' (' + tokenStrs.join(' -> ') + ')';
} else {
return "";
return '';
}
}
@ -45,9 +46,9 @@ export class AbstractProviderError extends BaseException {
/** @internal */
constructResolvingMessage: Function;
constructor(injector: ReflectiveInjector, key: ReflectiveKey,
constructResolvingMessage: Function) {
super("DI Exception");
constructor(
injector: ReflectiveInjector, key: ReflectiveKey, constructResolvingMessage: Function) {
super('DI Exception');
this.keys = [key];
this.injectors = [injector];
this.constructResolvingMessage = constructResolvingMessage;
@ -146,8 +147,10 @@ export class InstantiationError extends WrappedException {
/** @internal */
injectors: ReflectiveInjector[];
constructor(injector: ReflectiveInjector, originalException: any /** TODO #9100 */, originalStack: any /** TODO #9100 */, key: ReflectiveKey) {
super("DI Exception", originalException, originalStack, null);
constructor(
injector: ReflectiveInjector, originalException: any /** TODO #9100 */,
originalStack: any /** TODO #9100 */, key: ReflectiveKey) {
super('DI Exception', originalException, originalStack, null);
this.keys = [key];
this.injectors = [injector];
}
@ -228,10 +231,10 @@ export class NoAnnotationError extends BaseException {
signature.push(parameter.map(stringify).join(' '));
}
}
return "Cannot resolve all parameters for '" + stringify(typeOrFunc) + "'(" +
signature.join(', ') + "). " +
"Make sure that all the parameters are decorated with Inject or have valid type annotations and that '" +
stringify(typeOrFunc) + "' is decorated with Injectable.";
return 'Cannot resolve all parameters for \'' + stringify(typeOrFunc) + '\'(' +
signature.join(', ') + '). ' +
'Make sure that all the parameters are decorated with Inject or have valid type annotations and that \'' +
stringify(typeOrFunc) + '\' is decorated with Injectable.';
}
}
@ -268,7 +271,8 @@ export class OutOfBoundsError extends BaseException {
*/
export class MixingMultiProvidersWithRegularProvidersError extends BaseException {
constructor(provider1: any /** TODO #9100 */, provider2: any /** TODO #9100 */) {
super("Cannot mix multi providers and regular providers, got: " + provider1.toString() + " " +
provider2.toString());
super(
'Cannot mix multi providers and regular providers, got: ' + provider1.toString() + ' ' +
provider2.toString());
}
}

105
modules/@angular/core/src/di/reflective_injector.ts
View File

@ -1,23 +1,13 @@
import {ListWrapper} from '../facade/collection';
import {Provider} from './provider';
import {
ResolvedReflectiveProvider,
ReflectiveDependency,
ResolvedReflectiveFactory,
resolveReflectiveProviders
} from './reflective_provider';
import {
AbstractProviderError,
NoProviderError,
CyclicDependencyError,
InstantiationError,
OutOfBoundsError
} from './reflective_exceptions';
import {Type} from '../facade/lang';
import {BaseException, unimplemented} from '../facade/exceptions';
import {ReflectiveKey} from './reflective_key';
import {SelfMetadata, SkipSelfMetadata} from './metadata';
import {Type} from '../facade/lang';
import {Injector, THROW_IF_NOT_FOUND} from './injector';
import {SelfMetadata, SkipSelfMetadata} from './metadata';
import {Provider} from './provider';
import {AbstractProviderError, CyclicDependencyError, InstantiationError, NoProviderError, OutOfBoundsError} from './reflective_exceptions';
import {ReflectiveKey} from './reflective_key';
import {ReflectiveDependency, ResolvedReflectiveFactory, ResolvedReflectiveProvider, resolveReflectiveProviders} from './reflective_provider';
var __unused: Type; // avoid unused import when Type union types are erased
@ -154,8 +144,8 @@ export class ReflectiveProtoInjector {
constructor(providers: ResolvedReflectiveProvider[]) {
this.numberOfProviders = providers.length;
this._strategy = providers.length > _MAX_CONSTRUCTION_COUNTER ?
new ReflectiveProtoInjectorDynamicStrategy(this, providers) :
new ReflectiveProtoInjectorInlineStrategy(this, providers);
new ReflectiveProtoInjectorDynamicStrategy(this, providers) :
new ReflectiveProtoInjectorInlineStrategy(this, providers);
}
getProviderAtIndex(index: number): ResolvedReflectiveProvider {
@ -186,8 +176,9 @@ export class ReflectiveInjectorInlineStrategy implements ReflectiveInjectorStrat
obj8: any = UNDEFINED;
obj9: any = UNDEFINED;
constructor(public injector: ReflectiveInjector_,
public protoStrategy: ReflectiveProtoInjectorInlineStrategy) {}
constructor(
public injector: ReflectiveInjector_,
public protoStrategy: ReflectiveProtoInjectorInlineStrategy) {}
resetConstructionCounter(): void { this.injector._constructionCounter = 0; }
@ -284,8 +275,9 @@ export class ReflectiveInjectorInlineStrategy implements ReflectiveInjectorStrat
export class ReflectiveInjectorDynamicStrategy implements ReflectiveInjectorStrategy {
objs: any[];
constructor(public protoStrategy: ReflectiveProtoInjectorDynamicStrategy,
public injector: ReflectiveInjector_) {
constructor(
public protoStrategy: ReflectiveProtoInjectorDynamicStrategy,
public injector: ReflectiveInjector_) {
this.objs = ListWrapper.createFixedSize(protoStrategy.providers.length);
ListWrapper.fill(this.objs, UNDEFINED);
}
@ -390,7 +382,7 @@ export abstract class ReflectiveInjector implements Injector {
*
* See {@link ReflectiveInjector#fromResolvedProviders} for more info.
*/
static resolve(providers: Array<Type | Provider | {[k: string]: any} | any[]>):
static resolve(providers: Array<Type|Provider|{[k: string]: any}|any[]>):
ResolvedReflectiveProvider[] {
return resolveReflectiveProviders(providers);
}
@ -421,8 +413,9 @@ export abstract class ReflectiveInjector implements Injector {
* because it needs to resolve the passed-in providers first.
* See {@link Injector#resolve} and {@link Injector#fromResolvedProviders}.
*/
static resolveAndCreate(providers: Array<Type | Provider | {[k: string]: any} | any[]>,
parent: Injector = null): ReflectiveInjector {
static resolveAndCreate(
providers: Array<Type|Provider|{[k: string]: any}|any[]>,
parent: Injector = null): ReflectiveInjector {
var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
}
@ -450,10 +443,10 @@ export abstract class ReflectiveInjector implements Injector {
* ```
* @experimental
*/
static fromResolvedProviders(providers: ResolvedReflectiveProvider[],
parent: Injector = null): ReflectiveInjector {
return new ReflectiveInjector_(ReflectiveProtoInjector.fromResolvedProviders(providers),
parent);
static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent: Injector = null):
ReflectiveInjector {
return new ReflectiveInjector_(
ReflectiveProtoInjector.fromResolvedProviders(providers), parent);
}
/**
@ -513,8 +506,8 @@ export abstract class ReflectiveInjector implements Injector {
* because it needs to resolve the passed-in providers first.
* See {@link Injector#resolve} and {@link Injector#createChildFromResolved}.
*/
resolveAndCreateChild(
providers: Array<Type | Provider | {[k: string]: any} | any[]>): ReflectiveInjector {
resolveAndCreateChild(providers: Array<Type|Provider|{[k: string]: any}|any[]>):
ReflectiveInjector {
return unimplemented();
}
@ -571,7 +564,7 @@ export abstract class ReflectiveInjector implements Injector {
* expect(car).not.toBe(injector.resolveAndInstantiate(Car));
* ```
*/
resolveAndInstantiate(provider: Type | Provider): any { return unimplemented(); }
resolveAndInstantiate(provider: Type|Provider): any { return unimplemented(); }
/**
* Instantiates an object using a resolved provider in the context of the injector.
@ -613,8 +606,9 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
/**
* Private
*/
constructor(_proto: any /* ProtoInjector */, _parent: Injector = null,
private _debugContext: Function = null) {
constructor(
_proto: any /* ProtoInjector */, _parent: Injector = null,
private _debugContext: Function = null) {
this._proto = _proto;
this._parent = _parent;
this._strategy = _proto._strategy.createInjectorStrategy(this);
@ -640,7 +634,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
*/
get internalStrategy(): any { return this._strategy; }
resolveAndCreateChild(providers: Array<Type | Provider | any[]>): ReflectiveInjector {
resolveAndCreateChild(providers: Array<Type|Provider|any[]>): ReflectiveInjector {
var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
return this.createChildFromResolved(ResolvedReflectiveProviders);
}
@ -652,7 +646,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
return inj;
}
resolveAndInstantiate(provider: Type | Provider): any {
resolveAndInstantiate(provider: Type|Provider): any {
return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);
}
@ -680,8 +674,9 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
}
}
private _instantiate(provider: ResolvedReflectiveProvider,
ResolvedReflectiveFactory: ResolvedReflectiveFactory): any {
private _instantiate(
provider: ResolvedReflectiveProvider,
ResolvedReflectiveFactory: ResolvedReflectiveFactory): any {
var factory = ResolvedReflectiveFactory.factory;
var deps = ResolvedReflectiveFactory.dependencies;
var length = deps.length;
@ -792,16 +787,17 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16);
break;
case 18:
obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16,
d17);
obj = factory(
d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17);
break;
case 19:
obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16,
d17, d18);
obj = factory(
d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18);
break;
case 20:
obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16,
d17, d18, d19);
obj = factory(
d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18,
d19);
break;
default:
throw new BaseException(
@ -813,14 +809,16 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
return obj;
}
private _getByReflectiveDependency(provider: ResolvedReflectiveProvider,
dep: ReflectiveDependency): any {
return this._getByKey(dep.key, dep.lowerBoundVisibility, dep.upperBoundVisibility,
dep.optional ? null : THROW_IF_NOT_FOUND);
private _getByReflectiveDependency(
provider: ResolvedReflectiveProvider, dep: ReflectiveDependency): any {
return this._getByKey(
dep.key, dep.lowerBoundVisibility, dep.upperBoundVisibility,
dep.optional ? null : THROW_IF_NOT_FOUND);
}
private _getByKey(key: ReflectiveKey, lowerBoundVisibility: Object, upperBoundVisibility: Object,
notFoundValue: any): any {
private _getByKey(
key: ReflectiveKey, lowerBoundVisibility: Object, upperBoundVisibility: Object,
notFoundValue: any): any {
if (key === INJECTOR_KEY) {
return this;
}
@ -872,7 +870,10 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
}
get displayName(): string {
return `ReflectiveInjector(providers: [${_mapProviders(this, (b: ResolvedReflectiveProvider) => ` "${b.key.displayName}" `).join(", ")}])`;
const providers =
_mapProviders(this, (b: ResolvedReflectiveProvider) => ' "' + b.key.displayName + '" ')
.join(', ');
return `ReflectiveInjector(providers: [${providers}])`;
}
toString(): string { return this.displayName; }

4
modules/@angular/core/src/di/reflective_key.ts
View File

@ -1,7 +1,9 @@
import {stringify, isBlank} from '../facade/lang';
import {BaseException} from '../facade/exceptions';
import {isBlank, stringify} from '../facade/lang';
import {resolveForwardRef} from './forward_ref';
/**
* A unique object used for retrieving items from the {@link ReflectiveInjector}.
*

59
modules/@angular/core/src/di/reflective_provider.ts
View File

@ -1,25 +1,9 @@
import {
Type,
isBlank,
isPresent,
isArray,
} from '../facade/lang';
import {Type, isBlank, isPresent, isArray,} from '../facade/lang';
import {MapWrapper, ListWrapper} from '../facade/collection';
import {reflector} from '../reflection/reflection';
import {ReflectiveKey} from './reflective_key';
import {
InjectMetadata,
OptionalMetadata,
SelfMetadata,
HostMetadata,
SkipSelfMetadata,
DependencyMetadata
} from './metadata';
import {
NoAnnotationError,
MixingMultiProvidersWithRegularProvidersError,
InvalidProviderError
} from './reflective_exceptions';
import {InjectMetadata, OptionalMetadata, SelfMetadata, HostMetadata, SkipSelfMetadata, DependencyMetadata} from './metadata';
import {NoAnnotationError, MixingMultiProvidersWithRegularProvidersError, InvalidProviderError} from './reflective_exceptions';
import {resolveForwardRef} from './forward_ref';
import {Provider, ProviderBuilder, provide} from './provider';
import {isProviderLiteral, createProvider} from './provider_util';
@ -29,8 +13,9 @@ import {isProviderLiteral, createProvider} from './provider_util';
* This is internal to Angular and should not be used directly.
*/
export class ReflectiveDependency {
constructor(public key: ReflectiveKey, public optional: boolean, public lowerBoundVisibility: any,
public upperBoundVisibility: any, public properties: any[]) {}
constructor(
public key: ReflectiveKey, public optional: boolean, public lowerBoundVisibility: any,
public upperBoundVisibility: any, public properties: any[]) {}
static fromKey(key: ReflectiveKey): ReflectiveDependency {
return new ReflectiveDependency(key, false, null, null, []);
@ -80,8 +65,9 @@ export interface ResolvedReflectiveProvider {
export interface ResolvedReflectiveBinding extends ResolvedReflectiveProvider {}
export class ResolvedReflectiveProvider_ implements ResolvedReflectiveBinding {
constructor(public key: ReflectiveKey, public resolvedFactories: ResolvedReflectiveFactory[],
public multiProvider: boolean) {}
constructor(
public key: ReflectiveKey, public resolvedFactories: ResolvedReflectiveFactory[],
public multiProvider: boolean) {}
get resolvedFactory(): ResolvedReflectiveFactory { return this.resolvedFactories[0]; }
}
@ -134,15 +120,15 @@ export function resolveReflectiveFactory(provider: Provider): ResolvedReflective
* convenience provider syntax.
*/
export function resolveReflectiveProvider(provider: Provider): ResolvedReflectiveProvider {
return new ResolvedReflectiveProvider_(ReflectiveKey.get(provider.token),
[resolveReflectiveFactory(provider)], provider.multi);
return new ResolvedReflectiveProvider_(
ReflectiveKey.get(provider.token), [resolveReflectiveFactory(provider)], provider.multi);
}
/**
* Resolve a list of Providers.
*/
export function resolveReflectiveProviders(
providers: Array<Type | Provider | {[k: string]: any} | any[]>): ResolvedReflectiveProvider[] {
providers: Array<Type|Provider|{[k: string]: any}|any[]>): ResolvedReflectiveProvider[] {
var normalized = _normalizeProviders(providers, []);
var resolved = normalized.map(resolveReflectiveProvider);
return MapWrapper.values(
@ -187,7 +173,7 @@ export function mergeResolvedReflectiveProviders(
}
function _normalizeProviders(
providers: Array<Type | Provider | {[k: string]: any} | ProviderBuilder | any[]>,
providers: Array<Type|Provider|{[k: string]: any}|ProviderBuilder|any[]>,
res: Provider[]): Provider[] {
providers.forEach(b => {
if (b instanceof Type) {
@ -213,8 +199,8 @@ function _normalizeProviders(
return res;
}
export function constructDependencies(typeOrFunc: any,
dependencies: any[]): ReflectiveDependency[] {
export function constructDependencies(
typeOrFunc: any, dependencies: any[]): ReflectiveDependency[] {
if (isBlank(dependencies)) {
return _dependenciesFor(typeOrFunc);
} else {
@ -232,8 +218,9 @@ function _dependenciesFor(typeOrFunc: any): ReflectiveDependency[] {
return params.map((p: any[]) => _extractToken(typeOrFunc, p, params));
}
function _extractToken(typeOrFunc: any /** TODO #9100 */, metadata: any /** TODO #9100 */ /*any[] | any*/,
params: any[][]): ReflectiveDependency {
function _extractToken(
typeOrFunc: any /** TODO #9100 */, metadata: any /** TODO #9100 */ /*any[] | any*/,
params: any[][]): ReflectiveDependency {
var depProps: any[] /** TODO #9100 */ = [];
var token: any /** TODO #9100 */ = null;
var optional = false;
@ -287,8 +274,10 @@ function _extractToken(typeOrFunc: any /** TODO #9100 */, metadata: any /** TODO
}
}
function _createDependency(token: any /** TODO #9100 */, optional: any /** TODO #9100 */, lowerBoundVisibility: any /** TODO #9100 */, upperBoundVisibility: any /** TODO #9100 */,
depProps: any /** TODO #9100 */): ReflectiveDependency {
return new ReflectiveDependency(ReflectiveKey.get(token), optional, lowerBoundVisibility,
upperBoundVisibility, depProps);
function _createDependency(
token: any /** TODO #9100 */, optional: any /** TODO #9100 */,
lowerBoundVisibility: any /** TODO #9100 */, upperBoundVisibility: any /** TODO #9100 */,
depProps: any /** TODO #9100 */): ReflectiveDependency {
return new ReflectiveDependency(
ReflectiveKey.get(token), optional, lowerBoundVisibility, upperBoundVisibility, depProps);
}