@angular/core
Version:
Angular - the core framework
255 lines • 40.3 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, providerToFactory } from '../di/r3_injector';
import { assertDefined } from '../util/assert';
import { diPublicInInjector, getNodeInjectable, getOrCreateNodeInjectorForNode } 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();
let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);
let providerFactory = providerToFactory(provider);
const tNode = getCurrentTNode();
const beginIndex = tNode.providerIndexes & 1048575 /* ProvidersStartIndexMask */;
const endIndex = tNode.directiveStart;
const cptViewProvidersCount = tNode.providerIndexes >> 20 /* 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 /* 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 /* 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":"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","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\n\nimport {resolveForwardRef} from '../di/forward_ref';\nimport {ClassProvider, Provider, TypeProvider} from '../di/interface/provider';\nimport {isClassProvider, isTypeProvider, providerToFactory} from '../di/r3_injector';\nimport {assertDefined} from '../util/assert';\n\nimport {diPublicInInjector, getNodeInjectable, getOrCreateNodeInjectorForNode} from './di';\nimport {ɵɵdirectiveInject} from './instructions/all';\nimport {DirectiveDef} from './interfaces/definition';\nimport {NodeInjectorFactory} from './interfaces/injector';\nimport {TContainerNode, TDirectiveHostNode, TElementContainerNode, TElementNode, TNodeProviderIndexes} 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\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>, providers: Provider[], viewProviders: Provider[]): 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, tInjectables: TData, lInjectablesBlueprint: NodeInjectorFactory[],\n    isComponent: boolean, isViewProvider: boolean): 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], tInjectables, lInjectablesBlueprint, isComponent, isViewProvider);\n    }\n  } else {\n    const tView = getTView();\n    const lView = getLView();\n    let token: any = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);\n    let providerFactory: () => any = providerToFactory(provider);\n\n    const tNode = getCurrentTNode()!;\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, tInjectables, isViewProvider ? beginIndex : beginIndex + cptViewProvidersCount,\n          endIndex);\n      if (existingFactoryIndex === -1) {\n        diPublicInInjector(\n            getOrCreateNodeInjectorForNode(\n                tNode as TElementNode | TContainerNode | TElementContainerNode, lView),\n            tView, token);\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 =\n          indexOf(token, tInjectables, beginIndex + cptViewProvidersCount, endIndex);\n      const existingViewProvidersFactoryIndex =\n          indexOf(token, tInjectables, beginIndex, beginIndex + cptViewProvidersCount);\n      const doesProvidersFactoryExist = existingProvidersFactoryIndex >= 0 &&\n          lInjectablesBlueprint[existingProvidersFactoryIndex];\n      const doesViewProvidersFactoryExist = existingViewProvidersFactoryIndex >= 0 &&\n          lInjectablesBlueprint[existingViewProvidersFactoryIndex];\n\n      if (isViewProvider && !doesViewProvidersFactoryExist ||\n          !isViewProvider && !doesProvidersFactoryExist) {\n        // Cases 1.a and 2.a\n        diPublicInInjector(\n            getOrCreateNodeInjectorForNode(\n                tNode as TElementNode | TContainerNode | TElementContainerNode, lView),\n            tView, token);\n        const factory = multiFactory(\n            isViewProvider ? multiViewProvidersFactoryResolver : multiProvidersFactoryResolver,\n            lInjectablesBlueprint.length, isViewProvider, isComponent, providerFactory);\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 :\n                                  existingProvidersFactoryIndex],\n            providerFactory, !isViewProvider && isComponent);\n        registerDestroyHooksIfSupported(\n            tView, provider,\n            existingProvidersFactoryIndex > -1 ? existingProvidersFactoryIndex :\n                                                 existingViewProvidersFactoryIndex,\n            indexInFactory);\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, provider: Exclude<Provider, any[]>, contextIndex: number,\n    indexInFactory?: number) {\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, 'indexInFactory when registering multi factory destroy hook');\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, factory: () => any, isComponentProvider: boolean): 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, _: undefined, tData: TData, lData: LView,\n    tNode: TDirectiveHostNode): 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, _: undefined, tData: TData, lView: LView,\n    tNode: TDirectiveHostNode): any[] {\n  const factories = this.multi!;\n  let result: any[];\n  if (this.providerFactory) {\n    const componentCount = this.providerFactory.componentProviders!;\n    const multiProviders =\n        getNodeInjectable(lView, lView[TVIEW], this.providerFactory!.index!, tNode);\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, _: undefined, tData: TData, lData: LView,\n        tNode: TDirectiveHostNode) => any,\n    index: number, isViewProvider: boolean, isComponent: boolean,\n    f: () => any): 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"]}