@angular/core
Version:
Angular - the core framework
373 lines • 30.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { Type } from '../interface/type';
import { reflector } from '../reflection/reflection';
import { resolveForwardRef } from './forward_ref';
import { InjectionToken } from './injection_token';
import { Inject, Optional, Self, SkipSelf } from './metadata';
import { invalidProviderError, mixingMultiProvidersWithRegularProvidersError, noAnnotationError } from './reflective_errors';
import { ReflectiveKey } from './reflective_key';
/**
* @record
*/
function NormalizedProvider() { }
/**
* `Dependency` is used by the framework to extend DI.
* This is internal to Angular and should not be used directly.
*/
export class ReflectiveDependency {
/**
* @param {?} key
* @param {?} optional
* @param {?} visibility
*/
constructor(key, optional, visibility) {
this.key = key;
this.optional = optional;
this.visibility = visibility;
}
/**
* @param {?} key
* @return {?}
*/
static fromKey(key) {
return new ReflectiveDependency(key, false, null);
}
}
if (false) {
/** @type {?} */
ReflectiveDependency.prototype.key;
/** @type {?} */
ReflectiveDependency.prototype.optional;
/** @type {?} */
ReflectiveDependency.prototype.visibility;
}
/** @type {?} */
const _EMPTY_LIST = [];
/**
* An internal resolved representation of a `Provider` used by the `Injector`.
*
* \@usageNotes
* This is usually created automatically by `Injector.resolveAndCreate`.
*
* It can be created manually, as follows:
*
* ### Example
*
* ```typescript
* var resolvedProviders = Injector.resolve([{ provide: 'message', useValue: 'Hello' }]);
* var injector = Injector.fromResolvedProviders(resolvedProviders);
*
* expect(injector.get('message')).toEqual('Hello');
* ```
*
* \@publicApi
* @record
*/
export function ResolvedReflectiveProvider() { }
if (false) {
/**
* A key, usually a `Type<any>`.
* @type {?}
*/
ResolvedReflectiveProvider.prototype.key;
/**
* Factory function which can return an instance of an object represented by a key.
* @type {?}
*/
ResolvedReflectiveProvider.prototype.resolvedFactories;
/**
* Indicates if the provider is a multi-provider or a regular provider.
* @type {?}
*/
ResolvedReflectiveProvider.prototype.multiProvider;
}
export class ResolvedReflectiveProvider_ {
/**
* @param {?} key
* @param {?} resolvedFactories
* @param {?} multiProvider
*/
constructor(key, resolvedFactories, multiProvider) {
this.key = key;
this.resolvedFactories = resolvedFactories;
this.multiProvider = multiProvider;
this.resolvedFactory = this.resolvedFactories[0];
}
}
if (false) {
/** @type {?} */
ResolvedReflectiveProvider_.prototype.resolvedFactory;
/** @type {?} */
ResolvedReflectiveProvider_.prototype.key;
/** @type {?} */
ResolvedReflectiveProvider_.prototype.resolvedFactories;
/** @type {?} */
ResolvedReflectiveProvider_.prototype.multiProvider;
}
/**
* An internal resolved representation of a factory function created by resolving `Provider`.
* \@publicApi
*/
export class ResolvedReflectiveFactory {
/**
* @param {?} factory
* @param {?} dependencies
*/
constructor(factory, dependencies) {
this.factory = factory;
this.dependencies = dependencies;
}
}
if (false) {
/**
* Factory function which can return an instance of an object represented by a key.
* @type {?}
*/
ResolvedReflectiveFactory.prototype.factory;
/**
* Arguments (dependencies) to the `factory` function.
* @type {?}
*/
ResolvedReflectiveFactory.prototype.dependencies;
}
/**
* Resolve a single provider.
* @param {?} provider
* @return {?}
*/
function resolveReflectiveFactory(provider) {
/** @type {?} */
let factoryFn;
/** @type {?} */
let resolvedDeps;
if (provider.useClass) {
/** @type {?} */
const useClass = resolveForwardRef(provider.useClass);
factoryFn = reflector.factory(useClass);
resolvedDeps = _dependenciesFor(useClass);
}
else if (provider.useExisting) {
factoryFn = (/**
* @param {?} aliasInstance
* @return {?}
*/
(aliasInstance) => aliasInstance);
resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];
}
else if (provider.useFactory) {
factoryFn = provider.useFactory;
resolvedDeps = constructDependencies(provider.useFactory, provider.deps);
}
else {
factoryFn = (/**
* @return {?}
*/
() => provider.useValue);
resolvedDeps = _EMPTY_LIST;
}
return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);
}
/**
* Converts the `Provider` into `ResolvedProvider`.
*
* `Injector` internally only uses `ResolvedProvider`, `Provider` contains convenience provider
* syntax.
* @param {?} provider
* @return {?}
*/
function resolveReflectiveProvider(provider) {
return new ResolvedReflectiveProvider_(ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)], provider.multi || false);
}
/**
* Resolve a list of Providers.
* @param {?} providers
* @return {?}
*/
export function resolveReflectiveProviders(providers) {
/** @type {?} */
const normalized = _normalizeProviders(providers, []);
/** @type {?} */
const resolved = normalized.map(resolveReflectiveProvider);
/** @type {?} */
const resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());
return Array.from(resolvedProviderMap.values());
}
/**
* Merges a list of ResolvedProviders into a list where each key is contained exactly once and
* multi providers have been merged.
* @param {?} providers
* @param {?} normalizedProvidersMap
* @return {?}
*/
export function mergeResolvedReflectiveProviders(providers, normalizedProvidersMap) {
for (let i = 0; i < providers.length; i++) {
/** @type {?} */
const provider = providers[i];
/** @type {?} */
const existing = normalizedProvidersMap.get(provider.key.id);
if (existing) {
if (provider.multiProvider !== existing.multiProvider) {
throw mixingMultiProvidersWithRegularProvidersError(existing, provider);
}
if (provider.multiProvider) {
for (let j = 0; j < provider.resolvedFactories.length; j++) {
existing.resolvedFactories.push(provider.resolvedFactories[j]);
}
}
else {
normalizedProvidersMap.set(provider.key.id, provider);
}
}
else {
/** @type {?} */
let resolvedProvider;
if (provider.multiProvider) {
resolvedProvider = new ResolvedReflectiveProvider_(provider.key, provider.resolvedFactories.slice(), provider.multiProvider);
}
else {
resolvedProvider = provider;
}
normalizedProvidersMap.set(provider.key.id, resolvedProvider);
}
}
return normalizedProvidersMap;
}
/**
* @param {?} providers
* @param {?} res
* @return {?}
*/
function _normalizeProviders(providers, res) {
providers.forEach((/**
* @param {?} b
* @return {?}
*/
b => {
if (b instanceof Type) {
res.push({ provide: b, useClass: b });
}
else if (b && typeof b == 'object' && ((/** @type {?} */ (b))).provide !== undefined) {
res.push((/** @type {?} */ (b)));
}
else if (b instanceof Array) {
_normalizeProviders(b, res);
}
else {
throw invalidProviderError(b);
}
}));
return res;
}
/**
* @param {?} typeOrFunc
* @param {?=} dependencies
* @return {?}
*/
export function constructDependencies(typeOrFunc, dependencies) {
if (!dependencies) {
return _dependenciesFor(typeOrFunc);
}
else {
/** @type {?} */
const params = dependencies.map((/**
* @param {?} t
* @return {?}
*/
t => [t]));
return dependencies.map((/**
* @param {?} t
* @return {?}
*/
t => _extractToken(typeOrFunc, t, params)));
}
}
/**
* @param {?} typeOrFunc
* @return {?}
*/
function _dependenciesFor(typeOrFunc) {
/** @type {?} */
const params = reflector.parameters(typeOrFunc);
if (!params)
return [];
if (params.some((/**
* @param {?} p
* @return {?}
*/
p => p == null))) {
throw noAnnotationError(typeOrFunc, params);
}
return params.map((/**
* @param {?} p
* @return {?}
*/
p => _extractToken(typeOrFunc, p, params)));
}
/**
* @param {?} typeOrFunc
* @param {?} metadata
* @param {?} params
* @return {?}
*/
function _extractToken(typeOrFunc, metadata, params) {
/** @type {?} */
let token = null;
/** @type {?} */
let optional = false;
if (!Array.isArray(metadata)) {
if (metadata instanceof Inject) {
return _createDependency(metadata.token, optional, null);
}
else {
return _createDependency(metadata, optional, null);
}
}
/** @type {?} */
let visibility = null;
for (let i = 0; i < metadata.length; ++i) {
/** @type {?} */
const paramMetadata = metadata[i];
if (paramMetadata instanceof Type) {
token = paramMetadata;
}
else if (paramMetadata instanceof Inject) {
token = paramMetadata.token;
}
else if (paramMetadata instanceof Optional) {
optional = true;
}
else if (paramMetadata instanceof Self || paramMetadata instanceof SkipSelf) {
visibility = paramMetadata;
}
else if (paramMetadata instanceof InjectionToken) {
token = paramMetadata;
}
}
token = resolveForwardRef(token);
if (token != null) {
return _createDependency(token, optional, visibility);
}
else {
throw noAnnotationError(typeOrFunc, params);
}
}
/**
* @param {?} token
* @param {?} optional
* @param {?} visibility
* @return {?}
*/
function _createDependency(token, optional, visibility) {
return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reflective_provider.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/di/reflective_provider.ts"],"names":[],"mappings":";;;;;;;;;;;AAQA,OAAO,EAAC,IAAI,EAAC,MAAM,mBAAmB,CAAC;AACvC,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAEjD,OAAO,EAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAC,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAC,oBAAoB,EAAE,6CAA6C,EAAE,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAC3H,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;;;;AAG/C,iCACsB;;;;;AAMtB,MAAM,OAAO,oBAAoB;;;;;;IAC/B,YACW,GAAkB,EAAS,QAAiB,EAAS,UAA8B;QAAnF,QAAG,GAAH,GAAG,CAAe;QAAS,aAAQ,GAAR,QAAQ,CAAS;QAAS,eAAU,GAAV,UAAU,CAAoB;IAAG,CAAC;;;;;IAElG,MAAM,CAAC,OAAO,CAAC,GAAkB;QAC/B,OAAO,IAAI,oBAAoB,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACpD,CAAC;CACF;;;IALK,mCAAyB;;IAAE,wCAAwB;;IAAE,0CAAqC;;;MAO1F,WAAW,GAAU,EAAE;;;;;;;;;;;;;;;;;;;;;AAqB7B,gDAeC;;;;;;IAXC,yCAAmB;;;;;IAKnB,uDAA+C;;;;;IAK/C,mDAAuB;;AAGzB,MAAM,OAAO,2BAA2B;;;;;;IAGtC,YACW,GAAkB,EAAS,iBAA8C,EACzE,aAAsB;QADtB,QAAG,GAAH,GAAG,CAAe;QAAS,sBAAiB,GAAjB,iBAAiB,CAA6B;QACzE,kBAAa,GAAb,aAAa,CAAS;QAC/B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC;CACF;;;IAPC,sDAAoD;;IAGhD,0CAAyB;;IAAE,wDAAqD;;IAChF,oDAA6B;;;;;;AASnC,MAAM,OAAO,yBAAyB;;;;;IACpC,YAIW,OAAiB,EAKjB,YAAoC;QALpC,YAAO,GAAP,OAAO,CAAU;QAKjB,iBAAY,GAAZ,YAAY,CAAwB;IAAG,CAAC;CACpD;;;;;;IANK,4CAAwB;;;;;IAKxB,iDAA2C;;;;;;;AAOjD,SAAS,wBAAwB,CAAC,QAA4B;;QACxD,SAAmB;;QACnB,YAAoC;IACxC,IAAI,QAAQ,CAAC,QAAQ,EAAE;;cACf,QAAQ,GAAG,iBAAiB,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACrD,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACxC,YAAY,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;KAC3C;SAAM,IAAI,QAAQ,CAAC,WAAW,EAAE;QAC/B,SAAS;;;;QAAG,CAAC,aAAkB,EAAE,EAAE,CAAC,aAAa,CAAA,CAAC;QAClD,YAAY,GAAG,CAAC,oBAAoB,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;KACxF;SAAM,IAAI,QAAQ,CAAC,UAAU,EAAE;QAC9B,SAAS,GAAG,QAAQ,CAAC,UAAU,CAAC;QAChC,YAAY,GAAG,qBAAqB,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;KAC1E;SAAM;QACL,SAAS;;;QAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAA,CAAC;QACpC,YAAY,GAAG,WAAW,CAAC;KAC5B;IACD,OAAO,IAAI,yBAAyB,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;AAChE,CAAC;;;;;;;;;AAQD,SAAS,yBAAyB,CAAC,QAA4B;IAC7D,OAAO,IAAI,2BAA2B,CAClC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC,EACzE,QAAQ,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC;AAC/B,CAAC;;;;;;AAKD,MAAM,UAAU,0BAA0B,CAAC,SAAqB;;UACxD,UAAU,GAAG,mBAAmB,CAAC,SAAS,EAAE,EAAE,CAAC;;UAC/C,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,yBAAyB,CAAC;;UACpD,mBAAmB,GAAG,gCAAgC,CAAC,QAAQ,EAAE,IAAI,GAAG,EAAE,CAAC;IACjF,OAAO,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,CAAC,CAAC;AAClD,CAAC;;;;;;;;AAMD,MAAM,UAAU,gCAAgC,CAC5C,SAAuC,EACvC,sBAA+D;IAEjE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;;cACnC,QAAQ,GAAG,SAAS,CAAC,CAAC,CAAC;;cACvB,QAAQ,GAAG,sBAAsB,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC5D,IAAI,QAAQ,EAAE;YACZ,IAAI,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,aAAa,EAAE;gBACrD,MAAM,6CAA6C,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;aACzE;YACD,IAAI,QAAQ,CAAC,aAAa,EAAE;gBAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBAC1D,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;iBAChE;aACF;iBAAM;gBACL,sBAAsB,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;aACvD;SACF;aAAM;;gBACD,gBAA4C;YAChD,IAAI,QAAQ,CAAC,aAAa,EAAE;gBAC1B,gBAAgB,GAAG,IAAI,2BAA2B,CAC9C,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,iBAAiB,CAAC,KAAK,EAAE,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC;aAC/E;iBAAM;gBACL,gBAAgB,GAAG,QAAQ,CAAC;aAC7B;YACD,sBAAsB,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;SAC/D;KACF;IACD,OAAO,sBAAsB,CAAC;AAChC,CAAC;;;;;;AAED,SAAS,mBAAmB,CAAC,SAAqB,EAAE,GAAe;IACjE,SAAS,CAAC,OAAO;;;;IAAC,CAAC,CAAC,EAAE;QACpB,IAAI,CAAC,YAAY,IAAI,EAAE;YACrB,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAC,CAAC,CAAC;SAErC;aAAM,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,QAAQ,IAAI,CAAC,mBAAA,CAAC,EAAO,CAAC,CAAC,OAAO,KAAK,SAAS,EAAE;YACxE,GAAG,CAAC,IAAI,CAAC,mBAAA,CAAC,EAAsB,CAAC,CAAC;SAEnC;aAAM,IAAI,CAAC,YAAY,KAAK,EAAE;YAC7B,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;SAE7B;aAAM;YACL,MAAM,oBAAoB,CAAC,CAAC,CAAC,CAAC;SAC/B;IACH,CAAC,EAAC,CAAC;IAEH,OAAO,GAAG,CAAC;AACb,CAAC;;;;;;AAED,MAAM,UAAU,qBAAqB,CACjC,UAAe,EAAE,YAAoB;IACvC,IAAI,CAAC,YAAY,EAAE;QACjB,OAAO,gBAAgB,CAAC,UAAU,CAAC,CAAC;KACrC;SAAM;;cACC,MAAM,GAAY,YAAY,CAAC,GAAG;;;;QAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAC;QAClD,OAAO,YAAY,CAAC,GAAG;;;;QAAC,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC,EAAE,MAAM,CAAC,EAAC,CAAC;KACpE;AACH,CAAC;;;;;AAED,SAAS,gBAAgB,CAAC,UAAe;;UACjC,MAAM,GAAG,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC;IAE/C,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IACvB,IAAI,MAAM,CAAC,IAAI;;;;IAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,EAAC,EAAE;QAC/B,MAAM,iBAAiB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;KAC7C;IACD,OAAO,MAAM,CAAC,GAAG;;;;IAAC,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC,EAAE,MAAM,CAAC,EAAC,CAAC;AAC/D,CAAC;;;;;;;AAED,SAAS,aAAa,CAClB,UAAe,EAAE,QAAqB,EAAE,MAAe;;QACrD,KAAK,GAAQ,IAAI;;QACjB,QAAQ,GAAG,KAAK;IAEpB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QAC5B,IAAI,QAAQ,YAAY,MAAM,EAAE;YAC9B,OAAO,iBAAiB,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;SAC1D;aAAM;YACL,OAAO,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;SACpD;KACF;;QAEG,UAAU,GAAuB,IAAI;IAEzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;;cAClC,aAAa,GAAG,QAAQ,CAAC,CAAC,CAAC;QAEjC,IAAI,aAAa,YAAY,IAAI,EAAE;YACjC,KAAK,GAAG,aAAa,CAAC;SAEvB;aAAM,IAAI,aAAa,YAAY,MAAM,EAAE;YAC1C,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC;SAE7B;aAAM,IAAI,aAAa,YAAY,QAAQ,EAAE;YAC5C,QAAQ,GAAG,IAAI,CAAC;SAEjB;aAAM,IAAI,aAAa,YAAY,IAAI,IAAI,aAAa,YAAY,QAAQ,EAAE;YAC7E,UAAU,GAAG,aAAa,CAAC;SAC5B;aAAM,IAAI,aAAa,YAAY,cAAc,EAAE;YAClD,KAAK,GAAG,aAAa,CAAC;SACvB;KACF;IAED,KAAK,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAEjC,IAAI,KAAK,IAAI,IAAI,EAAE;QACjB,OAAO,iBAAiB,CAAC,KAAK,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;KACvD;SAAM;QACL,MAAM,iBAAiB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;KAC7C;AACH,CAAC;;;;;;;AAED,SAAS,iBAAiB,CACtB,KAAU,EAAE,QAAiB,EAAE,UAAkC;IACnE,OAAO,IAAI,oBAAoB,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;AAClF,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {Type} from '../interface/type';\nimport {reflector} from '../reflection/reflection';\n\nimport {resolveForwardRef} from './forward_ref';\nimport {InjectionToken} from './injection_token';\nimport {ClassProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ValueProvider} from './interface/provider';\nimport {Inject, Optional, Self, SkipSelf} from './metadata';\nimport {invalidProviderError, mixingMultiProvidersWithRegularProvidersError, noAnnotationError} from './reflective_errors';\nimport {ReflectiveKey} from './reflective_key';\n\n\ninterface NormalizedProvider extends TypeProvider, ValueProvider, ClassProvider, ExistingProvider,\n    FactoryProvider {}\n\n/**\n * `Dependency` is used by the framework to extend DI.\n * This is internal to Angular and should not be used directly.\n */\nexport class ReflectiveDependency {\n  constructor(\n      public key: ReflectiveKey, public optional: boolean, public visibility: Self|SkipSelf|null) {}\n\n  static fromKey(key: ReflectiveKey): ReflectiveDependency {\n    return new ReflectiveDependency(key, false, null);\n  }\n}\n\nconst _EMPTY_LIST: any[] = [];\n\n/**\n * An internal resolved representation of a `Provider` used by the `Injector`.\n *\n * @usageNotes\n * This is usually created automatically by `Injector.resolveAndCreate`.\n *\n * It can be created manually, as follows:\n *\n * ### Example\n *\n * ```typescript\n * var resolvedProviders = Injector.resolve([{ provide: 'message', useValue: 'Hello' }]);\n * var injector = Injector.fromResolvedProviders(resolvedProviders);\n *\n * expect(injector.get('message')).toEqual('Hello');\n * ```\n *\n * @publicApi\n */\nexport interface ResolvedReflectiveProvider {\n  /**\n   * A key, usually a `Type<any>`.\n   */\n  key: ReflectiveKey;\n\n  /**\n   * Factory function which can return an instance of an object represented by a key.\n   */\n  resolvedFactories: ResolvedReflectiveFactory[];\n\n  /**\n   * Indicates if the provider is a multi-provider or a regular provider.\n   */\n  multiProvider: boolean;\n}\n\nexport class ResolvedReflectiveProvider_ implements ResolvedReflectiveProvider {\n  readonly resolvedFactory: ResolvedReflectiveFactory;\n\n  constructor(\n      public key: ReflectiveKey, public resolvedFactories: ResolvedReflectiveFactory[],\n      public multiProvider: boolean) {\n    this.resolvedFactory = this.resolvedFactories[0];\n  }\n}\n\n/**\n * An internal resolved representation of a factory function created by resolving `Provider`.\n * @publicApi\n */\nexport class ResolvedReflectiveFactory {\n  constructor(\n      /**\n       * Factory function which can return an instance of an object represented by a key.\n       */\n      public factory: Function,\n\n      /**\n       * Arguments (dependencies) to the `factory` function.\n       */\n      public dependencies: ReflectiveDependency[]) {}\n}\n\n\n/**\n * Resolve a single provider.\n */\nfunction resolveReflectiveFactory(provider: NormalizedProvider): ResolvedReflectiveFactory {\n  let factoryFn: Function;\n  let resolvedDeps: ReflectiveDependency[];\n  if (provider.useClass) {\n    const useClass = resolveForwardRef(provider.useClass);\n    factoryFn = reflector.factory(useClass);\n    resolvedDeps = _dependenciesFor(useClass);\n  } else if (provider.useExisting) {\n    factoryFn = (aliasInstance: any) => aliasInstance;\n    resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];\n  } else if (provider.useFactory) {\n    factoryFn = provider.useFactory;\n    resolvedDeps = constructDependencies(provider.useFactory, provider.deps);\n  } else {\n    factoryFn = () => provider.useValue;\n    resolvedDeps = _EMPTY_LIST;\n  }\n  return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);\n}\n\n/**\n * Converts the `Provider` into `ResolvedProvider`.\n *\n * `Injector` internally only uses `ResolvedProvider`, `Provider` contains convenience provider\n * syntax.\n */\nfunction resolveReflectiveProvider(provider: NormalizedProvider): ResolvedReflectiveProvider {\n  return new ResolvedReflectiveProvider_(\n      ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)],\n      provider.multi || false);\n}\n\n/**\n * Resolve a list of Providers.\n */\nexport function resolveReflectiveProviders(providers: Provider[]): ResolvedReflectiveProvider[] {\n  const normalized = _normalizeProviders(providers, []);\n  const resolved = normalized.map(resolveReflectiveProvider);\n  const resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());\n  return Array.from(resolvedProviderMap.values());\n}\n\n/**\n * Merges a list of ResolvedProviders into a list where each key is contained exactly once and\n * multi providers have been merged.\n */\nexport function mergeResolvedReflectiveProviders(\n    providers: ResolvedReflectiveProvider[],\n    normalizedProvidersMap: Map<number, ResolvedReflectiveProvider>):\n    Map<number, ResolvedReflectiveProvider> {\n  for (let i = 0; i < providers.length; i++) {\n    const provider = providers[i];\n    const existing = normalizedProvidersMap.get(provider.key.id);\n    if (existing) {\n      if (provider.multiProvider !== existing.multiProvider) {\n        throw mixingMultiProvidersWithRegularProvidersError(existing, provider);\n      }\n      if (provider.multiProvider) {\n        for (let j = 0; j < provider.resolvedFactories.length; j++) {\n          existing.resolvedFactories.push(provider.resolvedFactories[j]);\n        }\n      } else {\n        normalizedProvidersMap.set(provider.key.id, provider);\n      }\n    } else {\n      let resolvedProvider: ResolvedReflectiveProvider;\n      if (provider.multiProvider) {\n        resolvedProvider = new ResolvedReflectiveProvider_(\n            provider.key, provider.resolvedFactories.slice(), provider.multiProvider);\n      } else {\n        resolvedProvider = provider;\n      }\n      normalizedProvidersMap.set(provider.key.id, resolvedProvider);\n    }\n  }\n  return normalizedProvidersMap;\n}\n\nfunction _normalizeProviders(providers: Provider[], res: Provider[]): Provider[] {\n  providers.forEach(b => {\n    if (b instanceof Type) {\n      res.push({provide: b, useClass: b});\n\n    } else if (b && typeof b == 'object' && (b as any).provide !== undefined) {\n      res.push(b as NormalizedProvider);\n\n    } else if (b instanceof Array) {\n      _normalizeProviders(b, res);\n\n    } else {\n      throw invalidProviderError(b);\n    }\n  });\n\n  return res;\n}\n\nexport function constructDependencies(\n    typeOrFunc: any, dependencies?: any[]): ReflectiveDependency[] {\n  if (!dependencies) {\n    return _dependenciesFor(typeOrFunc);\n  } else {\n    const params: any[][] = dependencies.map(t => [t]);\n    return dependencies.map(t => _extractToken(typeOrFunc, t, params));\n  }\n}\n\nfunction _dependenciesFor(typeOrFunc: any): ReflectiveDependency[] {\n  const params = reflector.parameters(typeOrFunc);\n\n  if (!params) return [];\n  if (params.some(p => p == null)) {\n    throw noAnnotationError(typeOrFunc, params);\n  }\n  return params.map(p => _extractToken(typeOrFunc, p, params));\n}\n\nfunction _extractToken(\n    typeOrFunc: any, metadata: any[] | any, params: any[][]): ReflectiveDependency {\n  let token: any = null;\n  let optional = false;\n\n  if (!Array.isArray(metadata)) {\n    if (metadata instanceof Inject) {\n      return _createDependency(metadata.token, optional, null);\n    } else {\n      return _createDependency(metadata, optional, null);\n    }\n  }\n\n  let visibility: Self|SkipSelf|null = null;\n\n  for (let i = 0; i < metadata.length; ++i) {\n    const paramMetadata = metadata[i];\n\n    if (paramMetadata instanceof Type) {\n      token = paramMetadata;\n\n    } else if (paramMetadata instanceof Inject) {\n      token = paramMetadata.token;\n\n    } else if (paramMetadata instanceof Optional) {\n      optional = true;\n\n    } else if (paramMetadata instanceof Self || paramMetadata instanceof SkipSelf) {\n      visibility = paramMetadata;\n    } else if (paramMetadata instanceof InjectionToken) {\n      token = paramMetadata;\n    }\n  }\n\n  token = resolveForwardRef(token);\n\n  if (token != null) {\n    return _createDependency(token, optional, visibility);\n  } else {\n    throw noAnnotationError(typeOrFunc, params);\n  }\n}\n\nfunction _createDependency(\n    token: any, optional: boolean, visibility: Self | SkipSelf | null): ReflectiveDependency {\n  return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);\n}\n"]}