@angular/core
Version:
Angular - the core framework
137 lines • 20.2 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 { createInjectorWithoutInjectorInstances } from '../di/create_injector';
import { getNullInjector, R3Injector } from '../di/r3_injector';
import { ComponentFactoryResolver as viewEngine_ComponentFactoryResolver } from '../linker/component_factory_resolver';
import { NgModuleFactory as viewEngine_NgModuleFactory, NgModuleRef as viewEngine_NgModuleRef, } from '../linker/ng_module_factory';
import { assertDefined } from '../util/assert';
import { stringify } from '../util/stringify';
import { ComponentFactoryResolver } from './component_ref';
import { getNgModuleDef } from './definition';
import { maybeUnwrapFn } from './util/misc_utils';
/**
* Returns a new NgModuleRef instance based on the NgModule class and parent injector provided.
*
* @param ngModule NgModule class.
* @param parentInjector Optional injector instance to use as a parent for the module injector. If
* not provided, `NullInjector` will be used instead.
* @returns NgModuleRef that represents an NgModule instance.
*
* @publicApi
*/
export function createNgModule(ngModule, parentInjector) {
return new NgModuleRef(ngModule, parentInjector ?? null, []);
}
/**
* The `createNgModule` function alias for backwards-compatibility.
* Please avoid using it directly and use `createNgModule` instead.
*
* @deprecated Use `createNgModule` instead.
*/
export const createNgModuleRef = createNgModule;
export class NgModuleRef extends viewEngine_NgModuleRef {
constructor(ngModuleType, _parent, additionalProviders) {
super();
this._parent = _parent;
// tslint:disable-next-line:require-internal-with-underscore
this._bootstrapComponents = [];
this.destroyCbs = [];
// When bootstrapping a module we have a dependency graph that looks like this:
// ApplicationRef -> ComponentFactoryResolver -> NgModuleRef. The problem is that if the
// module being resolved tries to inject the ComponentFactoryResolver, it'll create a
// circular dependency which will result in a runtime error, because the injector doesn't
// exist yet. We work around the issue by creating the ComponentFactoryResolver ourselves
// and providing it, rather than letting the injector resolve it.
this.componentFactoryResolver = new ComponentFactoryResolver(this);
const ngModuleDef = getNgModuleDef(ngModuleType);
ngDevMode &&
assertDefined(ngModuleDef, `NgModule '${stringify(ngModuleType)}' is not a subtype of 'NgModuleType'.`);
this._bootstrapComponents = maybeUnwrapFn(ngModuleDef.bootstrap);
this._r3Injector = createInjectorWithoutInjectorInstances(ngModuleType, _parent, [
{ provide: viewEngine_NgModuleRef, useValue: this },
{
provide: viewEngine_ComponentFactoryResolver,
useValue: this.componentFactoryResolver,
},
...additionalProviders,
], stringify(ngModuleType), new Set(['environment']));
// We need to resolve the injector types separately from the injector creation, because
// the module might be trying to use this ref in its constructor for DI which will cause a
// circular error that will eventually error out, because the injector isn't created yet.
this._r3Injector.resolveInjectorInitializers();
this.instance = this._r3Injector.get(ngModuleType);
}
get injector() {
return this._r3Injector;
}
destroy() {
ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');
const injector = this._r3Injector;
!injector.destroyed && injector.destroy();
this.destroyCbs.forEach((fn) => fn());
this.destroyCbs = null;
}
onDestroy(callback) {
ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');
this.destroyCbs.push(callback);
}
}
export class NgModuleFactory extends viewEngine_NgModuleFactory {
constructor(moduleType) {
super();
this.moduleType = moduleType;
}
create(parentInjector) {
return new NgModuleRef(this.moduleType, parentInjector, []);
}
}
export function createNgModuleRefWithProviders(moduleType, parentInjector, additionalProviders) {
return new NgModuleRef(moduleType, parentInjector, additionalProviders);
}
export class EnvironmentNgModuleRefAdapter extends viewEngine_NgModuleRef {
constructor(config) {
super();
this.componentFactoryResolver = new ComponentFactoryResolver(this);
this.instance = null;
const injector = new R3Injector([
...config.providers,
{ provide: viewEngine_NgModuleRef, useValue: this },
{ provide: viewEngine_ComponentFactoryResolver, useValue: this.componentFactoryResolver },
], config.parent || getNullInjector(), config.debugName, new Set(['environment']));
this.injector = injector;
if (config.runEnvironmentInitializers) {
injector.resolveInjectorInitializers();
}
}
destroy() {
this.injector.destroy();
}
onDestroy(callback) {
this.injector.onDestroy(callback);
}
}
/**
* Create a new environment injector.
*
* @param providers An array of providers.
* @param parent A parent environment injector.
* @param debugName An optional name for this injector instance, which will be used in error
* messages.
*
* @publicApi
*/
export function createEnvironmentInjector(providers, parent, debugName = null) {
const adapter = new EnvironmentNgModuleRefAdapter({
providers,
parent,
debugName,
runEnvironmentInitializers: true,
});
return adapter.injector;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng_module_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/ng_module_ref.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\nimport {createInjectorWithoutInjectorInstances} from '../di/create_injector';\nimport {Injector} from '../di/injector';\nimport {EnvironmentProviders, Provider, StaticProvider} from '../di/interface/provider';\nimport {EnvironmentInjector, getNullInjector, R3Injector} from '../di/r3_injector';\nimport {Type} from '../interface/type';\nimport {ComponentFactoryResolver as viewEngine_ComponentFactoryResolver} from '../linker/component_factory_resolver';\nimport {\n  InternalNgModuleRef,\n  NgModuleFactory as viewEngine_NgModuleFactory,\n  NgModuleRef as viewEngine_NgModuleRef,\n} from '../linker/ng_module_factory';\nimport {assertDefined} from '../util/assert';\nimport {stringify} from '../util/stringify';\n\nimport {ComponentFactoryResolver} from './component_ref';\nimport {getNgModuleDef} from './definition';\nimport {maybeUnwrapFn} from './util/misc_utils';\n\n/**\n * Returns a new NgModuleRef instance based on the NgModule class and parent injector provided.\n *\n * @param ngModule NgModule class.\n * @param parentInjector Optional injector instance to use as a parent for the module injector. If\n *     not provided, `NullInjector` will be used instead.\n * @returns NgModuleRef that represents an NgModule instance.\n *\n * @publicApi\n */\nexport function createNgModule<T>(\n  ngModule: Type<T>,\n  parentInjector?: Injector,\n): viewEngine_NgModuleRef<T> {\n  return new NgModuleRef<T>(ngModule, parentInjector ?? null, []);\n}\n\n/**\n * The `createNgModule` function alias for backwards-compatibility.\n * Please avoid using it directly and use `createNgModule` instead.\n *\n * @deprecated Use `createNgModule` instead.\n */\nexport const createNgModuleRef = createNgModule;\nexport class NgModuleRef<T> extends viewEngine_NgModuleRef<T> implements InternalNgModuleRef<T> {\n  // tslint:disable-next-line:require-internal-with-underscore\n  _bootstrapComponents: Type<any>[] = [];\n  // tslint:disable-next-line:require-internal-with-underscore\n  _r3Injector: R3Injector;\n  override instance: T;\n  destroyCbs: (() => void)[] | null = [];\n\n  // When bootstrapping a module we have a dependency graph that looks like this:\n  // ApplicationRef -> ComponentFactoryResolver -> NgModuleRef. The problem is that if the\n  // module being resolved tries to inject the ComponentFactoryResolver, it'll create a\n  // circular dependency which will result in a runtime error, because the injector doesn't\n  // exist yet. We work around the issue by creating the ComponentFactoryResolver ourselves\n  // and providing it, rather than letting the injector resolve it.\n  override readonly componentFactoryResolver: ComponentFactoryResolver =\n    new ComponentFactoryResolver(this);\n\n  constructor(\n    ngModuleType: Type<T>,\n    public _parent: Injector | null,\n    additionalProviders: StaticProvider[],\n  ) {\n    super();\n    const ngModuleDef = getNgModuleDef(ngModuleType);\n    ngDevMode &&\n      assertDefined(\n        ngModuleDef,\n        `NgModule '${stringify(ngModuleType)}' is not a subtype of 'NgModuleType'.`,\n      );\n\n    this._bootstrapComponents = maybeUnwrapFn(ngModuleDef!.bootstrap);\n    this._r3Injector = createInjectorWithoutInjectorInstances(\n      ngModuleType,\n      _parent,\n      [\n        {provide: viewEngine_NgModuleRef, useValue: this},\n        {\n          provide: viewEngine_ComponentFactoryResolver,\n          useValue: this.componentFactoryResolver,\n        },\n        ...additionalProviders,\n      ],\n      stringify(ngModuleType),\n      new Set(['environment']),\n    ) as R3Injector;\n\n    // We need to resolve the injector types separately from the injector creation, because\n    // the module might be trying to use this ref in its constructor for DI which will cause a\n    // circular error that will eventually error out, because the injector isn't created yet.\n    this._r3Injector.resolveInjectorInitializers();\n    this.instance = this._r3Injector.get(ngModuleType);\n  }\n\n  override get injector(): EnvironmentInjector {\n    return this._r3Injector;\n  }\n\n  override destroy(): void {\n    ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');\n    const injector = this._r3Injector;\n    !injector.destroyed && injector.destroy();\n    this.destroyCbs!.forEach((fn) => fn());\n    this.destroyCbs = null;\n  }\n  override onDestroy(callback: () => void): void {\n    ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');\n    this.destroyCbs!.push(callback);\n  }\n}\n\nexport class NgModuleFactory<T> extends viewEngine_NgModuleFactory<T> {\n  constructor(public moduleType: Type<T>) {\n    super();\n  }\n\n  override create(parentInjector: Injector | null): viewEngine_NgModuleRef<T> {\n    return new NgModuleRef(this.moduleType, parentInjector, []);\n  }\n}\n\nexport function createNgModuleRefWithProviders<T>(\n  moduleType: Type<T>,\n  parentInjector: Injector | null,\n  additionalProviders: StaticProvider[],\n): InternalNgModuleRef<T> {\n  return new NgModuleRef(moduleType, parentInjector, additionalProviders);\n}\n\nexport class EnvironmentNgModuleRefAdapter extends viewEngine_NgModuleRef<null> {\n  override readonly injector: R3Injector;\n  override readonly componentFactoryResolver: ComponentFactoryResolver =\n    new ComponentFactoryResolver(this);\n  override readonly instance = null;\n\n  constructor(config: {\n    providers: Array<Provider | EnvironmentProviders>;\n    parent: EnvironmentInjector | null;\n    debugName: string | null;\n    runEnvironmentInitializers: boolean;\n  }) {\n    super();\n    const injector = new R3Injector(\n      [\n        ...config.providers,\n        {provide: viewEngine_NgModuleRef, useValue: this},\n        {provide: viewEngine_ComponentFactoryResolver, useValue: this.componentFactoryResolver},\n      ],\n      config.parent || getNullInjector(),\n      config.debugName,\n      new Set(['environment']),\n    );\n    this.injector = injector;\n    if (config.runEnvironmentInitializers) {\n      injector.resolveInjectorInitializers();\n    }\n  }\n\n  override destroy(): void {\n    this.injector.destroy();\n  }\n\n  override onDestroy(callback: () => void): void {\n    this.injector.onDestroy(callback);\n  }\n}\n\n/**\n * Create a new environment injector.\n *\n * @param providers An array of providers.\n * @param parent A parent environment injector.\n * @param debugName An optional name for this injector instance, which will be used in error\n *     messages.\n *\n * @publicApi\n */\nexport function createEnvironmentInjector(\n  providers: Array<Provider | EnvironmentProviders>,\n  parent: EnvironmentInjector,\n  debugName: string | null = null,\n): EnvironmentInjector {\n  const adapter = new EnvironmentNgModuleRefAdapter({\n    providers,\n    parent,\n    debugName,\n    runEnvironmentInitializers: true,\n  });\n  return adapter.injector;\n}\n"]}