Method resolveParam

packages/core/injector/injector.ts:340–412

(param: unknown, index: number)

    const paramBarrier = new Barrier(dependencies.length);
    let isResolved = true;
    const resolveParam = async (param: unknown, index: number) => {
      try {
        if (this.isInquirer(param, parentInquirer)) {
          /*
           * Signal the barrier to make sure other dependencies do not get stuck waiting forever.
           */
          paramBarrier.signal();

          return parentInquirer && parentInquirer.instance;
        }
        if (resolutionContext.inquirer?.isTransient && parentInquirer) {
          // When `inquirer` is transient too, inherit the parent inquirer
          // This is required to ensure that transient providers are only resolved
          // when requested
          resolutionContext.inquirer.attachRootInquirer(parentInquirer);
        }
        const nestedResolutionContext =
          this.getStaticTransientResolutionContext(
            resolutionContext,
            parentInquirer,
          );
        const paramWrapper = await this.resolveSingleParam<T>(
          wrapper,
          param as Type | string | symbol,
          { index, dependencies },
          moduleRef,
          nestedResolutionContext,
          index,
        );

        /*
         * Ensure that all instance wrappers are resolved at this point before we continue.
         * Otherwise the staticity of `wrapper`'s dependency tree may be evaluated incorrectly
         * and result in undefined / null injection.
         */
        await paramBarrier.signalAndWait();

        const effectiveResolutionContext = this.getEffectiveResolutionContext(
          paramWrapper,
          resolutionContext,
          parentInquirer,
        );
        const paramWrapperWithInstance = await this.resolveComponentHost(
          moduleRef,
          paramWrapper,
          effectiveResolutionContext,
        );
        const instanceHost = paramWrapperWithInstance.getInstanceByContextId(
          this.getContextId(
            effectiveResolutionContext.contextId,
            paramWrapperWithInstance,
          ),
          effectiveResolutionContext.effectiveInquirerId,
        );
        if (!instanceHost.isResolved && !paramWrapperWithInstance.forwardRef) {
          isResolved = false;
        }
        return instanceHost?.instance;