@angular/core
Version:
Angular - the core framework
119 lines • 19.8 kB
JavaScript
/**
* @license
* Copyright Google Inc. 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 { __extends } from "tslib";
import { Injector } from '../di/injector';
import { INJECTOR } from '../di/injector_compatibility';
import { InjectFlags } from '../di/interface/injector';
import { createInjectorWithoutInjectorInstances } 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 { registerNgModuleType } from '../linker/ng_module_factory_registration';
import { assertDefined } from '../util/assert';
import { stringify } from '../util/stringify';
import { ComponentFactoryResolver } from './component_ref';
import { getNgLocaleIdDef, getNgModuleDef } from './definition';
import { setLocaleId } from './i18n';
import { maybeUnwrapFn } from './util/misc_utils';
var NgModuleRef = /** @class */ (function (_super) {
__extends(NgModuleRef, _super);
function NgModuleRef(ngModuleType, _parent) {
var _this = _super.call(this) || this;
_this._parent = _parent;
// tslint:disable-next-line:require-internal-with-underscore
_this._bootstrapComponents = [];
_this.injector = _this;
_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);
var ngModuleDef = getNgModuleDef(ngModuleType);
ngDevMode &&
assertDefined(ngModuleDef, "NgModule '" + stringify(ngModuleType) + "' is not a subtype of 'NgModuleType'.");
var ngLocaleIdDef = getNgLocaleIdDef(ngModuleType);
ngLocaleIdDef && setLocaleId(ngLocaleIdDef);
_this._bootstrapComponents = maybeUnwrapFn(ngModuleDef.bootstrap);
_this._r3Injector = createInjectorWithoutInjectorInstances(ngModuleType, _parent, [
{ provide: viewEngine_NgModuleRef, useValue: _this }, {
provide: viewEngine_ComponentFactoryResolver,
useValue: _this.componentFactoryResolver
}
], stringify(ngModuleType));
// We need to resolve the injector types separately from the injector creation, because
// the module might be trying to use this ref in its contructor for DI which will cause a
// circular error that will eventually error out, because the injector isn't created yet.
_this._r3Injector._resolveInjectorDefTypes();
_this.instance = _this.get(ngModuleType);
return _this;
}
NgModuleRef.prototype.get = function (token, notFoundValue, injectFlags) {
if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }
if (injectFlags === void 0) { injectFlags = InjectFlags.Default; }
if (token === Injector || token === viewEngine_NgModuleRef || token === INJECTOR) {
return this;
}
return this._r3Injector.get(token, notFoundValue, injectFlags);
};
NgModuleRef.prototype.destroy = function () {
ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');
var injector = this._r3Injector;
!injector.destroyed && injector.destroy();
this.destroyCbs.forEach(function (fn) { return fn(); });
this.destroyCbs = null;
};
NgModuleRef.prototype.onDestroy = function (callback) {
ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');
this.destroyCbs.push(callback);
};
return NgModuleRef;
}(viewEngine_NgModuleRef));
export { NgModuleRef };
var NgModuleFactory = /** @class */ (function (_super) {
__extends(NgModuleFactory, _super);
function NgModuleFactory(moduleType) {
var _this = _super.call(this) || this;
_this.moduleType = moduleType;
var ngModuleDef = getNgModuleDef(moduleType);
if (ngModuleDef !== null) {
// Register the NgModule with Angular's module registry. The location (and hence timing) of
// this call is critical to ensure this works correctly (modules get registered when expected)
// without bloating bundles (modules are registered when otherwise not referenced).
//
// In View Engine, registration occurs in the .ngfactory.js file as a side effect. This has
// several practical consequences:
//
// - If an .ngfactory file is not imported from, the module won't be registered (and can be
// tree shaken).
// - If an .ngfactory file is imported from, the module will be registered even if an instance
// is not actually created (via `create` below).
// - Since an .ngfactory file in View Engine references the .ngfactory files of the NgModule's
// imports,
//
// In Ivy, things are a bit different. .ngfactory files still exist for compatibility, but are
// not a required API to use - there are other ways to obtain an NgModuleFactory for a given
// NgModule. Thus, relying on a side effect in the .ngfactory file is not sufficient. Instead,
// the side effect of registration is added here, in the constructor of NgModuleFactory,
// ensuring no matter how a factory is created, the module is registered correctly.
//
// An alternative would be to include the registration side effect inline following the actual
// NgModule definition. This also has the correct timing, but breaks tree-shaking - modules
// will be registered and retained even if they're otherwise never referenced.
registerNgModuleType(moduleType);
}
return _this;
}
NgModuleFactory.prototype.create = function (parentInjector) {
return new NgModuleRef(this.moduleType, parentInjector);
};
return NgModuleFactory;
}(viewEngine_NgModuleFactory));
export { NgModuleFactory };
//# 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 Inc. 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 {Injector} from '../di/injector';\nimport {INJECTOR} from '../di/injector_compatibility';\nimport {InjectFlags} from '../di/interface/injector';\nimport {createInjectorWithoutInjectorInstances, R3Injector} from '../di/r3_injector';\nimport {Type} from '../interface/type';\nimport {ComponentFactoryResolver as viewEngine_ComponentFactoryResolver} from '../linker/component_factory_resolver';\nimport {InternalNgModuleRef, NgModuleFactory as viewEngine_NgModuleFactory, NgModuleRef as viewEngine_NgModuleRef} from '../linker/ng_module_factory';\nimport {registerNgModuleType} from '../linker/ng_module_factory_registration';\nimport {NgModuleDef} from '../metadata/ng_module';\nimport {assertDefined} from '../util/assert';\nimport {stringify} from '../util/stringify';\n\nimport {ComponentFactoryResolver} from './component_ref';\nimport {getNgLocaleIdDef, getNgModuleDef} from './definition';\nimport {setLocaleId} from './i18n';\nimport {maybeUnwrapFn} from './util/misc_utils';\n\nexport interface NgModuleType<T = any> extends Type<T> {\n  ɵmod: NgModuleDef<T>;\n}\n\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  injector: Injector = this;\n  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  readonly componentFactoryResolver: ComponentFactoryResolver = new ComponentFactoryResolver(this);\n\n  constructor(ngModuleType: Type<T>, public _parent: Injector|null) {\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    const ngLocaleIdDef = getNgLocaleIdDef(ngModuleType);\n    ngLocaleIdDef && setLocaleId(ngLocaleIdDef);\n    this._bootstrapComponents = maybeUnwrapFn(ngModuleDef!.bootstrap);\n    this._r3Injector = createInjectorWithoutInjectorInstances(\n                           ngModuleType, _parent,\n                           [\n                             {provide: viewEngine_NgModuleRef, useValue: this}, {\n                               provide: viewEngine_ComponentFactoryResolver,\n                               useValue: this.componentFactoryResolver\n                             }\n                           ],\n                           stringify(ngModuleType)) 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 contructor for DI which will cause a\n    // circular error that will eventually error out, because the injector isn't created yet.\n    this._r3Injector._resolveInjectorDefTypes();\n    this.instance = this.get(ngModuleType);\n  }\n\n  get(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND,\n      injectFlags: InjectFlags = InjectFlags.Default): any {\n    if (token === Injector || token === viewEngine_NgModuleRef || token === INJECTOR) {\n      return this;\n    }\n    return this._r3Injector.get(token, notFoundValue, injectFlags);\n  }\n\n  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  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    const ngModuleDef = getNgModuleDef(moduleType);\n    if (ngModuleDef !== null) {\n      // Register the NgModule with Angular's module registry. The location (and hence timing) of\n      // this call is critical to ensure this works correctly (modules get registered when expected)\n      // without bloating bundles (modules are registered when otherwise not referenced).\n      //\n      // In View Engine, registration occurs in the .ngfactory.js file as a side effect. This has\n      // several practical consequences:\n      //\n      // - If an .ngfactory file is not imported from, the module won't be registered (and can be\n      //   tree shaken).\n      // - If an .ngfactory file is imported from, the module will be registered even if an instance\n      //   is not actually created (via `create` below).\n      // - Since an .ngfactory file in View Engine references the .ngfactory files of the NgModule's\n      //   imports,\n      //\n      // In Ivy, things are a bit different. .ngfactory files still exist for compatibility, but are\n      // not a required API to use - there are other ways to obtain an NgModuleFactory for a given\n      // NgModule. Thus, relying on a side effect in the .ngfactory file is not sufficient. Instead,\n      // the side effect of registration is added here, in the constructor of NgModuleFactory,\n      // ensuring no matter how a factory is created, the module is registered correctly.\n      //\n      // An alternative would be to include the registration side effect inline following the actual\n      // NgModule definition. This also has the correct timing, but breaks tree-shaking - modules\n      // will be registered and retained even if they're otherwise never referenced.\n      registerNgModuleType(moduleType as NgModuleType);\n    }\n  }\n\n  create(parentInjector: Injector|null): viewEngine_NgModuleRef<T> {\n    return new NgModuleRef(this.moduleType, parentInjector);\n  }\n}\n"]}