Function lookupTokenUsingEmbeddedInjector

packages/core/src/render3/di.ts:968–1038

* Returns a value from the closest embedded or node injector. * * @param tNode The Node where the search for the injector should start * @param lView The `LView` that contains the `tNode` * @param token The token to look for * @param flags Injection flags * @param notFoundValue The value to re

(
  tNode: TDirectiveHostNode,
  lView: LView,
  token: ProviderToken<T>,
  flags: InternalInjectFlags,
  notFoundValue?: any,
)

 * @returns the value from the injector, `null` when not found, or `notFoundValue` if provided
 */
function lookupTokenUsingEmbeddedInjector<T>(
  tNode: TDirectiveHostNode,
  lView: LView,
  token: ProviderToken<T>,
  flags: InternalInjectFlags,
  notFoundValue?: any,
) {
  let currentTNode: TDirectiveHostNode | null = tNode;
  let currentLView: LView | null = lView;

  // When an LView with an embedded view injector is inserted, it'll likely be interlaced with
  // nodes who may have injectors (e.g. node injector -> embedded view injector -> node injector).
  // Since the bloom filters for the node injectors have already been constructed and we don't
  // have a way of extracting the records from an injector, the only way to maintain the correct
  // hierarchy when resolving the value is to walk it node-by-node while attempting to resolve
  // the token at each level.
  while (
    currentTNode !== null &&
    currentLView !== null &&
    currentLView[FLAGS] & LViewFlags.HasEmbeddedViewInjector &&
    !isRootView(currentLView)
  ) {
    ngDevMode && assertTNodeForLView(currentTNode, currentLView);

    // Note that this lookup on the node injector is using the `Self` flag, because
    // we don't want the node injector to look at any parent injectors since we
    // may hit the embedded view injector first.
    const nodeInjectorValue = lookupTokenUsingNodeInjector(
      currentTNode,
      currentLView,
      token,
      flags | InternalInjectFlags.Self,
      NOT_FOUND,
    );
    if (nodeInjectorValue !== NOT_FOUND) {
      return nodeInjectorValue;
    }

    // Has an explicit type due to a TS bug: https://github.com/microsoft/TypeScript/issues/33191
    let parentTNode: TElementNode | TContainerNode | null = currentTNode.parent;

    // `TNode.parent` includes the parent within the current view only. If it doesn't exist,
    // it means that we've hit the view boundary and we need to go up to the next view.
    if (!parentTNode) {
      // Before we go to the next LView, check if the token exists on the current embedded injector.
      const embeddedViewInjector = currentLView[EMBEDDED_VIEW_INJECTOR];
      if (embeddedViewInjector) {
        const embeddedViewInjectorValue = (embeddedViewInjector as BackwardsCompatibleInjector).get(
          token,
          NOT_FOUND as T | {},
          // The `SkipSelf` flag is intended for the current injection context (the child component).
          // When we delegate to the embedded view injector, we are effectively traversing to a
          // parent/fallback scope, so the "Self" has already been skipped. We must strip the
          // flag to ensure the embedded view injector can resolve tokens from itself.
          flags & ~InternalInjectFlags.SkipSelf,
        );
        if (embeddedViewInjectorValue !== NOT_FOUND) {
          return embeddedViewInjectorValue;