@angular/core
Version:
Angular - the core framework
180 lines • 20.7 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: packages/core/src/render3/ng_module_ref.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @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 { 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';
/**
* @record
* @template T
*/
export function NgModuleType() { }
if (false) {
/** @type {?} */
NgModuleType.prototype.ɵmod;
}
/**
* @template T
*/
export class NgModuleRef extends viewEngine_NgModuleRef {
/**
* @param {?} ngModuleType
* @param {?} _parent
*/
constructor(ngModuleType, _parent) {
super();
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);
/** @type {?} */
const ngModuleDef = getNgModuleDef(ngModuleType);
ngDevMode &&
assertDefined(ngModuleDef, `NgModule '${stringify(ngModuleType)}' is not a subtype of 'NgModuleType'.`);
/** @type {?} */
const ngLocaleIdDef = getNgLocaleIdDef(ngModuleType);
ngLocaleIdDef && setLocaleId(ngLocaleIdDef);
this._bootstrapComponents = maybeUnwrapFn((/** @type {?} */ (ngModuleDef)).bootstrap);
this._r3Injector = (/** @type {?} */ (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);
}
/**
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} injectFlags
* @return {?}
*/
get(token, notFoundValue = Injector.THROW_IF_NOT_FOUND, injectFlags = InjectFlags.Default) {
if (token === Injector || token === viewEngine_NgModuleRef || token === INJECTOR) {
return this;
}
return this._r3Injector.get(token, notFoundValue, injectFlags);
}
/**
* @return {?}
*/
destroy() {
ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');
/** @type {?} */
const injector = this._r3Injector;
!injector.destroyed && injector.destroy();
(/** @type {?} */ (this.destroyCbs)).forEach((/**
* @param {?} fn
* @return {?}
*/
fn => fn()));
this.destroyCbs = null;
}
/**
* @param {?} callback
* @return {?}
*/
onDestroy(callback) {
ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');
(/** @type {?} */ (this.destroyCbs)).push(callback);
}
}
if (false) {
/** @type {?} */
NgModuleRef.prototype._bootstrapComponents;
/** @type {?} */
NgModuleRef.prototype._r3Injector;
/** @type {?} */
NgModuleRef.prototype.injector;
/** @type {?} */
NgModuleRef.prototype.instance;
/** @type {?} */
NgModuleRef.prototype.destroyCbs;
/** @type {?} */
NgModuleRef.prototype.componentFactoryResolver;
/** @type {?} */
NgModuleRef.prototype._parent;
}
/**
* @template T
*/
export class NgModuleFactory extends viewEngine_NgModuleFactory {
/**
* @param {?} moduleType
*/
constructor(moduleType) {
super();
this.moduleType = moduleType;
/** @type {?} */
const 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((/** @type {?} */ (moduleType)));
}
}
/**
* @param {?} parentInjector
* @return {?}
*/
create(parentInjector) {
return new NgModuleRef(this.moduleType, parentInjector);
}
}
if (false) {
/** @type {?} */
NgModuleFactory.prototype.moduleType;
}
//# 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"]}