@angular/upgrade
Version:
Angular - the library for easing update from v1 to v2
176 lines • 24 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 { PlatformRef } from '@angular/core';
import { platformBrowser } from '@angular/platform-browser';
import { module_ as angularModule } from '../../src/common/src/angular1';
import { $INJECTOR, $PROVIDE, DOWNGRADED_MODULE_COUNT_KEY, INJECTOR_KEY, LAZY_MODULE_REF, UPGRADE_APP_TYPE_KEY, UPGRADE_MODULE_NAME } from '../../src/common/src/constants';
import { destroyApp, getDowngradedModuleCount, isFunction } from '../../src/common/src/util';
import { angular1Providers, setTempInjectorRef } from './angular1_providers';
import { NgAdapterInjector } from './util';
let moduleUid = 0;
/**
* @description
*
* A helper function for creating an AngularJS module that can bootstrap an Angular module
* "on-demand" (possibly lazily) when a {@link downgradeComponent downgraded component} needs to be
* instantiated.
*
* *Part of the [upgrade/static](api?query=upgrade/static) library for hybrid upgrade apps that
* support AOT compilation.*
*
* It allows loading/bootstrapping the Angular part of a hybrid application lazily and not having to
* pay the cost up-front. For example, you can have an AngularJS application that uses Angular for
* specific routes and only instantiate the Angular modules if/when the user visits one of these
* routes.
*
* The Angular module will be bootstrapped once (when requested for the first time) and the same
* reference will be used from that point onwards.
*
* `downgradeModule()` requires either an `NgModuleFactory` or a function:
* - `NgModuleFactory`: If you pass an `NgModuleFactory`, it will be used to instantiate a module
* using `platformBrowser`'s {@link PlatformRef#bootstrapModuleFactory bootstrapModuleFactory()}.
* - `Function`: If you pass a function, it is expected to return a promise resolving to an
* `NgModuleRef`. The function is called with an array of extra {@link StaticProvider Providers}
* that are expected to be available from the returned `NgModuleRef`'s `Injector`.
*
* `downgradeModule()` returns the name of the created AngularJS wrapper module. You can use it to
* declare a dependency in your main AngularJS module.
*
* {@example upgrade/static/ts/lite/module.ts region="basic-how-to"}
*
* For more details on how to use `downgradeModule()` see
* [Upgrading for Performance](guide/upgrade-performance).
*
* @usageNotes
*
* Apart from `UpgradeModule`, you can use the rest of the `upgrade/static` helpers as usual to
* build a hybrid application. Note that the Angular pieces (e.g. downgraded services) will not be
* available until the downgraded module has been bootstrapped, i.e. by instantiating a downgraded
* component.
*
* <div class="alert is-important">
*
* You cannot use `downgradeModule()` and `UpgradeModule` in the same hybrid application.<br />
* Use one or the other.
*
* </div>
*
* ### Differences with `UpgradeModule`
*
* Besides their different API, there are two important internal differences between
* `downgradeModule()` and `UpgradeModule` that affect the behavior of hybrid applications:
*
* 1. Unlike `UpgradeModule`, `downgradeModule()` does not bootstrap the main AngularJS module
* inside the {@link NgZone Angular zone}.
* 2. Unlike `UpgradeModule`, `downgradeModule()` does not automatically run a
* [$digest()](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$digest) when changes are
* detected in the Angular part of the application.
*
* What this means is that applications using `UpgradeModule` will run change detection more
* frequently in order to ensure that both frameworks are properly notified about possible changes.
* This will inevitably result in more change detection runs than necessary.
*
* `downgradeModule()`, on the other side, does not try to tie the two change detection systems as
* tightly, restricting the explicit change detection runs only to cases where it knows it is
* necessary (e.g. when the inputs of a downgraded component change). This improves performance,
* especially in change-detection-heavy applications, but leaves it up to the developer to manually
* notify each framework as needed.
*
* For a more detailed discussion of the differences and their implications, see
* [Upgrading for Performance](guide/upgrade-performance).
*
* <div class="alert is-helpful">
*
* You can manually trigger a change detection run in AngularJS using
* [scope.$apply(...)](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$apply) or
* [$rootScope.$digest()](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$digest).
*
* You can manually trigger a change detection run in Angular using {@link NgZone#run
* ngZone.run(...)}.
*
* </div>
*
* ### Downgrading multiple modules
*
* It is possible to downgrade multiple modules and include them in an AngularJS application. In
* that case, each downgraded module will be bootstrapped when an associated downgraded component or
* injectable needs to be instantiated.
*
* Things to keep in mind, when downgrading multiple modules:
*
* - Each downgraded component/injectable needs to be explicitly associated with a downgraded
* module. See `downgradeComponent()` and `downgradeInjectable()` for more details.
*
* - If you want some injectables to be shared among all downgraded modules, you can provide them as
* `StaticProvider`s, when creating the `PlatformRef` (e.g. via `platformBrowser` or
* `platformBrowserDynamic`).
*
* - When using {@link PlatformRef#bootstrapmodule `bootstrapModule()`} or
* {@link PlatformRef#bootstrapmodulefactory `bootstrapModuleFactory()`} to bootstrap the
* downgraded modules, each one is considered a "root" module. As a consequence, a new instance
* will be created for every injectable provided in `"root"` (via
* {@link Injectable#providedIn `providedIn`}).
* If this is not your intention, you can have a shared module (that will act as act as the "root"
* module) and create all downgraded modules using that module's injector:
*
* {@example upgrade/static/ts/lite-multi-shared/module.ts region="shared-root-module"}
*
* @publicApi
*/
export function downgradeModule(moduleFactoryOrBootstrapFn) {
const lazyModuleName = `${UPGRADE_MODULE_NAME}.lazy${++moduleUid}`;
const lazyModuleRefKey = `${LAZY_MODULE_REF}${lazyModuleName}`;
const lazyInjectorKey = `${INJECTOR_KEY}${lazyModuleName}`;
const bootstrapFn = isFunction(moduleFactoryOrBootstrapFn) ?
moduleFactoryOrBootstrapFn :
(extraProviders) => platformBrowser(extraProviders).bootstrapModuleFactory(moduleFactoryOrBootstrapFn);
let injector;
// Create an ng1 module to bootstrap.
angularModule(lazyModuleName, [])
.constant(UPGRADE_APP_TYPE_KEY, 3 /* Lite */)
.factory(INJECTOR_KEY, [lazyInjectorKey, identity])
.factory(lazyInjectorKey, () => {
if (!injector) {
throw new Error('Trying to get the Angular injector before bootstrapping the corresponding ' +
'Angular module.');
}
return injector;
})
.factory(LAZY_MODULE_REF, [lazyModuleRefKey, identity])
.factory(lazyModuleRefKey, [
$INJECTOR,
($injector) => {
setTempInjectorRef($injector);
const result = {
promise: bootstrapFn(angular1Providers).then(ref => {
injector = result.injector = new NgAdapterInjector(ref.injector);
injector.get($INJECTOR);
// Destroy the AngularJS app once the Angular `PlatformRef` is destroyed.
// This does not happen in a typical SPA scenario, but it might be useful for
// other use-cases where disposing of an Angular/AngularJS app is necessary
// (such as Hot Module Replacement (HMR)).
// See https://github.com/angular/angular/issues/39935.
injector.get(PlatformRef).onDestroy(() => destroyApp($injector));
return injector;
})
};
return result;
}
])
.config([
$INJECTOR, $PROVIDE,
($injector, $provide) => {
$provide.constant(DOWNGRADED_MODULE_COUNT_KEY, getDowngradedModuleCount($injector) + 1);
}
]);
return lazyModuleName;
}
function identity(x) {
return x;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"downgrade_module.js","sourceRoot":"","sources":["../../../../../../../packages/upgrade/static/src/downgrade_module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAyC,WAAW,EAAiB,MAAM,eAAe,CAAC;AAClG,OAAO,EAAC,eAAe,EAAC,MAAM,2BAA2B,CAAC;AAE1D,OAAO,EAAoC,OAAO,IAAI,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAC1G,OAAO,EAAC,SAAS,EAAE,QAAQ,EAAE,2BAA2B,EAAE,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAC1K,OAAO,EAAC,UAAU,EAAE,wBAAwB,EAAE,UAAU,EAAgC,MAAM,2BAA2B,CAAC;AAE1H,OAAO,EAAC,iBAAiB,EAAE,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAC,iBAAiB,EAAC,MAAM,QAAQ,CAAC;AAGzC,IAAI,SAAS,GAAG,CAAC,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4GG;AACH,MAAM,UAAU,eAAe,CAAI,0BAC+B;IAChE,MAAM,cAAc,GAAG,GAAG,mBAAmB,QAAQ,EAAE,SAAS,EAAE,CAAC;IACnE,MAAM,gBAAgB,GAAG,GAAG,eAAe,GAAG,cAAc,EAAE,CAAC;IAC/D,MAAM,eAAe,GAAG,GAAG,YAAY,GAAG,cAAc,EAAE,CAAC;IAE3D,MAAM,WAAW,GAAG,UAAU,CAAC,0BAA0B,CAAC,CAAC,CAAC;QACxD,0BAA0B,CAAC,CAAC;QAC5B,CAAC,cAAgC,EAAE,EAAE,CACjC,eAAe,CAAC,cAAc,CAAC,CAAC,sBAAsB,CAAC,0BAA0B,CAAC,CAAC;IAE3F,IAAI,QAAkB,CAAC;IAEvB,qCAAqC;IACrC,aAAa,CAAC,cAAc,EAAE,EAAE,CAAC;SAC5B,QAAQ,CAAC,oBAAoB,eAAsB;SACnD,OAAO,CAAC,YAAY,EAAE,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;SAClD,OAAO,CACJ,eAAe,EACf,GAAG,EAAE;QACH,IAAI,CAAC,QAAQ,EAAE;YACb,MAAM,IAAI,KAAK,CACX,4EAA4E;gBAC5E,iBAAiB,CAAC,CAAC;SACxB;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC;SACL,OAAO,CAAC,eAAe,EAAE,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;SACtD,OAAO,CACJ,gBAAgB,EAChB;QACE,SAAS;QACT,CAAC,SAA2B,EAAE,EAAE;YAC9B,kBAAkB,CAAC,SAAS,CAAC,CAAC;YAC9B,MAAM,MAAM,GAAkB;gBAC5B,OAAO,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;oBACjD,QAAQ,GAAG,MAAM,CAAC,QAAQ,GAAG,IAAI,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;oBACjE,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;oBAExB,yEAAyE;oBACzE,6EAA6E;oBAC7E,2EAA2E;oBAC3E,0CAA0C;oBAC1C,uDAAuD;oBACvD,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC;oBAEjE,OAAO,QAAQ,CAAC;gBAClB,CAAC,CAAC;aACH,CAAC;YACF,OAAO,MAAM,CAAC;QAChB,CAAC;KACF,CAAC;SACL,MAAM,CAAC;QACN,SAAS,EAAE,QAAQ;QACnB,CAAC,SAA2B,EAAE,QAAyB,EAAE,EAAE;YACzD,QAAQ,CAAC,QAAQ,CAAC,2BAA2B,EAAE,wBAAwB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1F,CAAC;KACF,CAAC,CAAC;IAEP,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,SAAS,QAAQ,CAAU,CAAI;IAC7B,OAAO,CAAC,CAAC;AACX,CAAC","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 {Injector, NgModuleFactory, NgModuleRef, PlatformRef, StaticProvider} from '@angular/core';\nimport {platformBrowser} from '@angular/platform-browser';\n\nimport {IInjectorService, IProvideService, module_ as angularModule} from '../../src/common/src/angular1';\nimport {$INJECTOR, $PROVIDE, DOWNGRADED_MODULE_COUNT_KEY, INJECTOR_KEY, LAZY_MODULE_REF, UPGRADE_APP_TYPE_KEY, UPGRADE_MODULE_NAME} from '../../src/common/src/constants';\nimport {destroyApp, getDowngradedModuleCount, isFunction, LazyModuleRef, UpgradeAppType} from '../../src/common/src/util';\n\nimport {angular1Providers, setTempInjectorRef} from './angular1_providers';\nimport {NgAdapterInjector} from './util';\n\n\nlet moduleUid = 0;\n\n/**\n * @description\n *\n * A helper function for creating an AngularJS module that can bootstrap an Angular module\n * \"on-demand\" (possibly lazily) when a {@link downgradeComponent downgraded component} needs to be\n * instantiated.\n *\n * *Part of the [upgrade/static](api?query=upgrade/static) library for hybrid upgrade apps that\n * support AOT compilation.*\n *\n * It allows loading/bootstrapping the Angular part of a hybrid application lazily and not having to\n * pay the cost up-front. For example, you can have an AngularJS application that uses Angular for\n * specific routes and only instantiate the Angular modules if/when the user visits one of these\n * routes.\n *\n * The Angular module will be bootstrapped once (when requested for the first time) and the same\n * reference will be used from that point onwards.\n *\n * `downgradeModule()` requires either an `NgModuleFactory` or a function:\n * - `NgModuleFactory`: If you pass an `NgModuleFactory`, it will be used to instantiate a module\n *   using `platformBrowser`'s {@link PlatformRef#bootstrapModuleFactory bootstrapModuleFactory()}.\n * - `Function`: If you pass a function, it is expected to return a promise resolving to an\n *   `NgModuleRef`. The function is called with an array of extra {@link StaticProvider Providers}\n *   that are expected to be available from the returned `NgModuleRef`'s `Injector`.\n *\n * `downgradeModule()` returns the name of the created AngularJS wrapper module. You can use it to\n * declare a dependency in your main AngularJS module.\n *\n * {@example upgrade/static/ts/lite/module.ts region=\"basic-how-to\"}\n *\n * For more details on how to use `downgradeModule()` see\n * [Upgrading for Performance](guide/upgrade-performance).\n *\n * @usageNotes\n *\n * Apart from `UpgradeModule`, you can use the rest of the `upgrade/static` helpers as usual to\n * build a hybrid application. Note that the Angular pieces (e.g. downgraded services) will not be\n * available until the downgraded module has been bootstrapped, i.e. by instantiating a downgraded\n * component.\n *\n * <div class=\"alert is-important\">\n *\n *   You cannot use `downgradeModule()` and `UpgradeModule` in the same hybrid application.<br />\n *   Use one or the other.\n *\n * </div>\n *\n * ### Differences with `UpgradeModule`\n *\n * Besides their different API, there are two important internal differences between\n * `downgradeModule()` and `UpgradeModule` that affect the behavior of hybrid applications:\n *\n * 1. Unlike `UpgradeModule`, `downgradeModule()` does not bootstrap the main AngularJS module\n *    inside the {@link NgZone Angular zone}.\n * 2. Unlike `UpgradeModule`, `downgradeModule()` does not automatically run a\n *    [$digest()](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$digest) when changes are\n *    detected in the Angular part of the application.\n *\n * What this means is that applications using `UpgradeModule` will run change detection more\n * frequently in order to ensure that both frameworks are properly notified about possible changes.\n * This will inevitably result in more change detection runs than necessary.\n *\n * `downgradeModule()`, on the other side, does not try to tie the two change detection systems as\n * tightly, restricting the explicit change detection runs only to cases where it knows it is\n * necessary (e.g. when the inputs of a downgraded component change). This improves performance,\n * especially in change-detection-heavy applications, but leaves it up to the developer to manually\n * notify each framework as needed.\n *\n * For a more detailed discussion of the differences and their implications, see\n * [Upgrading for Performance](guide/upgrade-performance).\n *\n * <div class=\"alert is-helpful\">\n *\n *   You can manually trigger a change detection run in AngularJS using\n *   [scope.$apply(...)](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$apply) or\n *   [$rootScope.$digest()](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$digest).\n *\n *   You can manually trigger a change detection run in Angular using {@link NgZone#run\n *   ngZone.run(...)}.\n *\n * </div>\n *\n * ### Downgrading multiple modules\n *\n * It is possible to downgrade multiple modules and include them in an AngularJS application. In\n * that case, each downgraded module will be bootstrapped when an associated downgraded component or\n * injectable needs to be instantiated.\n *\n * Things to keep in mind, when downgrading multiple modules:\n *\n * - Each downgraded component/injectable needs to be explicitly associated with a downgraded\n *   module. See `downgradeComponent()` and `downgradeInjectable()` for more details.\n *\n * - If you want some injectables to be shared among all downgraded modules, you can provide them as\n *   `StaticProvider`s, when creating the `PlatformRef` (e.g. via `platformBrowser` or\n *   `platformBrowserDynamic`).\n *\n * - When using {@link PlatformRef#bootstrapmodule `bootstrapModule()`} or\n *   {@link PlatformRef#bootstrapmodulefactory `bootstrapModuleFactory()`} to bootstrap the\n *   downgraded modules, each one is considered a \"root\" module. As a consequence, a new instance\n *   will be created for every injectable provided in `\"root\"` (via\n *   {@link Injectable#providedIn `providedIn`}).\n *   If this is not your intention, you can have a shared module (that will act as act as the \"root\"\n *   module) and create all downgraded modules using that module's injector:\n *\n *   {@example upgrade/static/ts/lite-multi-shared/module.ts region=\"shared-root-module\"}\n *\n * @publicApi\n */\nexport function downgradeModule<T>(moduleFactoryOrBootstrapFn: NgModuleFactory<T>|(\n    (extraProviders: StaticProvider[]) => Promise<NgModuleRef<T>>)): string {\n  const lazyModuleName = `${UPGRADE_MODULE_NAME}.lazy${++moduleUid}`;\n  const lazyModuleRefKey = `${LAZY_MODULE_REF}${lazyModuleName}`;\n  const lazyInjectorKey = `${INJECTOR_KEY}${lazyModuleName}`;\n\n  const bootstrapFn = isFunction(moduleFactoryOrBootstrapFn) ?\n      moduleFactoryOrBootstrapFn :\n      (extraProviders: StaticProvider[]) =>\n          platformBrowser(extraProviders).bootstrapModuleFactory(moduleFactoryOrBootstrapFn);\n\n  let injector: Injector;\n\n  // Create an ng1 module to bootstrap.\n  angularModule(lazyModuleName, [])\n      .constant(UPGRADE_APP_TYPE_KEY, UpgradeAppType.Lite)\n      .factory(INJECTOR_KEY, [lazyInjectorKey, identity])\n      .factory(\n          lazyInjectorKey,\n          () => {\n            if (!injector) {\n              throw new Error(\n                  'Trying to get the Angular injector before bootstrapping the corresponding ' +\n                  'Angular module.');\n            }\n            return injector;\n          })\n      .factory(LAZY_MODULE_REF, [lazyModuleRefKey, identity])\n      .factory(\n          lazyModuleRefKey,\n          [\n            $INJECTOR,\n            ($injector: IInjectorService) => {\n              setTempInjectorRef($injector);\n              const result: LazyModuleRef = {\n                promise: bootstrapFn(angular1Providers).then(ref => {\n                  injector = result.injector = new NgAdapterInjector(ref.injector);\n                  injector.get($INJECTOR);\n\n                  // Destroy the AngularJS app once the Angular `PlatformRef` is destroyed.\n                  // This does not happen in a typical SPA scenario, but it might be useful for\n                  // other use-cases where disposing of an Angular/AngularJS app is necessary\n                  // (such as Hot Module Replacement (HMR)).\n                  // See https://github.com/angular/angular/issues/39935.\n                  injector.get(PlatformRef).onDestroy(() => destroyApp($injector));\n\n                  return injector;\n                })\n              };\n              return result;\n            }\n          ])\n      .config([\n        $INJECTOR, $PROVIDE,\n        ($injector: IInjectorService, $provide: IProvideService) => {\n          $provide.constant(DOWNGRADED_MODULE_COUNT_KEY, getDowngradedModuleCount($injector) + 1);\n        }\n      ]);\n\n  return lazyModuleName;\n}\n\nfunction identity<T = any>(x: T): T {\n  return x;\n}\n"]}