/** * @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":"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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} 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 {diPublicInInjector, getNodeInjectable, getOrCreateNodeInjectorForNode, NodeInjector} 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    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 =\n          new NodeInjector(tNode as TElementNode | TContainerNode | TElementContainerNode, lView);\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, 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"]}