@angular/core
Version:
Angular - the core framework
262 lines • 42.8 kB
JavaScript
/**
* @license
* Copyright Google LLC 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 { resolveForwardRef } from '../di/forward_ref';
import { isClassProvider, isTypeProvider } from '../di/provider_collection';
import { providerToFactory } from '../di/r3_injector';
import { assertDefined } from '../util/assert';
import { emitProviderConfiguredEvent, runInInjectorProfilerContext } from './debug/injector_profiler';
import { diPublicInInjector, getNodeInjectable, getOrCreateNodeInjectorForNode, NodeInjector, } from './di';
import { ɵɵdirectiveInject } from './instructions/all';
import { NodeInjectorFactory } from './interfaces/injector';
import { isComponentDef } from './interfaces/type_checks';
import { TVIEW } from './interfaces/view';
import { getCurrentTNode, getLView, getTView } from './state';
/**
* Resolves the providers which are defined in the DirectiveDef.
*
* When inserting the tokens and the factories in their respective arrays, we can assume that
* this method is called first for the component (if any), and then for other directives on the same
* node.
* As a consequence,the providers are always processed in that order:
* 1) The view providers of the component
* 2) The providers of the component
* 3) The providers of the other directives
* This matches the structure of the injectables arrays of a view (for each node).
* So the tokens and the factories can be pushed at the end of the arrays, except
* in one case for multi providers.
*
* @param def the directive definition
* @param providers: Array of `providers`.
* @param viewProviders: Array of `viewProviders`.
*/
export function providersResolver(def, providers, viewProviders) {
const tView = getTView();
if (tView.firstCreatePass) {
const isComponent = isComponentDef(def);
// The list of view providers is processed first, and the flags are updated
resolveProvider(viewProviders, tView.data, tView.blueprint, isComponent, true);
// Then, the list of providers is processed, and the flags are updated
resolveProvider(providers, tView.data, tView.blueprint, isComponent, false);
}
}
/**
* Resolves a provider and publishes it to the DI system.
*/
function resolveProvider(provider, tInjectables, lInjectablesBlueprint, isComponent, isViewProvider) {
provider = resolveForwardRef(provider);
if (Array.isArray(provider)) {
// Recursively call `resolveProvider`
// Recursion is OK in this case because this code will not be in hot-path once we implement
// cloning of the initial state.
for (let i = 0; i < provider.length; i++) {
resolveProvider(provider[i], tInjectables, lInjectablesBlueprint, isComponent, isViewProvider);
}
}
else {
const tView = getTView();
const lView = getLView();
const tNode = getCurrentTNode();
let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);
const providerFactory = providerToFactory(provider);
if (ngDevMode) {
const injector = new NodeInjector(tNode, lView);
runInInjectorProfilerContext(injector, token, () => {
emitProviderConfiguredEvent(provider, isViewProvider);
});
}
const beginIndex = tNode.providerIndexes & 1048575 /* TNodeProviderIndexes.ProvidersStartIndexMask */;
const endIndex = tNode.directiveStart;
const cptViewProvidersCount = tNode.providerIndexes >> 20 /* TNodeProviderIndexes.CptViewProvidersCountShift */;
if (isTypeProvider(provider) || !provider.multi) {
// Single provider case: the factory is created and pushed immediately
const factory = new NodeInjectorFactory(providerFactory, isViewProvider, ɵɵdirectiveInject);
const existingFactoryIndex = indexOf(token, tInjectables, isViewProvider ? beginIndex : beginIndex + cptViewProvidersCount, endIndex);
if (existingFactoryIndex === -1) {
diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, token);
registerDestroyHooksIfSupported(tView, provider, tInjectables.length);
tInjectables.push(token);
tNode.directiveStart++;
tNode.directiveEnd++;
if (isViewProvider) {
tNode.providerIndexes += 1048576 /* TNodeProviderIndexes.CptViewProvidersCountShifter */;
}
lInjectablesBlueprint.push(factory);
lView.push(factory);
}
else {
lInjectablesBlueprint[existingFactoryIndex] = factory;
lView[existingFactoryIndex] = factory;
}
}
else {
// Multi provider case:
// We create a multi factory which is going to aggregate all the values.
// Since the output of such a factory depends on content or view injection,
// we create two of them, which are linked together.
//
// The first one (for view providers) is always in the first block of the injectables array,
// and the second one (for providers) is always in the second block.
// This is important because view providers have higher priority. When a multi token
// is being looked up, the view providers should be found first.
// Note that it is not possible to have a multi factory in the third block (directive block).
//
// The algorithm to process multi providers is as follows:
// 1) If the multi provider comes from the `viewProviders` of the component:
// a) If the special view providers factory doesn't exist, it is created and pushed.
// b) Else, the multi provider is added to the existing multi factory.
// 2) If the multi provider comes from the `providers` of the component or of another
// directive:
// a) If the multi factory doesn't exist, it is created and provider pushed into it.
// It is also linked to the multi factory for view providers, if it exists.
// b) Else, the multi provider is added to the existing multi factory.
const existingProvidersFactoryIndex = indexOf(token, tInjectables, beginIndex + cptViewProvidersCount, endIndex);
const existingViewProvidersFactoryIndex = indexOf(token, tInjectables, beginIndex, beginIndex + cptViewProvidersCount);
const doesProvidersFactoryExist = existingProvidersFactoryIndex >= 0 && lInjectablesBlueprint[existingProvidersFactoryIndex];
const doesViewProvidersFactoryExist = existingViewProvidersFactoryIndex >= 0 &&
lInjectablesBlueprint[existingViewProvidersFactoryIndex];
if ((isViewProvider && !doesViewProvidersFactoryExist) ||
(!isViewProvider && !doesProvidersFactoryExist)) {
// Cases 1.a and 2.a
diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, token);
const factory = multiFactory(isViewProvider ? multiViewProvidersFactoryResolver : multiProvidersFactoryResolver, lInjectablesBlueprint.length, isViewProvider, isComponent, providerFactory);
if (!isViewProvider && doesViewProvidersFactoryExist) {
lInjectablesBlueprint[existingViewProvidersFactoryIndex].providerFactory = factory;
}
registerDestroyHooksIfSupported(tView, provider, tInjectables.length, 0);
tInjectables.push(token);
tNode.directiveStart++;
tNode.directiveEnd++;
if (isViewProvider) {
tNode.providerIndexes += 1048576 /* TNodeProviderIndexes.CptViewProvidersCountShifter */;
}
lInjectablesBlueprint.push(factory);
lView.push(factory);
}
else {
// Cases 1.b and 2.b
const indexInFactory = multiFactoryAdd(lInjectablesBlueprint[isViewProvider ? existingViewProvidersFactoryIndex : existingProvidersFactoryIndex], providerFactory, !isViewProvider && isComponent);
registerDestroyHooksIfSupported(tView, provider, existingProvidersFactoryIndex > -1
? existingProvidersFactoryIndex
: existingViewProvidersFactoryIndex, indexInFactory);
}
if (!isViewProvider && isComponent && doesViewProvidersFactoryExist) {
lInjectablesBlueprint[existingViewProvidersFactoryIndex].componentProviders++;
}
}
}
}
/**
* Registers the `ngOnDestroy` hook of a provider, if the provider supports destroy hooks.
* @param tView `TView` in which to register the hook.
* @param provider Provider whose hook should be registered.
* @param contextIndex Index under which to find the context for the hook when it's being invoked.
* @param indexInFactory Only required for `multi` providers. Index of the provider in the multi
* provider factory.
*/
function registerDestroyHooksIfSupported(tView, provider, contextIndex, indexInFactory) {
const providerIsTypeProvider = isTypeProvider(provider);
const providerIsClassProvider = isClassProvider(provider);
if (providerIsTypeProvider || providerIsClassProvider) {
// Resolve forward references as `useClass` can hold a forward reference.
const classToken = providerIsClassProvider ? resolveForwardRef(provider.useClass) : provider;
const prototype = classToken.prototype;
const ngOnDestroy = prototype.ngOnDestroy;
if (ngOnDestroy) {
const hooks = tView.destroyHooks || (tView.destroyHooks = []);
if (!providerIsTypeProvider && provider.multi) {
ngDevMode &&
assertDefined(indexInFactory, 'indexInFactory when registering multi factory destroy hook');
const existingCallbacksIndex = hooks.indexOf(contextIndex);
if (existingCallbacksIndex === -1) {
hooks.push(contextIndex, [indexInFactory, ngOnDestroy]);
}
else {
hooks[existingCallbacksIndex + 1].push(indexInFactory, ngOnDestroy);
}
}
else {
hooks.push(contextIndex, ngOnDestroy);
}
}
}
}
/**
* Add a factory in a multi factory.
* @returns Index at which the factory was inserted.
*/
function multiFactoryAdd(multiFactory, factory, isComponentProvider) {
if (isComponentProvider) {
multiFactory.componentProviders++;
}
return multiFactory.multi.push(factory) - 1;
}
/**
* Returns the index of item in the array, but only in the begin to end range.
*/
function indexOf(item, arr, begin, end) {
for (let i = begin; i < end; i++) {
if (arr[i] === item)
return i;
}
return -1;
}
/**
* Use this with `multi` `providers`.
*/
function multiProvidersFactoryResolver(_, tData, lData, tNode) {
return multiResolve(this.multi, []);
}
/**
* Use this with `multi` `viewProviders`.
*
* This factory knows how to concatenate itself with the existing `multi` `providers`.
*/
function multiViewProvidersFactoryResolver(_, tData, lView, tNode) {
const factories = this.multi;
let result;
if (this.providerFactory) {
const componentCount = this.providerFactory.componentProviders;
const multiProviders = getNodeInjectable(lView, lView[TVIEW], this.providerFactory.index, tNode);
// Copy the section of the array which contains `multi` `providers` from the component
result = multiProviders.slice(0, componentCount);
// Insert the `viewProvider` instances.
multiResolve(factories, result);
// Copy the section of the array which contains `multi` `providers` from other directives
for (let i = componentCount; i < multiProviders.length; i++) {
result.push(multiProviders[i]);
}
}
else {
result = [];
// Insert the `viewProvider` instances.
multiResolve(factories, result);
}
return result;
}
/**
* Maps an array of factories into an array of values.
*/
function multiResolve(factories, result) {
for (let i = 0; i < factories.length; i++) {
const factory = factories[i];
result.push(factory());
}
return result;
}
/**
* Creates a multi factory.
*/
function multiFactory(factoryFn, index, isViewProvider, isComponent, f) {
const factory = new NodeInjectorFactory(factoryFn, isViewProvider, ɵɵdirectiveInject);
factory.multi = [];
factory.index = index;
factory.componentProviders = 0;
multiFactoryAdd(factory, f, isComponent && !isViewProvider);
return factory;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"di_setup.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/di_setup.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAC,eAAe,EAAE,cAAc,EAAiB,MAAM,2BAA2B,CAAC;AAC1F,OAAO,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAC,2BAA2B,EAAE,4BAA4B,EAAC,MAAM,2BAA2B,CAAC;AACpG,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,8BAA8B,EAC9B,YAAY,GACb,MAAM,MAAM,CAAC;AACd,OAAO,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAQ1D,OAAO,EAAC,cAAc,EAAC,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAgC,KAAK,EAAQ,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAAC,eAAe,EAAE,QAAQ,EAAE,QAAQ,EAAC,MAAM,SAAS,CAAC;AAE5D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,GAAoB,EACpB,SAAqB,EACrB,aAAyB;IAEzB,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,IAAI,KAAK,CAAC,eAAe,EAAE,CAAC;QAC1B,MAAM,WAAW,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;QAExC,2EAA2E;QAC3E,eAAe,CAAC,aAAa,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;QAE/E,sEAAsE;QACtE,eAAe,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAC9E,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,eAAe,CACtB,QAAkB,EAClB,YAAmB,EACnB,qBAA4C,EAC5C,WAAoB,EACpB,cAAuB;IAEvB,QAAQ,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IACvC,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,qCAAqC;QACrC,2FAA2F;QAC3F,gCAAgC;QAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,eAAe,CACb,QAAQ,CAAC,CAAC,CAAC,EACX,YAAY,EACZ,qBAAqB,EACrB,WAAW,EACX,cAAc,CACf,CAAC;QACJ,CAAC;IACH,CAAC;SAAM,CAAC;QACN,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,eAAe,EAAG,CAAC;QACjC,IAAI,KAAK,GAAQ,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAE3F,MAAM,eAAe,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QACpD,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,QAAQ,GAAG,IAAI,YAAY,CAC/B,KAA8D,EAC9D,KAAK,CACN,CAAC;YACF,4BAA4B,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE;gBACjD,2BAA2B,CAAC,QAA0B,EAAE,cAAc,CAAC,CAAC;YAC1E,CAAC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,UAAU,GAAG,KAAK,CAAC,eAAe,6DAA+C,CAAC;QACxF,MAAM,QAAQ,GAAG,KAAK,CAAC,cAAc,CAAC;QACtC,MAAM,qBAAqB,GACzB,KAAK,CAAC,eAAe,4DAAmD,CAAC;QAE3E,IAAI,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YAChD,sEAAsE;YACtE,MAAM,OAAO,GAAG,IAAI,mBAAmB,CAAC,eAAe,EAAE,cAAc,EAAE,iBAAiB,CAAC,CAAC;YAC5F,MAAM,oBAAoB,GAAG,OAAO,CAClC,KAAK,EACL,YAAY,EACZ,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,GAAG,qBAAqB,EAChE,QAAQ,CACT,CAAC;YACF,IAAI,oBAAoB,KAAK,CAAC,CAAC,EAAE,CAAC;gBAChC,kBAAkB,CAChB,8BAA8B,CAC5B,KAA8D,EAC9D,KAAK,CACN,EACD,KAAK,EACL,KAAK,CACN,CAAC;gBACF,+BAA+B,CAAC,KAAK,EAAE,QAAQ,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;gBACtE,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACzB,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,KAAK,CAAC,YAAY,EAAE,CAAC;gBACrB,IAAI,cAAc,EAAE,CAAC;oBACnB,KAAK,CAAC,eAAe,mEAAqD,CAAC;gBAC7E,CAAC;gBACD,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACpC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACtB,CAAC;iBAAM,CAAC;gBACN,qBAAqB,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC;gBACtD,KAAK,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC;YACxC,CAAC;QACH,CAAC;aAAM,CAAC;YACN,uBAAuB;YACvB,wEAAwE;YACxE,2EAA2E;YAC3E,oDAAoD;YACpD,EAAE;YACF,4FAA4F;YAC5F,oEAAoE;YACpE,oFAAoF;YACpF,gEAAgE;YAChE,6FAA6F;YAC7F,EAAE;YACF,0DAA0D;YAC1D,4EAA4E;YAC5E,sFAAsF;YACtF,wEAAwE;YACxE,qFAAqF;YACrF,aAAa;YACb,sFAAsF;YACtF,gFAAgF;YAChF,wEAAwE;YAExE,MAAM,6BAA6B,GAAG,OAAO,CAC3C,KAAK,EACL,YAAY,EACZ,UAAU,GAAG,qBAAqB,EAClC,QAAQ,CACT,CAAC;YACF,MAAM,iCAAiC,GAAG,OAAO,CAC/C,KAAK,EACL,YAAY,EACZ,UAAU,EACV,UAAU,GAAG,qBAAqB,CACnC,CAAC;YACF,MAAM,yBAAyB,GAC7B,6BAA6B,IAAI,CAAC,IAAI,qBAAqB,CAAC,6BAA6B,CAAC,CAAC;YAC7F,MAAM,6BAA6B,GACjC,iCAAiC,IAAI,CAAC;gBACtC,qBAAqB,CAAC,iCAAiC,CAAC,CAAC;YAE3D,IACE,CAAC,cAAc,IAAI,CAAC,6BAA6B,CAAC;gBAClD,CAAC,CAAC,cAAc,IAAI,CAAC,yBAAyB,CAAC,EAC/C,CAAC;gBACD,oBAAoB;gBACpB,kBAAkB,CAChB,8BAA8B,CAC5B,KAA8D,EAC9D,KAAK,CACN,EACD,KAAK,EACL,KAAK,CACN,CAAC;gBACF,MAAM,OAAO,GAAG,YAAY,CAC1B,cAAc,CAAC,CAAC,CAAC,iCAAiC,CAAC,CAAC,CAAC,6BAA6B,EAClF,qBAAqB,CAAC,MAAM,EAC5B,cAAc,EACd,WAAW,EACX,eAAe,CAChB,CAAC;gBACF,IAAI,CAAC,cAAc,IAAI,6BAA6B,EAAE,CAAC;oBACrD,qBAAqB,CAAC,iCAAiC,CAAC,CAAC,eAAe,GAAG,OAAO,CAAC;gBACrF,CAAC;gBACD,+BAA+B,CAAC,KAAK,EAAE,QAAQ,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;gBACzE,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACzB,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,KAAK,CAAC,YAAY,EAAE,CAAC;gBACrB,IAAI,cAAc,EAAE,CAAC;oBACnB,KAAK,CAAC,eAAe,mEAAqD,CAAC;gBAC7E,CAAC;gBACD,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACpC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACtB,CAAC;iBAAM,CAAC;gBACN,oBAAoB;gBACpB,MAAM,cAAc,GAAG,eAAe,CACpC,qBAAsB,CACpB,cAAc,CAAC,CAAC,CAAC,iCAAiC,CAAC,CAAC,CAAC,6BAA6B,CACnF,EACD,eAAe,EACf,CAAC,cAAc,IAAI,WAAW,CAC/B,CAAC;gBACF,+BAA+B,CAC7B,KAAK,EACL,QAAQ,EACR,6BAA6B,GAAG,CAAC,CAAC;oBAChC,CAAC,CAAC,6BAA6B;oBAC/B,CAAC,CAAC,iCAAiC,EACrC,cAAc,CACf,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,cAAc,IAAI,WAAW,IAAI,6BAA6B,EAAE,CAAC;gBACpE,qBAAqB,CAAC,iCAAiC,CAAC,CAAC,kBAAmB,EAAE,CAAC;YACjF,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,+BAA+B,CACtC,KAAY,EACZ,QAAkC,EAClC,YAAoB,EACpB,cAAuB;IAEvB,MAAM,sBAAsB,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;IACxD,MAAM,uBAAuB,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;IAE1D,IAAI,sBAAsB,IAAI,uBAAuB,EAAE,CAAC;QACtD,yEAAyE;QACzE,MAAM,UAAU,GAAG,uBAAuB,CAAC,CAAC,CAAC,iBAAiB,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC7F,MAAM,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACvC,MAAM,WAAW,GAAG,SAAS,CAAC,WAAW,CAAC;QAE1C,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,KAAK,GAAG,KAAK,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,EAAE,CAAC,CAAC;YAE9D,IAAI,CAAC,sBAAsB,IAAK,QAA0B,CAAC,KAAK,EAAE,CAAC;gBACjE,SAAS;oBACP,aAAa,CACX,cAAc,EACd,4DAA4D,CAC7D,CAAC;gBACJ,MAAM,sBAAsB,GAAG,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;gBAE3D,IAAI,sBAAsB,KAAK,CAAC,CAAC,EAAE,CAAC;oBAClC,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC;gBAC1D,CAAC;qBAAM,CAAC;oBACL,KAAK,CAAC,sBAAsB,GAAG,CAAC,CAAqB,CAAC,IAAI,CAAC,cAAe,EAAE,WAAW,CAAC,CAAC;gBAC5F,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;YACxC,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,eAAe,CACtB,YAAiC,EACjC,OAAkB,EAClB,mBAA4B;IAE5B,IAAI,mBAAmB,EAAE,CAAC;QACxB,YAAY,CAAC,kBAAmB,EAAE,CAAC;IACrC,CAAC;IACD,OAAO,YAAY,CAAC,KAAM,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;AAC/C,CAAC;AAED;;GAEG;AACH,SAAS,OAAO,CAAC,IAAS,EAAE,GAAU,EAAE,KAAa,EAAE,GAAW;IAChE,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QACjC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI;YAAE,OAAO,CAAC,CAAC;IAChC,CAAC;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;AAED;;GAEG;AACH,SAAS,6BAA6B,CAEpC,CAAY,EACZ,KAAY,EACZ,KAAY,EACZ,KAAyB;IAEzB,OAAO,YAAY,CAAC,IAAI,CAAC,KAAM,EAAE,EAAE,CAAC,CAAC;AACvC,CAAC;AAED;;;;GAIG;AACH,SAAS,iCAAiC,CAExC,CAAY,EACZ,KAAY,EACZ,KAAY,EACZ,KAAyB;IAEzB,MAAM,SAAS,GAAG,IAAI,CAAC,KAAM,CAAC;IAC9B,IAAI,MAAa,CAAC;IAClB,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,MAAM,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC,kBAAmB,CAAC;QAChE,MAAM,cAAc,GAAG,iBAAiB,CACtC,KAAK,EACL,KAAK,CAAC,KAAK,CAAC,EACZ,IAAI,CAAC,eAAgB,CAAC,KAAM,EAC5B,KAAK,CACN,CAAC;QACF,sFAAsF;QACtF,MAAM,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;QACjD,uCAAuC;QACvC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAChC,yFAAyF;QACzF,KAAK,IAAI,CAAC,GAAG,cAAc,EAAE,CAAC,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5D,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;SAAM,CAAC;QACN,MAAM,GAAG,EAAE,CAAC;QACZ,uCAAuC;QACvC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CAAC,SAA2B,EAAE,MAAa;IAC9D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,MAAM,OAAO,GAAG,SAAS,CAAC,CAAC,CAAgB,CAAC;QAC5C,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CACnB,SAMQ,EACR,KAAa,EACb,cAAuB,EACvB,WAAoB,EACpB,CAAY;IAEZ,MAAM,OAAO,GAAG,IAAI,mBAAmB,CAAC,SAAS,EAAE,cAAc,EAAE,iBAAiB,CAAC,CAAC;IACtF,OAAO,CAAC,KAAK,GAAG,EAAE,CAAC;IACnB,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;IACtB,OAAO,CAAC,kBAAkB,GAAG,CAAC,CAAC;IAC/B,eAAe,CAAC,OAAO,EAAE,CAAC,EAAE,WAAW,IAAI,CAAC,cAAc,CAAC,CAAC;IAC5D,OAAO,OAAO,CAAC;AACjB,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {resolveForwardRef} from '../di/forward_ref';\nimport {ClassProvider, Provider} from '../di/interface/provider';\nimport {isClassProvider, isTypeProvider, SingleProvider} from '../di/provider_collection';\nimport {providerToFactory} from '../di/r3_injector';\nimport {assertDefined} from '../util/assert';\n\nimport {emitProviderConfiguredEvent, runInInjectorProfilerContext} from './debug/injector_profiler';\nimport {\n  diPublicInInjector,\n  getNodeInjectable,\n  getOrCreateNodeInjectorForNode,\n  NodeInjector,\n} from './di';\nimport {ɵɵdirectiveInject} from './instructions/all';\nimport {DirectiveDef} from './interfaces/definition';\nimport {NodeInjectorFactory} from './interfaces/injector';\nimport {\n  TContainerNode,\n  TDirectiveHostNode,\n  TElementContainerNode,\n  TElementNode,\n  TNodeProviderIndexes,\n} from './interfaces/node';\nimport {isComponentDef} from './interfaces/type_checks';\nimport {DestroyHookData, LView, TData, TVIEW, TView} from './interfaces/view';\nimport {getCurrentTNode, getLView, getTView} from './state';\n\n/**\n * Resolves the providers which are defined in the DirectiveDef.\n *\n * When inserting the tokens and the factories in their respective arrays, we can assume that\n * this method is called first for the component (if any), and then for other directives on the same\n * node.\n * As a consequence,the providers are always processed in that order:\n * 1) The view providers of the component\n * 2) The providers of the component\n * 3) The providers of the other directives\n * This matches the structure of the injectables arrays of a view (for each node).\n * So the tokens and the factories can be pushed at the end of the arrays, except\n * in one case for multi providers.\n *\n * @param def the directive definition\n * @param providers: Array of `providers`.\n * @param viewProviders: Array of `viewProviders`.\n */\nexport function providersResolver<T>(\n  def: DirectiveDef<T>,\n  providers: Provider[],\n  viewProviders: Provider[],\n): void {\n  const tView = getTView();\n  if (tView.firstCreatePass) {\n    const isComponent = isComponentDef(def);\n\n    // The list of view providers is processed first, and the flags are updated\n    resolveProvider(viewProviders, tView.data, tView.blueprint, isComponent, true);\n\n    // Then, the list of providers is processed, and the flags are updated\n    resolveProvider(providers, tView.data, tView.blueprint, isComponent, false);\n  }\n}\n\n/**\n * Resolves a provider and publishes it to the DI system.\n */\nfunction resolveProvider(\n  provider: Provider,\n  tInjectables: TData,\n  lInjectablesBlueprint: NodeInjectorFactory[],\n  isComponent: boolean,\n  isViewProvider: boolean,\n): void {\n  provider = resolveForwardRef(provider);\n  if (Array.isArray(provider)) {\n    // Recursively call `resolveProvider`\n    // Recursion is OK in this case because this code will not be in hot-path once we implement\n    // cloning of the initial state.\n    for (let i = 0; i < provider.length; i++) {\n      resolveProvider(\n        provider[i],\n        tInjectables,\n        lInjectablesBlueprint,\n        isComponent,\n        isViewProvider,\n      );\n    }\n  } else {\n    const tView = getTView();\n    const lView = getLView();\n    const tNode = getCurrentTNode()!;\n    let token: any = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);\n\n    const providerFactory = providerToFactory(provider);\n    if (ngDevMode) {\n      const injector = new NodeInjector(\n        tNode as TElementNode | TContainerNode | TElementContainerNode,\n        lView,\n      );\n      runInInjectorProfilerContext(injector, token, () => {\n        emitProviderConfiguredEvent(provider as SingleProvider, isViewProvider);\n      });\n    }\n\n    const beginIndex = tNode.providerIndexes & TNodeProviderIndexes.ProvidersStartIndexMask;\n    const endIndex = tNode.directiveStart;\n    const cptViewProvidersCount =\n      tNode.providerIndexes >> TNodeProviderIndexes.CptViewProvidersCountShift;\n\n    if (isTypeProvider(provider) || !provider.multi) {\n      // Single provider case: the factory is created and pushed immediately\n      const factory = new NodeInjectorFactory(providerFactory, isViewProvider, ɵɵdirectiveInject);\n      const existingFactoryIndex = indexOf(\n        token,\n        tInjectables,\n        isViewProvider ? beginIndex : beginIndex + cptViewProvidersCount,\n        endIndex,\n      );\n      if (existingFactoryIndex === -1) {\n        diPublicInInjector(\n          getOrCreateNodeInjectorForNode(\n            tNode as TElementNode | TContainerNode | TElementContainerNode,\n            lView,\n          ),\n          tView,\n          token,\n        );\n        registerDestroyHooksIfSupported(tView, provider, tInjectables.length);\n        tInjectables.push(token);\n        tNode.directiveStart++;\n        tNode.directiveEnd++;\n        if (isViewProvider) {\n          tNode.providerIndexes += TNodeProviderIndexes.CptViewProvidersCountShifter;\n        }\n        lInjectablesBlueprint.push(factory);\n        lView.push(factory);\n      } else {\n        lInjectablesBlueprint[existingFactoryIndex] = factory;\n        lView[existingFactoryIndex] = factory;\n      }\n    } else {\n      // Multi provider case:\n      // We create a multi factory which is going to aggregate all the values.\n      // Since the output of such a factory depends on content or view injection,\n      // we create two of them, which are linked together.\n      //\n      // The first one (for view providers) is always in the first block of the injectables array,\n      // and the second one (for providers) is always in the second block.\n      // This is important because view providers have higher priority. When a multi token\n      // is being looked up, the view providers should be found first.\n      // Note that it is not possible to have a multi factory in the third block (directive block).\n      //\n      // The algorithm to process multi providers is as follows:\n      // 1) If the multi provider comes from the `viewProviders` of the component:\n      //   a) If the special view providers factory doesn't exist, it is created and pushed.\n      //   b) Else, the multi provider is added to the existing multi factory.\n      // 2) If the multi provider comes from the `providers` of the component or of another\n      // directive:\n      //   a) If the multi factory doesn't exist, it is created and provider pushed into it.\n      //      It is also linked to the multi factory for view providers, if it exists.\n      //   b) Else, the multi provider is added to the existing multi factory.\n\n      const existingProvidersFactoryIndex = indexOf(\n        token,\n        tInjectables,\n        beginIndex + cptViewProvidersCount,\n        endIndex,\n      );\n      const existingViewProvidersFactoryIndex = indexOf(\n        token,\n        tInjectables,\n        beginIndex,\n        beginIndex + cptViewProvidersCount,\n      );\n      const doesProvidersFactoryExist =\n        existingProvidersFactoryIndex >= 0 && lInjectablesBlueprint[existingProvidersFactoryIndex];\n      const doesViewProvidersFactoryExist =\n        existingViewProvidersFactoryIndex >= 0 &&\n        lInjectablesBlueprint[existingViewProvidersFactoryIndex];\n\n      if (\n        (isViewProvider && !doesViewProvidersFactoryExist) ||\n        (!isViewProvider && !doesProvidersFactoryExist)\n      ) {\n        // Cases 1.a and 2.a\n        diPublicInInjector(\n          getOrCreateNodeInjectorForNode(\n            tNode as TElementNode | TContainerNode | TElementContainerNode,\n            lView,\n          ),\n          tView,\n          token,\n        );\n        const factory = multiFactory(\n          isViewProvider ? multiViewProvidersFactoryResolver : multiProvidersFactoryResolver,\n          lInjectablesBlueprint.length,\n          isViewProvider,\n          isComponent,\n          providerFactory,\n        );\n        if (!isViewProvider && doesViewProvidersFactoryExist) {\n          lInjectablesBlueprint[existingViewProvidersFactoryIndex].providerFactory = factory;\n        }\n        registerDestroyHooksIfSupported(tView, provider, tInjectables.length, 0);\n        tInjectables.push(token);\n        tNode.directiveStart++;\n        tNode.directiveEnd++;\n        if (isViewProvider) {\n          tNode.providerIndexes += TNodeProviderIndexes.CptViewProvidersCountShifter;\n        }\n        lInjectablesBlueprint.push(factory);\n        lView.push(factory);\n      } else {\n        // Cases 1.b and 2.b\n        const indexInFactory = multiFactoryAdd(\n          lInjectablesBlueprint![\n            isViewProvider ? existingViewProvidersFactoryIndex : existingProvidersFactoryIndex\n          ],\n          providerFactory,\n          !isViewProvider && isComponent,\n        );\n        registerDestroyHooksIfSupported(\n          tView,\n          provider,\n          existingProvidersFactoryIndex > -1\n            ? existingProvidersFactoryIndex\n            : existingViewProvidersFactoryIndex,\n          indexInFactory,\n        );\n      }\n      if (!isViewProvider && isComponent && doesViewProvidersFactoryExist) {\n        lInjectablesBlueprint[existingViewProvidersFactoryIndex].componentProviders!++;\n      }\n    }\n  }\n}\n\n/**\n * Registers the `ngOnDestroy` hook of a provider, if the provider supports destroy hooks.\n * @param tView `TView` in which to register the hook.\n * @param provider Provider whose hook should be registered.\n * @param contextIndex Index under which to find the context for the hook when it's being invoked.\n * @param indexInFactory Only required for `multi` providers. Index of the provider in the multi\n * provider factory.\n */\nfunction registerDestroyHooksIfSupported(\n  tView: TView,\n  provider: Exclude<Provider, any[]>,\n  contextIndex: number,\n  indexInFactory?: number,\n) {\n  const providerIsTypeProvider = isTypeProvider(provider);\n  const providerIsClassProvider = isClassProvider(provider);\n\n  if (providerIsTypeProvider || providerIsClassProvider) {\n    // Resolve forward references as `useClass` can hold a forward reference.\n    const classToken = providerIsClassProvider ? resolveForwardRef(provider.useClass) : provider;\n    const prototype = classToken.prototype;\n    const ngOnDestroy = prototype.ngOnDestroy;\n\n    if (ngOnDestroy) {\n      const hooks = tView.destroyHooks || (tView.destroyHooks = []);\n\n      if (!providerIsTypeProvider && (provider as ClassProvider).multi) {\n        ngDevMode &&\n          assertDefined(\n            indexInFactory,\n            'indexInFactory when registering multi factory destroy hook',\n          );\n        const existingCallbacksIndex = hooks.indexOf(contextIndex);\n\n        if (existingCallbacksIndex === -1) {\n          hooks.push(contextIndex, [indexInFactory, ngOnDestroy]);\n        } else {\n          (hooks[existingCallbacksIndex + 1] as DestroyHookData).push(indexInFactory!, ngOnDestroy);\n        }\n      } else {\n        hooks.push(contextIndex, ngOnDestroy);\n      }\n    }\n  }\n}\n\n/**\n * Add a factory in a multi factory.\n * @returns Index at which the factory was inserted.\n */\nfunction multiFactoryAdd(\n  multiFactory: NodeInjectorFactory,\n  factory: () => any,\n  isComponentProvider: boolean,\n): number {\n  if (isComponentProvider) {\n    multiFactory.componentProviders!++;\n  }\n  return multiFactory.multi!.push(factory) - 1;\n}\n\n/**\n * Returns the index of item in the array, but only in the begin to end range.\n */\nfunction indexOf(item: any, arr: any[], begin: number, end: number) {\n  for (let i = begin; i < end; i++) {\n    if (arr[i] === item) return i;\n  }\n  return -1;\n}\n\n/**\n * Use this with `multi` `providers`.\n */\nfunction multiProvidersFactoryResolver(\n  this: NodeInjectorFactory,\n  _: undefined,\n  tData: TData,\n  lData: LView,\n  tNode: TDirectiveHostNode,\n): any[] {\n  return multiResolve(this.multi!, []);\n}\n\n/**\n * Use this with `multi` `viewProviders`.\n *\n * This factory knows how to concatenate itself with the existing `multi` `providers`.\n */\nfunction multiViewProvidersFactoryResolver(\n  this: NodeInjectorFactory,\n  _: undefined,\n  tData: TData,\n  lView: LView,\n  tNode: TDirectiveHostNode,\n): any[] {\n  const factories = this.multi!;\n  let result: any[];\n  if (this.providerFactory) {\n    const componentCount = this.providerFactory.componentProviders!;\n    const multiProviders = getNodeInjectable(\n      lView,\n      lView[TVIEW],\n      this.providerFactory!.index!,\n      tNode,\n    );\n    // Copy the section of the array which contains `multi` `providers` from the component\n    result = multiProviders.slice(0, componentCount);\n    // Insert the `viewProvider` instances.\n    multiResolve(factories, result);\n    // Copy the section of the array which contains `multi` `providers` from other directives\n    for (let i = componentCount; i < multiProviders.length; i++) {\n      result.push(multiProviders[i]);\n    }\n  } else {\n    result = [];\n    // Insert the `viewProvider` instances.\n    multiResolve(factories, result);\n  }\n  return result;\n}\n\n/**\n * Maps an array of factories into an array of values.\n */\nfunction multiResolve(factories: Array<() => any>, result: any[]): any[] {\n  for (let i = 0; i < factories.length; i++) {\n    const factory = factories[i]! as () => null;\n    result.push(factory());\n  }\n  return result;\n}\n\n/**\n * Creates a multi factory.\n */\nfunction multiFactory(\n  factoryFn: (\n    this: NodeInjectorFactory,\n    _: undefined,\n    tData: TData,\n    lData: LView,\n    tNode: TDirectiveHostNode,\n  ) => any,\n  index: number,\n  isViewProvider: boolean,\n  isComponent: boolean,\n  f: () => any,\n): NodeInjectorFactory {\n  const factory = new NodeInjectorFactory(factoryFn, isViewProvider, ɵɵdirectiveInject);\n  factory.multi = [];\n  factory.index = index;\n  factory.componentProviders = 0;\n  multiFactoryAdd(factory, f, isComponent && !isViewProvider);\n  return factory;\n}\n"]}