1 | /**
|
2 | * @license
|
3 | * Copyright Google LLC All Rights Reserved.
|
4 | *
|
5 | * Use of this source code is governed by an MIT-style license that can be
|
6 | * found in the LICENSE file at https://angular.io/license
|
7 | */
|
8 | import { PlatformRef } from '@angular/core';
|
9 | import { platformBrowser } from '@angular/platform-browser';
|
10 | import { module_ as angularModule } from '../../src/common/src/angular1';
|
11 | import { $INJECTOR, $PROVIDE, DOWNGRADED_MODULE_COUNT_KEY, INJECTOR_KEY, LAZY_MODULE_REF, UPGRADE_APP_TYPE_KEY, UPGRADE_MODULE_NAME } from '../../src/common/src/constants';
|
12 | import { destroyApp, getDowngradedModuleCount, isFunction, isNgModuleType } from '../../src/common/src/util';
|
13 | import { angular1Providers, setTempInjectorRef } from './angular1_providers';
|
14 | import { NgAdapterInjector } from './util';
|
15 | let moduleUid = 0;
|
16 | /**
|
17 | * @description
|
18 | *
|
19 | * A helper function for creating an AngularJS module that can bootstrap an Angular module
|
20 | * "on-demand" (possibly lazily) when a {@link downgradeComponent downgraded component} needs to be
|
21 | * instantiated.
|
22 | *
|
23 | * *Part of the [upgrade/static](api?query=upgrade/static) library for hybrid upgrade apps that
|
24 | * support AOT compilation.*
|
25 | *
|
26 | * It allows loading/bootstrapping the Angular part of a hybrid application lazily and not having to
|
27 | * pay the cost up-front. For example, you can have an AngularJS application that uses Angular for
|
28 | * specific routes and only instantiate the Angular modules if/when the user visits one of these
|
29 | * routes.
|
30 | *
|
31 | * The Angular module will be bootstrapped once (when requested for the first time) and the same
|
32 | * reference will be used from that point onwards.
|
33 | *
|
34 | * `downgradeModule()` requires either an `NgModuleFactory`, `NgModule` class or a function:
|
35 | * - `NgModuleFactory`: If you pass an `NgModuleFactory`, it will be used to instantiate a module
|
36 | * using `platformBrowser`'s {@link PlatformRef#bootstrapModuleFactory bootstrapModuleFactory()}.
|
37 | * NOTE: this type of the argument is deprecated. Please either provide an `NgModule` class or a
|
38 | * bootstrap function instead.
|
39 | * - `NgModule` class: If you pass an NgModule class, it will be used to instantiate a module
|
40 | * using `platformBrowser`'s {@link PlatformRef#bootstrapModule bootstrapModule()}.
|
41 | * - `Function`: If you pass a function, it is expected to return a promise resolving to an
|
42 | * `NgModuleRef`. The function is called with an array of extra {@link StaticProvider Providers}
|
43 | * that are expected to be available from the returned `NgModuleRef`'s `Injector`.
|
44 | *
|
45 | * `downgradeModule()` returns the name of the created AngularJS wrapper module. You can use it to
|
46 | * declare a dependency in your main AngularJS module.
|
47 | *
|
48 | * {@example upgrade/static/ts/lite/module.ts region="basic-how-to"}
|
49 | *
|
50 | * For more details on how to use `downgradeModule()` see
|
51 | * [Upgrading for Performance](guide/upgrade-performance).
|
52 | *
|
53 | * @usageNotes
|
54 | *
|
55 | * Apart from `UpgradeModule`, you can use the rest of the `upgrade/static` helpers as usual to
|
56 | * build a hybrid application. Note that the Angular pieces (e.g. downgraded services) will not be
|
57 | * available until the downgraded module has been bootstrapped, i.e. by instantiating a downgraded
|
58 | * component.
|
59 | *
|
60 | * <div class="alert is-important">
|
61 | *
|
62 | * You cannot use `downgradeModule()` and `UpgradeModule` in the same hybrid application.<br />
|
63 | * Use one or the other.
|
64 | *
|
65 | * </div>
|
66 | *
|
67 | * ### Differences with `UpgradeModule`
|
68 | *
|
69 | * Besides their different API, there are two important internal differences between
|
70 | * `downgradeModule()` and `UpgradeModule` that affect the behavior of hybrid applications:
|
71 | *
|
72 | * 1. Unlike `UpgradeModule`, `downgradeModule()` does not bootstrap the main AngularJS module
|
73 | * inside the {@link NgZone Angular zone}.
|
74 | * 2. Unlike `UpgradeModule`, `downgradeModule()` does not automatically run a
|
75 | * [$digest()](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$digest) when changes are
|
76 | * detected in the Angular part of the application.
|
77 | *
|
78 | * What this means is that applications using `UpgradeModule` will run change detection more
|
79 | * frequently in order to ensure that both frameworks are properly notified about possible changes.
|
80 | * This will inevitably result in more change detection runs than necessary.
|
81 | *
|
82 | * `downgradeModule()`, on the other side, does not try to tie the two change detection systems as
|
83 | * tightly, restricting the explicit change detection runs only to cases where it knows it is
|
84 | * necessary (e.g. when the inputs of a downgraded component change). This improves performance,
|
85 | * especially in change-detection-heavy applications, but leaves it up to the developer to manually
|
86 | * notify each framework as needed.
|
87 | *
|
88 | * For a more detailed discussion of the differences and their implications, see
|
89 | * [Upgrading for Performance](guide/upgrade-performance).
|
90 | *
|
91 | * <div class="alert is-helpful">
|
92 | *
|
93 | * You can manually trigger a change detection run in AngularJS using
|
94 | * [scope.$apply(...)](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$apply) or
|
95 | * [$rootScope.$digest()](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$digest).
|
96 | *
|
97 | * You can manually trigger a change detection run in Angular using {@link NgZone#run
|
98 | * ngZone.run(...)}.
|
99 | *
|
100 | * </div>
|
101 | *
|
102 | * ### Downgrading multiple modules
|
103 | *
|
104 | * It is possible to downgrade multiple modules and include them in an AngularJS application. In
|
105 | * that case, each downgraded module will be bootstrapped when an associated downgraded component or
|
106 | * injectable needs to be instantiated.
|
107 | *
|
108 | * Things to keep in mind, when downgrading multiple modules:
|
109 | *
|
110 | * - Each downgraded component/injectable needs to be explicitly associated with a downgraded
|
111 | * module. See `downgradeComponent()` and `downgradeInjectable()` for more details.
|
112 | *
|
113 | * - If you want some injectables to be shared among all downgraded modules, you can provide them as
|
114 | * `StaticProvider`s, when creating the `PlatformRef` (e.g. via `platformBrowser` or
|
115 | * `platformBrowserDynamic`).
|
116 | *
|
117 | * - When using {@link PlatformRef#bootstrapmodule `bootstrapModule()`} or
|
118 | * {@link PlatformRef#bootstrapmodulefactory `bootstrapModuleFactory()`} to bootstrap the
|
119 | * downgraded modules, each one is considered a "root" module. As a consequence, a new instance
|
120 | * will be created for every injectable provided in `"root"` (via
|
121 | * {@link Injectable#providedIn `providedIn`}).
|
122 | * If this is not your intention, you can have a shared module (that will act as act as the "root"
|
123 | * module) and create all downgraded modules using that module's injector:
|
124 | *
|
125 | * {@example upgrade/static/ts/lite-multi-shared/module.ts region="shared-root-module"}
|
126 | *
|
127 | * @publicApi
|
128 | */
|
129 | export function downgradeModule(moduleOrBootstrapFn) {
|
130 | const lazyModuleName = `${UPGRADE_MODULE_NAME}.lazy${++moduleUid}`;
|
131 | const lazyModuleRefKey = `${LAZY_MODULE_REF}${lazyModuleName}`;
|
132 | const lazyInjectorKey = `${INJECTOR_KEY}${lazyModuleName}`;
|
133 | let bootstrapFn;
|
134 | if (isNgModuleType(moduleOrBootstrapFn)) {
|
135 | // NgModule class
|
136 | bootstrapFn = (extraProviders) => platformBrowser(extraProviders).bootstrapModule(moduleOrBootstrapFn);
|
137 | }
|
138 | else if (!isFunction(moduleOrBootstrapFn)) {
|
139 | // NgModule factory
|
140 | bootstrapFn = (extraProviders) => platformBrowser(extraProviders).bootstrapModuleFactory(moduleOrBootstrapFn);
|
141 | }
|
142 | else {
|
143 | // bootstrap function
|
144 | bootstrapFn = moduleOrBootstrapFn;
|
145 | }
|
146 | let injector;
|
147 | // Create an ng1 module to bootstrap.
|
148 | angularModule(lazyModuleName, [])
|
149 | .constant(UPGRADE_APP_TYPE_KEY, 3 /* UpgradeAppType.Lite */)
|
150 | .factory(INJECTOR_KEY, [lazyInjectorKey, identity])
|
151 | .factory(lazyInjectorKey, () => {
|
152 | if (!injector) {
|
153 | throw new Error('Trying to get the Angular injector before bootstrapping the corresponding ' +
|
154 | 'Angular module.');
|
155 | }
|
156 | return injector;
|
157 | })
|
158 | .factory(LAZY_MODULE_REF, [lazyModuleRefKey, identity])
|
159 | .factory(lazyModuleRefKey, [
|
160 | $INJECTOR,
|
161 | ($injector) => {
|
162 | setTempInjectorRef($injector);
|
163 | const result = {
|
164 | promise: bootstrapFn(angular1Providers).then(ref => {
|
165 | injector = result.injector = new NgAdapterInjector(ref.injector);
|
166 | injector.get($INJECTOR);
|
167 | // Destroy the AngularJS app once the Angular `PlatformRef` is destroyed.
|
168 | // This does not happen in a typical SPA scenario, but it might be useful for
|
169 | // other use-cases where disposing of an Angular/AngularJS app is necessary
|
170 | // (such as Hot Module Replacement (HMR)).
|
171 | // See https://github.com/angular/angular/issues/39935.
|
172 | injector.get(PlatformRef).onDestroy(() => destroyApp($injector));
|
173 | return injector;
|
174 | })
|
175 | };
|
176 | return result;
|
177 | }
|
178 | ])
|
179 | .config([
|
180 | $INJECTOR, $PROVIDE,
|
181 | ($injector, $provide) => {
|
182 | $provide.constant(DOWNGRADED_MODULE_COUNT_KEY, getDowngradedModuleCount($injector) + 1);
|
183 | }
|
184 | ]);
|
185 | return lazyModuleName;
|
186 | }
|
187 | function identity(x) {
|
188 | return x;
|
189 | }
|
190 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"downgrade_module.js","sourceRoot":"","sources":["../../../../../../../packages/upgrade/static/src/downgrade_module.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 {Injector, NgModuleFactory, NgModuleRef, PlatformRef, StaticProvider, Type} 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, isNgModuleType, 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`, `NgModule` class 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 *   NOTE: this type of the argument is deprecated. Please either provide an `NgModule` class or a\n *   bootstrap function instead.\n * - `NgModule` class: If you pass an NgModule class, it will be used to instantiate a module\n *   using `platformBrowser`'s {@link PlatformRef#bootstrapModule bootstrapModule()}.\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>(moduleOrBootstrapFn: Type<T>|(\n    (extraProviders: StaticProvider[]) => Promise<NgModuleRef<T>>)): string;\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`, `NgModule` class 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 *   NOTE: this type of the argument is deprecated. Please either provide an `NgModule` class or a\n *   bootstrap function instead.\n * - `NgModule` class: If you pass an NgModule class, it will be used to instantiate a module\n *   using `platformBrowser`'s {@link PlatformRef#bootstrapModule bootstrapModule()}.\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 *\n * @deprecated Passing `NgModuleFactory` as the `downgradeModule` function argument is deprecated,\n *     please pass an NgModule class reference instead.\n */\nexport function downgradeModule<T>(moduleOrBootstrapFn: NgModuleFactory<T>): string;\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`, `NgModule` class 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 *   NOTE: this type of the argument is deprecated. Please either provide an `NgModule` class or a\n *   bootstrap function instead.\n * - `NgModule` class: If you pass an NgModule class, it will be used to instantiate a module\n *   using `platformBrowser`'s {@link PlatformRef#bootstrapModule bootstrapModule()}.\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>(moduleOrBootstrapFn: Type<T>|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  let bootstrapFn: (extraProviders: StaticProvider[]) => Promise<NgModuleRef<T>>;\n  if (isNgModuleType(moduleOrBootstrapFn)) {\n    // NgModule class\n    bootstrapFn = (extraProviders: StaticProvider[]) =>\n        platformBrowser(extraProviders).bootstrapModule(moduleOrBootstrapFn);\n  } else if (!isFunction(moduleOrBootstrapFn)) {\n    // NgModule factory\n    bootstrapFn = (extraProviders: StaticProvider[]) =>\n        platformBrowser(extraProviders).bootstrapModuleFactory(moduleOrBootstrapFn);\n  } else {\n    // bootstrap function\n    bootstrapFn = moduleOrBootstrapFn;\n  }\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"]} |
\ | No newline at end of file |