Function providerToFactory

packages/core/src/di/r3_injector.ts:639–681

(
  provider: SingleProvider,
  ngModuleType?: InjectorType<any>,
  providers?: any[],
)

 * @param provider provider to convert to factory
 */
export function providerToFactory(
  provider: SingleProvider,
  ngModuleType?: InjectorType<any>,
  providers?: any[],
): (type?: Type<unknown>, flags?: number) => any {
  let factory: ((type?: Type<unknown>, flags?: InternalInjectFlags) => any) | undefined = undefined;
  if (ngDevMode && isEnvironmentProviders(provider)) {
    throwInvalidProviderError(undefined, providers, provider);
  }

  if (isTypeProvider(provider)) {
    const unwrappedProvider = resolveForwardRef(provider);
    return getFactoryDef(unwrappedProvider) || injectableDefOrInjectorDefFactory(unwrappedProvider);
  } else {
    if (isValueProvider(provider)) {
      factory = () => resolveForwardRef(provider.useValue);
    } else if (isFactoryProvider(provider)) {
      factory = () => provider.useFactory(...injectArgs(provider.deps || []));
    } else if (isExistingProvider(provider)) {
      factory = (_, flags) =>
        ɵɵinject(
          resolveForwardRef(provider.useExisting),
          flags !== undefined && flags & InternalInjectFlags.Optional
            ? InternalInjectFlags.Optional
            : undefined,
        );
    } else {
      const classRef = resolveForwardRef(
        provider &&
          ((provider as StaticClassProvider | ClassProvider).useClass || provider.provide),
      );
      if (ngDevMode && !classRef) {
        throwInvalidProviderError(ngModuleType, providers, provider);
      }
      if (hasDeps(provider)) {
        factory = () => new classRef(...injectArgs(provider.deps));
      } else {
        return getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef);
      }
    }
  }
  return factory;
}

export function assertNotDestroyed(injector: R3Injector): void {
  if (injector.destroyed) {