@angular/upgrade 13.0.0-next.8 → 13.0.0-rc.2

package/esm2020/src/dynamic/src/upgrade_adapter.mjs

@@ -0,0 +1,683 @@
+/**
+ * @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 { __decorate, __metadata } from "tslib";
+import { Compiler, Injector, isDevMode, NgModule, NgZone, resolveForwardRef, Testability } from '@angular/core';
+import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+import { bootstrap, element as angularElement, module_ as angularModule } from '../../common/src/angular1';
+import { $$TESTABILITY, $COMPILE, $INJECTOR, $ROOT_SCOPE, COMPILER_KEY, INJECTOR_KEY, LAZY_MODULE_REF, NG_ZONE_KEY, UPGRADE_APP_TYPE_KEY } from '../../common/src/constants';
+import { downgradeComponent } from '../../common/src/downgrade_component';
+import { downgradeInjectable } from '../../common/src/downgrade_injectable';
+import { controllerKey, Deferred, destroyApp, onError } from '../../common/src/util';
+import { UpgradeNg1ComponentAdapterBuilder } from './upgrade_ng1_adapter';
+let upgradeCount = 0;
+/**
+ * Use `UpgradeAdapter` to allow AngularJS and Angular to coexist in a single application.
+ *
+ * The `UpgradeAdapter` allows:
+ * 1. creation of Angular component from AngularJS component directive
+ *    (See [UpgradeAdapter#upgradeNg1Component()])
+ * 2. creation of AngularJS directive from Angular component.
+ *    (See [UpgradeAdapter#downgradeNg2Component()])
+ * 3. Bootstrapping of a hybrid Angular application which contains both of the frameworks
+ *    coexisting in a single application.
+ *
+ * @usageNotes
+ * ### Mental Model
+ *
+ * When reasoning about how a hybrid application works it is useful to have a mental model which
+ * describes what is happening and explains what is happening at the lowest level.
+ *
+ * 1. There are two independent frameworks running in a single application, each framework treats
+ *    the other as a black box.
+ * 2. Each DOM element on the page is owned exactly by one framework. Whichever framework
+ *    instantiated the element is the owner. Each framework only updates/interacts with its own
+ *    DOM elements and ignores others.
+ * 3. AngularJS directives always execute inside AngularJS framework codebase regardless of
+ *    where they are instantiated.
+ * 4. Angular components always execute inside Angular framework codebase regardless of
+ *    where they are instantiated.
+ * 5. An AngularJS component can be upgraded to an Angular component. This creates an
+ *    Angular directive, which bootstraps the AngularJS component directive in that location.
+ * 6. An Angular component can be downgraded to an AngularJS component directive. This creates
+ *    an AngularJS directive, which bootstraps the Angular component in that location.
+ * 7. Whenever an adapter component is instantiated the host element is owned by the framework
+ *    doing the instantiation. The other framework then instantiates and owns the view for that
+ *    component. This implies that component bindings will always follow the semantics of the
+ *    instantiation framework. The syntax is always that of Angular syntax.
+ * 8. AngularJS is always bootstrapped first and owns the bottom most view.
+ * 9. The new application is running in Angular zone, and therefore it no longer needs calls to
+ *    `$apply()`.
+ *
+ * ### Example
+ *
+ * ```
+ * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module), myCompilerOptions);
+ * const module = angular.module('myExample', []);
+ * module.directive('ng2Comp', adapter.downgradeNg2Component(Ng2Component));
+ *
+ * module.directive('ng1Hello', function() {
+ *   return {
+ *      scope: { title: '=' },
+ *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'
+ *   };
+ * });
+ *
+ *
+ * @Component({
+ *   selector: 'ng2-comp',
+ *   inputs: ['name'],
+ *   template: 'ng2[<ng1-hello [title]="name">transclude</ng1-hello>](<ng-content></ng-content>)',
+ *   directives:
+ * })
+ * class Ng2Component {
+ * }
+ *
+ * @NgModule({
+ *   declarations: [Ng2Component, adapter.upgradeNg1Component('ng1Hello')],
+ *   imports: [BrowserModule]
+ * })
+ * class MyNg2Module {}
+ *
+ *
+ * document.body.innerHTML = '<ng2-comp name="World">project</ng2-comp>';
+ *
+ * adapter.bootstrap(document.body, ['myExample']).ready(function() {
+ *   expect(document.body.textContent).toEqual(
+ *       "ng2[ng1[Hello World!](transclude)](project)");
+ * });
+ *
+ * ```
+ *
+ * @deprecated Deprecated since v5. Use `upgrade/static` instead, which also supports
+ * [Ahead-of-Time compilation](guide/aot-compiler).
+ * @publicApi
+ */
+export class UpgradeAdapter {
+    constructor(ng2AppModule, compilerOptions) {
+        this.ng2AppModule = ng2AppModule;
+        this.compilerOptions = compilerOptions;
+        this.idPrefix = `NG2_UPGRADE_${upgradeCount++}_`;
+        this.downgradedComponents = [];
+        /**
+         * An internal map of ng1 components which need to up upgraded to ng2.
+         *
+         * We can't upgrade until injector is instantiated and we can retrieve the component metadata.
+         * For this reason we keep a list of components to upgrade until ng1 injector is bootstrapped.
+         *
+         * @internal
+         */
+        this.ng1ComponentsToBeUpgraded = {};
+        this.upgradedProviders = [];
+        this.moduleRef = null;
+        if (!ng2AppModule) {
+            throw new Error('UpgradeAdapter cannot be instantiated without an NgModule of the Angular app.');
+        }
+    }
+    /**
+     * Allows Angular Component to be used from AngularJS.
+     *
+     * Use `downgradeNg2Component` to create an AngularJS Directive Definition Factory from
+     * Angular Component. The adapter will bootstrap Angular component from within the
+     * AngularJS template.
+     *
+     * @usageNotes
+     * ### Mental Model
+     *
+     * 1. The component is instantiated by being listed in AngularJS template. This means that the
+     *    host element is controlled by AngularJS, but the component's view will be controlled by
+     *    Angular.
+     * 2. Even thought the component is instantiated in AngularJS, it will be using Angular
+     *    syntax. This has to be done, this way because we must follow Angular components do not
+     *    declare how the attributes should be interpreted.
+     * 3. `ng-model` is controlled by AngularJS and communicates with the downgraded Angular component
+     *    by way of the `ControlValueAccessor` interface from @angular/forms. Only components that
+     *    implement this interface are eligible.
+     *
+     * ### Supported Features
+     *
+     * - Bindings:
+     *   - Attribute: `<comp name="World">`
+     *   - Interpolation:  `<comp greeting="Hello {{name}}!">`
+     *   - Expression:  `<comp [name]="username">`
+     *   - Event:  `<comp (close)="doSomething()">`
+     *   - ng-model: `<comp ng-model="name">`
+     * - Content projection: yes
+     *
+     * ### Example
+     *
+     * ```
+     * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module));
+     * const module = angular.module('myExample', []);
+     * module.directive('greet', adapter.downgradeNg2Component(Greeter));
+     *
+     * @Component({
+     *   selector: 'greet',
+     *   template: '{{salutation}} {{name}}! - <ng-content></ng-content>'
+     * })
+     * class Greeter {
+     *   @Input() salutation: string;
+     *   @Input() name: string;
+     * }
+     *
+     * @NgModule({
+     *   declarations: [Greeter],
+     *   imports: [BrowserModule]
+     * })
+     * class MyNg2Module {}
+     *
+     * document.body.innerHTML =
+     *   'ng1 template: <greet salutation="Hello" [name]="world">text</greet>';
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
+     *   expect(document.body.textContent).toEqual("ng1 template: Hello world! - text");
+     * });
+     * ```
+     */
+    downgradeNg2Component(component) {
+        this.downgradedComponents.push(component);
+        return downgradeComponent({ component });
+    }
+    /**
+     * Allows AngularJS Component to be used from Angular.
+     *
+     * Use `upgradeNg1Component` to create an Angular component from AngularJS Component
+     * directive. The adapter will bootstrap AngularJS component from within the Angular
+     * template.
+     *
+     * @usageNotes
+     * ### Mental Model
+     *
+     * 1. The component is instantiated by being listed in Angular template. This means that the
+     *    host element is controlled by Angular, but the component's view will be controlled by
+     *    AngularJS.
+     *
+     * ### Supported Features
+     *
+     * - Bindings:
+     *   - Attribute: `<comp name="World">`
+     *   - Interpolation:  `<comp greeting="Hello {{name}}!">`
+     *   - Expression:  `<comp [name]="username">`
+     *   - Event:  `<comp (close)="doSomething()">`
+     * - Transclusion: yes
+     * - Only some of the features of
+     *   [Directive Definition Object](https://docs.angularjs.org/api/ng/service/$compile) are
+     *   supported:
+     *   - `compile`: not supported because the host element is owned by Angular, which does
+     *     not allow modifying DOM structure during compilation.
+     *   - `controller`: supported. (NOTE: injection of `$attrs` and `$transclude` is not supported.)
+     *   - `controllerAs`: supported.
+     *   - `bindToController`: supported.
+     *   - `link`: supported. (NOTE: only pre-link function is supported.)
+     *   - `name`: supported.
+     *   - `priority`: ignored.
+     *   - `replace`: not supported.
+     *   - `require`: supported.
+     *   - `restrict`: must be set to 'E'.
+     *   - `scope`: supported.
+     *   - `template`: supported.
+     *   - `templateUrl`: supported.
+     *   - `terminal`: ignored.
+     *   - `transclude`: supported.
+     *
+     *
+     * ### Example
+     *
+     * ```
+     * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module));
+     * const module = angular.module('myExample', []);
+     *
+     * module.directive('greet', function() {
+     *   return {
+     *     scope: {salutation: '=', name: '=' },
+     *     template: '{{salutation}} {{name}}! - <span ng-transclude></span>'
+     *   };
+     * });
+     *
+     * module.directive('ng2', adapter.downgradeNg2Component(Ng2Component));
+     *
+     * @Component({
+     *   selector: 'ng2',
+     *   template: 'ng2 template: <greet salutation="Hello" [name]="world">text</greet>'
+     * })
+     * class Ng2Component {
+     * }
+     *
+     * @NgModule({
+     *   declarations: [Ng2Component, adapter.upgradeNg1Component('greet')],
+     *   imports: [BrowserModule]
+     * })
+     * class MyNg2Module {}
+     *
+     * document.body.innerHTML = '<ng2></ng2>';
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
+     *   expect(document.body.textContent).toEqual("ng2 template: Hello world! - text");
+     * });
+     * ```
+     */
+    upgradeNg1Component(name) {
+        if (this.ng1ComponentsToBeUpgraded.hasOwnProperty(name)) {
+            return this.ng1ComponentsToBeUpgraded[name].type;
+        }
+        else {
+            return (this.ng1ComponentsToBeUpgraded[name] = new UpgradeNg1ComponentAdapterBuilder(name))
+                .type;
+        }
+    }
+    /**
+     * Registers the adapter's AngularJS upgrade module for unit testing in AngularJS.
+     * Use this instead of `angular.mock.module()` to load the upgrade module into
+     * the AngularJS testing injector.
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * const upgradeAdapter = new UpgradeAdapter(MyNg2Module);
+     *
+     * // configure the adapter with upgrade/downgrade components and services
+     * upgradeAdapter.downgradeNg2Component(MyComponent);
+     *
+     * let upgradeAdapterRef: UpgradeAdapterRef;
+     * let $compile, $rootScope;
+     *
+     * // We must register the adapter before any calls to `inject()`
+     * beforeEach(() => {
+     *   upgradeAdapterRef = upgradeAdapter.registerForNg1Tests(['heroApp']);
+     * });
+     *
+     * beforeEach(inject((_$compile_, _$rootScope_) => {
+     *   $compile = _$compile_;
+     *   $rootScope = _$rootScope_;
+     * }));
+     *
+     * it("says hello", (done) => {
+     *   upgradeAdapterRef.ready(() => {
+     *     const element = $compile("<my-component></my-component>")($rootScope);
+     *     $rootScope.$apply();
+     *     expect(element.html()).toContain("Hello World");
+     *     done();
+     *   })
+     * });
+     *
+     * ```
+     *
+     * @param modules any AngularJS modules that the upgrade module should depend upon
+     * @returns an `UpgradeAdapterRef`, which lets you register a `ready()` callback to
+     * run assertions once the Angular components are ready to test through AngularJS.
+     */
+    registerForNg1Tests(modules) {
+        const windowNgMock = window['angular'].mock;
+        if (!windowNgMock || !windowNgMock.module) {
+            throw new Error('Failed to find \'angular.mock.module\'.');
+        }
+        this.declareNg1Module(modules);
+        windowNgMock.module(this.ng1Module.name);
+        const upgrade = new UpgradeAdapterRef();
+        this.ng2BootstrapDeferred.promise.then((ng1Injector) => {
+            upgrade._bootstrapDone(this.moduleRef, ng1Injector);
+        }, onError);
+        return upgrade;
+    }
+    /**
+     * Bootstrap a hybrid AngularJS / Angular application.
+     *
+     * This `bootstrap` method is a direct replacement (takes same arguments) for AngularJS
+     * [`bootstrap`](https://docs.angularjs.org/api/ng/function/angular.bootstrap) method. Unlike
+     * AngularJS, this bootstrap is asynchronous.
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * const adapter = new UpgradeAdapter(MyNg2Module);
+     * const module = angular.module('myExample', []);
+     * module.directive('ng2', adapter.downgradeNg2Component(Ng2));
+     *
+     * module.directive('ng1', function() {
+     *   return {
+     *      scope: { title: '=' },
+     *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'
+     *   };
+     * });
+     *
+     *
+     * @Component({
+     *   selector: 'ng2',
+     *   inputs: ['name'],
+     *   template: 'ng2[<ng1 [title]="name">transclude</ng1>](<ng-content></ng-content>)'
+     * })
+     * class Ng2 {
+     * }
+     *
+     * @NgModule({
+     *   declarations: [Ng2, adapter.upgradeNg1Component('ng1')],
+     *   imports: [BrowserModule]
+     * })
+     * class MyNg2Module {}
+     *
+     * document.body.innerHTML = '<ng2 name="World">project</ng2>';
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
+     *   expect(document.body.textContent).toEqual(
+     *       "ng2[ng1[Hello World!](transclude)](project)");
+     * });
+     * ```
+     */
+    bootstrap(element, modules, config) {
+        this.declareNg1Module(modules);
+        const upgrade = new UpgradeAdapterRef();
+        // Make sure resumeBootstrap() only exists if the current bootstrap is deferred
+        const windowAngular = window /** TODO #???? */['angular'];
+        windowAngular.resumeBootstrap = undefined;
+        this.ngZone.run(() => {
+            bootstrap(element, [this.ng1Module.name], config);
+        });
+        const ng1BootstrapPromise = new Promise((resolve) => {
+            if (windowAngular.resumeBootstrap) {
+                const originalResumeBootstrap = windowAngular.resumeBootstrap;
+                windowAngular.resumeBootstrap = function () {
+                    windowAngular.resumeBootstrap = originalResumeBootstrap;
+                    const r = windowAngular.resumeBootstrap.apply(this, arguments);
+                    resolve();
+                    return r;
+                };
+            }
+            else {
+                resolve();
+            }
+        });
+        Promise.all([this.ng2BootstrapDeferred.promise, ng1BootstrapPromise]).then(([ng1Injector]) => {
+            angularElement(element).data(controllerKey(INJECTOR_KEY), this.moduleRef.injector);
+            this.moduleRef.injector.get(NgZone).run(() => {
+                upgrade._bootstrapDone(this.moduleRef, ng1Injector);
+            });
+        }, onError);
+        return upgrade;
+    }
+    /**
+     * Allows AngularJS service to be accessible from Angular.
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * class Login { ... }
+     * class Server { ... }
+     *
+     * @Injectable()
+     * class Example {
+     *   constructor(@Inject('server') server, login: Login) {
+     *     ...
+     *   }
+     * }
+     *
+     * const module = angular.module('myExample', []);
+     * module.service('server', Server);
+     * module.service('login', Login);
+     *
+     * const adapter = new UpgradeAdapter(MyNg2Module);
+     * adapter.upgradeNg1Provider('server');
+     * adapter.upgradeNg1Provider('login', {asToken: Login});
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {
+     *   const example: Example = ref.ng2Injector.get(Example);
+     * });
+     *
+     * ```
+     */
+    upgradeNg1Provider(name, options) {
+        const token = options && options.asToken || name;
+        this.upgradedProviders.push({
+            provide: token,
+            useFactory: ($injector) => $injector.get(name),
+            deps: [$INJECTOR]
+        });
+    }
+    /**
+     * Allows Angular service to be accessible from AngularJS.
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * class Example {
+     * }
+     *
+     * const adapter = new UpgradeAdapter(MyNg2Module);
+     *
+     * const module = angular.module('myExample', []);
+     * module.factory('example', adapter.downgradeNg2Provider(Example));
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {
+     *   const example: Example = ref.ng1Injector.get('example');
+     * });
+     *
+     * ```
+     */
+    downgradeNg2Provider(token) {
+        return downgradeInjectable(token);
+    }
+    /**
+     * Declare the AngularJS upgrade module for this adapter without bootstrapping the whole
+     * hybrid application.
+     *
+     * This method is automatically called by `bootstrap()` and `registerForNg1Tests()`.
+     *
+     * @param modules The AngularJS modules that this upgrade module should depend upon.
+     * @returns The AngularJS upgrade module that is declared by this method
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * const upgradeAdapter = new UpgradeAdapter(MyNg2Module);
+     * upgradeAdapter.declareNg1Module(['heroApp']);
+     * ```
+     */
+    declareNg1Module(modules = []) {
+        const delayApplyExps = [];
+        let original$applyFn;
+        let rootScopePrototype;
+        const upgradeAdapter = this;
+        const ng1Module = this.ng1Module = angularModule(this.idPrefix, modules);
+        const platformRef = platformBrowserDynamic();
+        this.ngZone = new NgZone({ enableLongStackTrace: Zone.hasOwnProperty('longStackTraceZoneSpec') });
+        this.ng2BootstrapDeferred = new Deferred();
+        ng1Module.constant(UPGRADE_APP_TYPE_KEY, 1 /* Dynamic */)
+            .factory(INJECTOR_KEY, () => this.moduleRef.injector.get(Injector))
+            .factory(LAZY_MODULE_REF, [INJECTOR_KEY, (injector) => ({ injector })])
+            .constant(NG_ZONE_KEY, this.ngZone)
+            .factory(COMPILER_KEY, () => this.moduleRef.injector.get(Compiler))
+            .config([
+            '$provide', '$injector',
+            (provide, ng1Injector) => {
+                provide.decorator($ROOT_SCOPE, [
+                    '$delegate',
+                    function (rootScopeDelegate) {
+                        // Capture the root apply so that we can delay first call to $apply until we
+                        // bootstrap Angular and then we replay and restore the $apply.
+                        rootScopePrototype = rootScopeDelegate.constructor.prototype;
+                        if (rootScopePrototype.hasOwnProperty('$apply')) {
+                            original$applyFn = rootScopePrototype.$apply;
+                            rootScopePrototype.$apply = (exp) => delayApplyExps.push(exp);
+                        }
+                        else {
+                            throw new Error('Failed to find \'$apply\' on \'$rootScope\'!');
+                        }
+                        return rootScopeDelegate;
+                    }
+                ]);
+                if (ng1Injector.has($$TESTABILITY)) {
+                    provide.decorator($$TESTABILITY, [
+                        '$delegate',
+                        function (testabilityDelegate) {
+                            const originalWhenStable = testabilityDelegate.whenStable;
+                            // Cannot use arrow function below because we need the context
+                            const newWhenStable = function (callback) {
+                                originalWhenStable.call(this, function () {
+                                    const ng2Testability = upgradeAdapter.moduleRef.injector.get(Testability);
+                                    if (ng2Testability.isStable()) {
+                                        callback.apply(this, arguments);
+                                    }
+                                    else {
+                                        ng2Testability.whenStable(newWhenStable.bind(this, callback));
+                                    }
+                                });
+                            };
+                            testabilityDelegate.whenStable = newWhenStable;
+                            return testabilityDelegate;
+                        }
+                    ]);
+                }
+            }
+        ]);
+        ng1Module.run([
+            '$injector', '$rootScope',
+            (ng1Injector, rootScope) => {
+                UpgradeNg1ComponentAdapterBuilder.resolve(this.ng1ComponentsToBeUpgraded, ng1Injector)
+                    .then(() => {
+                    // Note: There is a bug in TS 2.4 that prevents us from
+                    // inlining this into @NgModule
+                    // TODO(tbosch): find or file a bug against TypeScript for this.
+                    const ngModule = {
+                        providers: [
+                            { provide: $INJECTOR, useFactory: () => ng1Injector },
+                            { provide: $COMPILE, useFactory: () => ng1Injector.get($COMPILE) },
+                            this.upgradedProviders
+                        ],
+                        imports: [resolveForwardRef(this.ng2AppModule)],
+                        entryComponents: this.downgradedComponents
+                    };
+                    // At this point we have ng1 injector and we have prepared
+                    // ng1 components to be upgraded, we now can bootstrap ng2.
+                    let DynamicNgUpgradeModule = class DynamicNgUpgradeModule {
+                        constructor() { }
+                        ngDoBootstrap() { }
+                    };
+                    DynamicNgUpgradeModule = __decorate([
+                        NgModule({ jit: true, ...ngModule }),
+                        __metadata("design:paramtypes", [])
+                    ], DynamicNgUpgradeModule);
+                    platformRef
+                        .bootstrapModule(DynamicNgUpgradeModule, [this.compilerOptions, { ngZone: this.ngZone }])
+                        .then((ref) => {
+                        this.moduleRef = ref;
+                        this.ngZone.run(() => {
+                            if (rootScopePrototype) {
+                                rootScopePrototype.$apply = original$applyFn; // restore original $apply
+                                while (delayApplyExps.length) {
+                                    rootScope.$apply(delayApplyExps.shift());
+                                }
+                                rootScopePrototype = null;
+                            }
+                        });
+                    })
+                        .then(() => this.ng2BootstrapDeferred.resolve(ng1Injector), onError)
+                        .then(() => {
+                        let subscription = this.ngZone.onMicrotaskEmpty.subscribe({
+                            next: () => {
+                                if (rootScope.$$phase) {
+                                    if (isDevMode()) {
+                                        console.warn('A digest was triggered while one was already in progress. This may mean that something is triggering digests outside the Angular zone.');
+                                    }
+                                    return rootScope.$evalAsync(() => { });
+                                }
+                                return rootScope.$digest();
+                            }
+                        });
+                        rootScope.$on('$destroy', () => {
+                            subscription.unsubscribe();
+                        });
+                        // 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.
+                        platformRef.onDestroy(() => destroyApp(ng1Injector));
+                    });
+                })
+                    .catch((e) => this.ng2BootstrapDeferred.reject(e));
+            }
+        ]);
+        return ng1Module;
+    }
+}
+/**
+ * Synchronous promise-like object to wrap parent injectors,
+ * to preserve the synchronous nature of AngularJS's $compile.
+ */
+class ParentInjectorPromise {
+    constructor(element) {
+        this.element = element;
+        this.callbacks = [];
+        // store the promise on the element
+        element.data(controllerKey(INJECTOR_KEY), this);
+    }
+    then(callback) {
+        if (this.injector) {
+            callback(this.injector);
+        }
+        else {
+            this.callbacks.push(callback);
+        }
+    }
+    resolve(injector) {
+        this.injector = injector;
+        // reset the element data to point to the real injector
+        this.element.data(controllerKey(INJECTOR_KEY), injector);
+        // clean out the element to prevent memory leaks
+        this.element = null;
+        // run all the queued callbacks
+        this.callbacks.forEach((callback) => callback(injector));
+        this.callbacks.length = 0;
+    }
+}
+/**
+ * Use `UpgradeAdapterRef` to control a hybrid AngularJS / Angular application.
+ *
+ * @deprecated Deprecated since v5. Use `upgrade/static` instead, which also supports
+ * [Ahead-of-Time compilation](guide/aot-compiler).
+ * @publicApi
+ */
+export class UpgradeAdapterRef {
+    constructor() {
+        /* @internal */
+        this._readyFn = null;
+        this.ng1RootScope = null;
+        this.ng1Injector = null;
+        this.ng2ModuleRef = null;
+        this.ng2Injector = null;
+    }
+    /* @internal */
+    _bootstrapDone(ngModuleRef, ng1Injector) {
+        this.ng2ModuleRef = ngModuleRef;
+        this.ng2Injector = ngModuleRef.injector;
+        this.ng1Injector = ng1Injector;
+        this.ng1RootScope = ng1Injector.get($ROOT_SCOPE);
+        this._readyFn && this._readyFn(this);
+    }
+    /**
+     * Register a callback function which is notified upon successful hybrid AngularJS / Angular
+     * application has been bootstrapped.
+     *
+     * The `ready` callback function is invoked inside the Angular zone, therefore it does not
+     * require a call to `$apply()`.
+     */
+    ready(fn) {
+        this._readyFn = fn;
+    }
+    /**
+     * Dispose of running hybrid AngularJS / Angular application.
+     */
+    dispose() {
+        this.ng1Injector.get($ROOT_SCOPE).$destroy();
+        this.ng2ModuleRef.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgrade_adapter.js","sourceRoot":"","sources":["../../../../../../../../packages/upgrade/src/dynamic/src/upgrade_adapter.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 {Compiler, CompilerOptions, Injector, isDevMode, NgModule, NgModuleRef, NgZone, resolveForwardRef, StaticProvider, Testability, Type} from '@angular/core';\nimport {platformBrowserDynamic} from '@angular/platform-browser-dynamic';\n\nimport {bootstrap, element as angularElement, IAngularBootstrapConfig, IAugmentedJQuery, IInjectorService, IModule, IProvideService, IRootScopeService, ITestabilityService, module_ as angularModule} from '../../common/src/angular1';\nimport {$$TESTABILITY, $COMPILE, $INJECTOR, $ROOT_SCOPE, COMPILER_KEY, INJECTOR_KEY, LAZY_MODULE_REF, NG_ZONE_KEY, UPGRADE_APP_TYPE_KEY} from '../../common/src/constants';\nimport {downgradeComponent} from '../../common/src/downgrade_component';\nimport {downgradeInjectable} from '../../common/src/downgrade_injectable';\nimport {controllerKey, Deferred, destroyApp, LazyModuleRef, onError, UpgradeAppType} from '../../common/src/util';\n\nimport {UpgradeNg1ComponentAdapterBuilder} from './upgrade_ng1_adapter';\n\nlet upgradeCount: number = 0;\n\n/**\n * Use `UpgradeAdapter` to allow AngularJS and Angular to coexist in a single application.\n *\n * The `UpgradeAdapter` allows:\n * 1. creation of Angular component from AngularJS component directive\n *    (See [UpgradeAdapter#upgradeNg1Component()])\n * 2. creation of AngularJS directive from Angular component.\n *    (See [UpgradeAdapter#downgradeNg2Component()])\n * 3. Bootstrapping of a hybrid Angular application which contains both of the frameworks\n *    coexisting in a single application.\n *\n * @usageNotes\n * ### Mental Model\n *\n * When reasoning about how a hybrid application works it is useful to have a mental model which\n * describes what is happening and explains what is happening at the lowest level.\n *\n * 1. There are two independent frameworks running in a single application, each framework treats\n *    the other as a black box.\n * 2. Each DOM element on the page is owned exactly by one framework. Whichever framework\n *    instantiated the element is the owner. Each framework only updates/interacts with its own\n *    DOM elements and ignores others.\n * 3. AngularJS directives always execute inside AngularJS framework codebase regardless of\n *    where they are instantiated.\n * 4. Angular components always execute inside Angular framework codebase regardless of\n *    where they are instantiated.\n * 5. An AngularJS component can be upgraded to an Angular component. This creates an\n *    Angular directive, which bootstraps the AngularJS component directive in that location.\n * 6. An Angular component can be downgraded to an AngularJS component directive. This creates\n *    an AngularJS directive, which bootstraps the Angular component in that location.\n * 7. Whenever an adapter component is instantiated the host element is owned by the framework\n *    doing the instantiation. The other framework then instantiates and owns the view for that\n *    component. This implies that component bindings will always follow the semantics of the\n *    instantiation framework. The syntax is always that of Angular syntax.\n * 8. AngularJS is always bootstrapped first and owns the bottom most view.\n * 9. The new application is running in Angular zone, and therefore it no longer needs calls to\n *    `$apply()`.\n *\n * ### Example\n *\n * ```\n * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module), myCompilerOptions);\n * const module = angular.module('myExample', []);\n * module.directive('ng2Comp', adapter.downgradeNg2Component(Ng2Component));\n *\n * module.directive('ng1Hello', function() {\n *   return {\n *      scope: { title: '=' },\n *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'\n *   };\n * });\n *\n *\n * @Component({\n *   selector: 'ng2-comp',\n *   inputs: ['name'],\n *   template: 'ng2[<ng1-hello [title]=\"name\">transclude</ng1-hello>](<ng-content></ng-content>)',\n *   directives:\n * })\n * class Ng2Component {\n * }\n *\n * @NgModule({\n *   declarations: [Ng2Component, adapter.upgradeNg1Component('ng1Hello')],\n *   imports: [BrowserModule]\n * })\n * class MyNg2Module {}\n *\n *\n * document.body.innerHTML = '<ng2-comp name=\"World\">project</ng2-comp>';\n *\n * adapter.bootstrap(document.body, ['myExample']).ready(function() {\n *   expect(document.body.textContent).toEqual(\n *       \"ng2[ng1[Hello World!](transclude)](project)\");\n * });\n *\n * ```\n *\n * @deprecated Deprecated since v5. Use `upgrade/static` instead, which also supports\n * [Ahead-of-Time compilation](guide/aot-compiler).\n * @publicApi\n */\nexport class UpgradeAdapter {\n  private idPrefix: string = `NG2_UPGRADE_${upgradeCount++}_`;\n  private downgradedComponents: Type<any>[] = [];\n  /**\n   * An internal map of ng1 components which need to up upgraded to ng2.\n   *\n   * We can't upgrade until injector is instantiated and we can retrieve the component metadata.\n   * For this reason we keep a list of components to upgrade until ng1 injector is bootstrapped.\n   *\n   * @internal\n   */\n  private ng1ComponentsToBeUpgraded: {[name: string]: UpgradeNg1ComponentAdapterBuilder} = {};\n  private upgradedProviders: StaticProvider[] = [];\n  // TODO(issue/24571): remove '!'.\n  private ngZone!: NgZone;\n  // TODO(issue/24571): remove '!'.\n  private ng1Module!: IModule;\n  private moduleRef: NgModuleRef<any>|null = null;\n  // TODO(issue/24571): remove '!'.\n  private ng2BootstrapDeferred!: Deferred<IInjectorService>;\n\n  constructor(private ng2AppModule: Type<any>, private compilerOptions?: CompilerOptions) {\n    if (!ng2AppModule) {\n      throw new Error(\n          'UpgradeAdapter cannot be instantiated without an NgModule of the Angular app.');\n    }\n  }\n\n  /**\n   * Allows Angular Component to be used from AngularJS.\n   *\n   * Use `downgradeNg2Component` to create an AngularJS Directive Definition Factory from\n   * Angular Component. The adapter will bootstrap Angular component from within the\n   * AngularJS template.\n   *\n   * @usageNotes\n   * ### Mental Model\n   *\n   * 1. The component is instantiated by being listed in AngularJS template. This means that the\n   *    host element is controlled by AngularJS, but the component's view will be controlled by\n   *    Angular.\n   * 2. Even thought the component is instantiated in AngularJS, it will be using Angular\n   *    syntax. This has to be done, this way because we must follow Angular components do not\n   *    declare how the attributes should be interpreted.\n   * 3. `ng-model` is controlled by AngularJS and communicates with the downgraded Angular component\n   *    by way of the `ControlValueAccessor` interface from @angular/forms. Only components that\n   *    implement this interface are eligible.\n   *\n   * ### Supported Features\n   *\n   * - Bindings:\n   *   - Attribute: `<comp name=\"World\">`\n   *   - Interpolation:  `<comp greeting=\"Hello {{name}}!\">`\n   *   - Expression:  `<comp [name]=\"username\">`\n   *   - Event:  `<comp (close)=\"doSomething()\">`\n   *   - ng-model: `<comp ng-model=\"name\">`\n   * - Content projection: yes\n   *\n   * ### Example\n   *\n   * ```\n   * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module));\n   * const module = angular.module('myExample', []);\n   * module.directive('greet', adapter.downgradeNg2Component(Greeter));\n   *\n   * @Component({\n   *   selector: 'greet',\n   *   template: '{{salutation}} {{name}}! - <ng-content></ng-content>'\n   * })\n   * class Greeter {\n   *   @Input() salutation: string;\n   *   @Input() name: string;\n   * }\n   *\n   * @NgModule({\n   *   declarations: [Greeter],\n   *   imports: [BrowserModule]\n   * })\n   * class MyNg2Module {}\n   *\n   * document.body.innerHTML =\n   *   'ng1 template: <greet salutation=\"Hello\" [name]=\"world\">text</greet>';\n   *\n   * adapter.bootstrap(document.body, ['myExample']).ready(function() {\n   *   expect(document.body.textContent).toEqual(\"ng1 template: Hello world! - text\");\n   * });\n   * ```\n   */\n  downgradeNg2Component(component: Type<any>): Function {\n    this.downgradedComponents.push(component);\n\n    return downgradeComponent({component});\n  }\n\n  /**\n   * Allows AngularJS Component to be used from Angular.\n   *\n   * Use `upgradeNg1Component` to create an Angular component from AngularJS Component\n   * directive. The adapter will bootstrap AngularJS component from within the Angular\n   * template.\n   *\n   * @usageNotes\n   * ### Mental Model\n   *\n   * 1. The component is instantiated by being listed in Angular template. This means that the\n   *    host element is controlled by Angular, but the component's view will be controlled by\n   *    AngularJS.\n   *\n   * ### Supported Features\n   *\n   * - Bindings:\n   *   - Attribute: `<comp name=\"World\">`\n   *   - Interpolation:  `<comp greeting=\"Hello {{name}}!\">`\n   *   - Expression:  `<comp [name]=\"username\">`\n   *   - Event:  `<comp (close)=\"doSomething()\">`\n   * - Transclusion: yes\n   * - Only some of the features of\n   *   [Directive Definition Object](https://docs.angularjs.org/api/ng/service/$compile) are\n   *   supported:\n   *   - `compile`: not supported because the host element is owned by Angular, which does\n   *     not allow modifying DOM structure during compilation.\n   *   - `controller`: supported. (NOTE: injection of `$attrs` and `$transclude` is not supported.)\n   *   - `controllerAs`: supported.\n   *   - `bindToController`: supported.\n   *   - `link`: supported. (NOTE: only pre-link function is supported.)\n   *   - `name`: supported.\n   *   - `priority`: ignored.\n   *   - `replace`: not supported.\n   *   - `require`: supported.\n   *   - `restrict`: must be set to 'E'.\n   *   - `scope`: supported.\n   *   - `template`: supported.\n   *   - `templateUrl`: supported.\n   *   - `terminal`: ignored.\n   *   - `transclude`: supported.\n   *\n   *\n   * ### Example\n   *\n   * ```\n   * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module));\n   * const module = angular.module('myExample', []);\n   *\n   * module.directive('greet', function() {\n   *   return {\n   *     scope: {salutation: '=', name: '=' },\n   *     template: '{{salutation}} {{name}}! - <span ng-transclude></span>'\n   *   };\n   * });\n   *\n   * module.directive('ng2', adapter.downgradeNg2Component(Ng2Component));\n   *\n   * @Component({\n   *   selector: 'ng2',\n   *   template: 'ng2 template: <greet salutation=\"Hello\" [name]=\"world\">text</greet>'\n   * })\n   * class Ng2Component {\n   * }\n   *\n   * @NgModule({\n   *   declarations: [Ng2Component, adapter.upgradeNg1Component('greet')],\n   *   imports: [BrowserModule]\n   * })\n   * class MyNg2Module {}\n   *\n   * document.body.innerHTML = '<ng2></ng2>';\n   *\n   * adapter.bootstrap(document.body, ['myExample']).ready(function() {\n   *   expect(document.body.textContent).toEqual(\"ng2 template: Hello world! - text\");\n   * });\n   * ```\n   */\n  upgradeNg1Component(name: string): Type<any> {\n    if ((<any>this.ng1ComponentsToBeUpgraded).hasOwnProperty(name)) {\n      return this.ng1ComponentsToBeUpgraded[name].type;\n    } else {\n      return (this.ng1ComponentsToBeUpgraded[name] = new UpgradeNg1ComponentAdapterBuilder(name))\n          .type;\n    }\n  }\n\n  /**\n   * Registers the adapter's AngularJS upgrade module for unit testing in AngularJS.\n   * Use this instead of `angular.mock.module()` to load the upgrade module into\n   * the AngularJS testing injector.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * ```\n   * const upgradeAdapter = new UpgradeAdapter(MyNg2Module);\n   *\n   * // configure the adapter with upgrade/downgrade components and services\n   * upgradeAdapter.downgradeNg2Component(MyComponent);\n   *\n   * let upgradeAdapterRef: UpgradeAdapterRef;\n   * let $compile, $rootScope;\n   *\n   * // We must register the adapter before any calls to `inject()`\n   * beforeEach(() => {\n   *   upgradeAdapterRef = upgradeAdapter.registerForNg1Tests(['heroApp']);\n   * });\n   *\n   * beforeEach(inject((_$compile_, _$rootScope_) => {\n   *   $compile = _$compile_;\n   *   $rootScope = _$rootScope_;\n   * }));\n   *\n   * it(\"says hello\", (done) => {\n   *   upgradeAdapterRef.ready(() => {\n   *     const element = $compile(\"<my-component></my-component>\")($rootScope);\n   *     $rootScope.$apply();\n   *     expect(element.html()).toContain(\"Hello World\");\n   *     done();\n   *   })\n   * });\n   *\n   * ```\n   *\n   * @param modules any AngularJS modules that the upgrade module should depend upon\n   * @returns an `UpgradeAdapterRef`, which lets you register a `ready()` callback to\n   * run assertions once the Angular components are ready to test through AngularJS.\n   */\n  registerForNg1Tests(modules?: string[]): UpgradeAdapterRef {\n    const windowNgMock = (window as any)['angular'].mock;\n    if (!windowNgMock || !windowNgMock.module) {\n      throw new Error('Failed to find \\'angular.mock.module\\'.');\n    }\n    this.declareNg1Module(modules);\n    windowNgMock.module(this.ng1Module.name);\n    const upgrade = new UpgradeAdapterRef();\n    this.ng2BootstrapDeferred.promise.then((ng1Injector) => {\n      (<any>upgrade)._bootstrapDone(this.moduleRef, ng1Injector);\n    }, onError);\n    return upgrade;\n  }\n\n  /**\n   * Bootstrap a hybrid AngularJS / Angular application.\n   *\n   * This `bootstrap` method is a direct replacement (takes same arguments) for AngularJS\n   * [`bootstrap`](https://docs.angularjs.org/api/ng/function/angular.bootstrap) method. Unlike\n   * AngularJS, this bootstrap is asynchronous.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * ```\n   * const adapter = new UpgradeAdapter(MyNg2Module);\n   * const module = angular.module('myExample', []);\n   * module.directive('ng2', adapter.downgradeNg2Component(Ng2));\n   *\n   * module.directive('ng1', function() {\n   *   return {\n   *      scope: { title: '=' },\n   *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'\n   *   };\n   * });\n   *\n   *\n   * @Component({\n   *   selector: 'ng2',\n   *   inputs: ['name'],\n   *   template: 'ng2[<ng1 [title]=\"name\">transclude</ng1>](<ng-content></ng-content>)'\n   * })\n   * class Ng2 {\n   * }\n   *\n   * @NgModule({\n   *   declarations: [Ng2, adapter.upgradeNg1Component('ng1')],\n   *   imports: [BrowserModule]\n   * })\n   * class MyNg2Module {}\n   *\n   * document.body.innerHTML = '<ng2 name=\"World\">project</ng2>';\n   *\n   * adapter.bootstrap(document.body, ['myExample']).ready(function() {\n   *   expect(document.body.textContent).toEqual(\n   *       \"ng2[ng1[Hello World!](transclude)](project)\");\n   * });\n   * ```\n   */\n  bootstrap(element: Element, modules?: any[], config?: IAngularBootstrapConfig):\n      UpgradeAdapterRef {\n    this.declareNg1Module(modules);\n\n    const upgrade = new UpgradeAdapterRef();\n\n    // Make sure resumeBootstrap() only exists if the current bootstrap is deferred\n    const windowAngular = (window as any /** TODO #???? */)['angular'];\n    windowAngular.resumeBootstrap = undefined;\n\n    this.ngZone.run(() => {\n      bootstrap(element, [this.ng1Module.name], config!);\n    });\n    const ng1BootstrapPromise = new Promise<void>((resolve) => {\n      if (windowAngular.resumeBootstrap) {\n        const originalResumeBootstrap: () => void = windowAngular.resumeBootstrap;\n        windowAngular.resumeBootstrap = function() {\n          windowAngular.resumeBootstrap = originalResumeBootstrap;\n          const r = windowAngular.resumeBootstrap.apply(this, arguments);\n          resolve();\n          return r;\n        };\n      } else {\n        resolve();\n      }\n    });\n\n    Promise.all([this.ng2BootstrapDeferred.promise, ng1BootstrapPromise]).then(([ng1Injector]) => {\n      angularElement(element).data!(controllerKey(INJECTOR_KEY), this.moduleRef!.injector);\n      this.moduleRef!.injector.get<NgZone>(NgZone).run(() => {\n        (<any>upgrade)._bootstrapDone(this.moduleRef, ng1Injector);\n      });\n    }, onError);\n    return upgrade;\n  }\n\n  /**\n   * Allows AngularJS service to be accessible from Angular.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * ```\n   * class Login { ... }\n   * class Server { ... }\n   *\n   * @Injectable()\n   * class Example {\n   *   constructor(@Inject('server') server, login: Login) {\n   *     ...\n   *   }\n   * }\n   *\n   * const module = angular.module('myExample', []);\n   * module.service('server', Server);\n   * module.service('login', Login);\n   *\n   * const adapter = new UpgradeAdapter(MyNg2Module);\n   * adapter.upgradeNg1Provider('server');\n   * adapter.upgradeNg1Provider('login', {asToken: Login});\n   *\n   * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {\n   *   const example: Example = ref.ng2Injector.get(Example);\n   * });\n   *\n   * ```\n   */\n  upgradeNg1Provider(name: string, options?: {asToken: any}) {\n    const token = options && options.asToken || name;\n    this.upgradedProviders.push({\n      provide: token,\n      useFactory: ($injector: IInjectorService) => $injector.get(name),\n      deps: [$INJECTOR]\n    });\n  }\n\n  /**\n   * Allows Angular service to be accessible from AngularJS.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * ```\n   * class Example {\n   * }\n   *\n   * const adapter = new UpgradeAdapter(MyNg2Module);\n   *\n   * const module = angular.module('myExample', []);\n   * module.factory('example', adapter.downgradeNg2Provider(Example));\n   *\n   * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {\n   *   const example: Example = ref.ng1Injector.get('example');\n   * });\n   *\n   * ```\n   */\n  downgradeNg2Provider(token: any): Function {\n    return downgradeInjectable(token);\n  }\n\n  /**\n   * Declare the AngularJS upgrade module for this adapter without bootstrapping the whole\n   * hybrid application.\n   *\n   * This method is automatically called by `bootstrap()` and `registerForNg1Tests()`.\n   *\n   * @param modules The AngularJS modules that this upgrade module should depend upon.\n   * @returns The AngularJS upgrade module that is declared by this method\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * ```\n   * const upgradeAdapter = new UpgradeAdapter(MyNg2Module);\n   * upgradeAdapter.declareNg1Module(['heroApp']);\n   * ```\n   */\n  private declareNg1Module(modules: string[] = []): IModule {\n    const delayApplyExps: Function[] = [];\n    let original$applyFn: Function;\n    let rootScopePrototype: any;\n    const upgradeAdapter = this;\n    const ng1Module = this.ng1Module = angularModule(this.idPrefix, modules);\n    const platformRef = platformBrowserDynamic();\n\n    this.ngZone = new NgZone({enableLongStackTrace: Zone.hasOwnProperty('longStackTraceZoneSpec')});\n    this.ng2BootstrapDeferred = new Deferred();\n    ng1Module.constant(UPGRADE_APP_TYPE_KEY, UpgradeAppType.Dynamic)\n        .factory(INJECTOR_KEY, () => this.moduleRef!.injector.get(Injector))\n        .factory(\n            LAZY_MODULE_REF, [INJECTOR_KEY, (injector: Injector) => ({injector} as LazyModuleRef)])\n        .constant(NG_ZONE_KEY, this.ngZone)\n        .factory(COMPILER_KEY, () => this.moduleRef!.injector.get(Compiler))\n        .config([\n          '$provide', '$injector',\n          (provide: IProvideService, ng1Injector: IInjectorService) => {\n            provide.decorator($ROOT_SCOPE, [\n              '$delegate',\n              function(rootScopeDelegate: IRootScopeService) {\n                // Capture the root apply so that we can delay first call to $apply until we\n                // bootstrap Angular and then we replay and restore the $apply.\n                rootScopePrototype = rootScopeDelegate.constructor.prototype;\n                if (rootScopePrototype.hasOwnProperty('$apply')) {\n                  original$applyFn = rootScopePrototype.$apply;\n                  rootScopePrototype.$apply = (exp: any) => delayApplyExps.push(exp);\n                } else {\n                  throw new Error('Failed to find \\'$apply\\' on \\'$rootScope\\'!');\n                }\n                return rootScopeDelegate;\n              }\n            ]);\n            if (ng1Injector.has($$TESTABILITY)) {\n              provide.decorator($$TESTABILITY, [\n                '$delegate',\n                function(testabilityDelegate: ITestabilityService) {\n                  const originalWhenStable: Function = testabilityDelegate.whenStable;\n                  // Cannot use arrow function below because we need the context\n                  const newWhenStable = function(this: unknown, callback: Function) {\n                    originalWhenStable.call(this, function(this: unknown) {\n                      const ng2Testability: Testability =\n                          upgradeAdapter.moduleRef!.injector.get(Testability);\n                      if (ng2Testability.isStable()) {\n                        callback.apply(this, arguments);\n                      } else {\n                        ng2Testability.whenStable(newWhenStable.bind(this, callback));\n                      }\n                    });\n                  };\n\n                  testabilityDelegate.whenStable = newWhenStable;\n                  return testabilityDelegate;\n                }\n              ]);\n            }\n          }\n        ]);\n\n    ng1Module.run([\n      '$injector', '$rootScope',\n      (ng1Injector: IInjectorService, rootScope: IRootScopeService) => {\n        UpgradeNg1ComponentAdapterBuilder.resolve(this.ng1ComponentsToBeUpgraded, ng1Injector)\n            .then(() => {\n              // Note: There is a bug in TS 2.4 that prevents us from\n              // inlining this into @NgModule\n              // TODO(tbosch): find or file a bug against TypeScript for this.\n              const ngModule = {\n                providers: [\n                  {provide: $INJECTOR, useFactory: () => ng1Injector},\n                  {provide: $COMPILE, useFactory: () => ng1Injector.get($COMPILE)},\n                  this.upgradedProviders\n                ],\n                imports: [resolveForwardRef(this.ng2AppModule)],\n                entryComponents: this.downgradedComponents\n              };\n              // At this point we have ng1 injector and we have prepared\n              // ng1 components to be upgraded, we now can bootstrap ng2.\n              @NgModule({jit: true, ...ngModule})\n              class DynamicNgUpgradeModule {\n                constructor() {}\n                ngDoBootstrap() {}\n              }\n              platformRef\n                  .bootstrapModule(\n                      DynamicNgUpgradeModule, [this.compilerOptions!, {ngZone: this.ngZone}])\n                  .then((ref: NgModuleRef<any>) => {\n                    this.moduleRef = ref;\n                    this.ngZone.run(() => {\n                      if (rootScopePrototype) {\n                        rootScopePrototype.$apply = original$applyFn;  // restore original $apply\n                        while (delayApplyExps.length) {\n                          rootScope.$apply(delayApplyExps.shift());\n                        }\n                        rootScopePrototype = null;\n                      }\n                    });\n                  })\n                  .then(() => this.ng2BootstrapDeferred.resolve(ng1Injector), onError)\n                  .then(() => {\n                    let subscription = this.ngZone.onMicrotaskEmpty.subscribe({\n                      next: () => {\n                        if (rootScope.$$phase) {\n                          if (isDevMode()) {\n                            console.warn(\n                                'A digest was triggered while one was already in progress. This may mean that something is triggering digests outside the Angular zone.');\n                          }\n\n                          return rootScope.$evalAsync(() => {});\n                        }\n\n                        return rootScope.$digest();\n                      }\n                    });\n                    rootScope.$on('$destroy', () => {\n                      subscription.unsubscribe();\n                    });\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                    platformRef.onDestroy(() => destroyApp(ng1Injector));\n                  });\n            })\n            .catch((e) => this.ng2BootstrapDeferred.reject(e));\n      }\n    ]);\n\n    return ng1Module;\n  }\n}\n\n/**\n * Synchronous promise-like object to wrap parent injectors,\n * to preserve the synchronous nature of AngularJS's $compile.\n */\nclass ParentInjectorPromise {\n  // TODO(issue/24571): remove '!'.\n  private injector!: Injector;\n  private callbacks: ((injector: Injector) => any)[] = [];\n\n  constructor(private element: IAugmentedJQuery) {\n    // store the promise on the element\n    element.data!(controllerKey(INJECTOR_KEY), this);\n  }\n\n  then(callback: (injector: Injector) => any) {\n    if (this.injector) {\n      callback(this.injector);\n    } else {\n      this.callbacks.push(callback);\n    }\n  }\n\n  resolve(injector: Injector) {\n    this.injector = injector;\n\n    // reset the element data to point to the real injector\n    this.element.data!(controllerKey(INJECTOR_KEY), injector);\n\n    // clean out the element to prevent memory leaks\n    this.element = null!;\n\n    // run all the queued callbacks\n    this.callbacks.forEach((callback) => callback(injector));\n    this.callbacks.length = 0;\n  }\n}\n\n\n/**\n * Use `UpgradeAdapterRef` to control a hybrid AngularJS / Angular application.\n *\n * @deprecated Deprecated since v5. Use `upgrade/static` instead, which also supports\n * [Ahead-of-Time compilation](guide/aot-compiler).\n * @publicApi\n */\nexport class UpgradeAdapterRef {\n  /* @internal */\n  private _readyFn: ((upgradeAdapterRef: UpgradeAdapterRef) => void)|null = null;\n\n  public ng1RootScope: IRootScopeService = null!;\n  public ng1Injector: IInjectorService = null!;\n  public ng2ModuleRef: NgModuleRef<any> = null!;\n  public ng2Injector: Injector = null!;\n\n  /* @internal */\n  private _bootstrapDone(ngModuleRef: NgModuleRef<any>, ng1Injector: IInjectorService) {\n    this.ng2ModuleRef = ngModuleRef;\n    this.ng2Injector = ngModuleRef.injector;\n    this.ng1Injector = ng1Injector;\n    this.ng1RootScope = ng1Injector.get($ROOT_SCOPE);\n    this._readyFn && this._readyFn(this);\n  }\n\n  /**\n   * Register a callback function which is notified upon successful hybrid AngularJS / Angular\n   * application has been bootstrapped.\n   *\n   * The `ready` callback function is invoked inside the Angular zone, therefore it does not\n   * require a call to `$apply()`.\n   */\n  public ready(fn: (upgradeAdapterRef: UpgradeAdapterRef) => void) {\n    this._readyFn = fn;\n  }\n\n  /**\n   * Dispose of running hybrid AngularJS / Angular application.\n   */\n  public dispose() {\n    this.ng1Injector!.get($ROOT_SCOPE).$destroy();\n    this.ng2ModuleRef!.destroy();\n  }\n}\n"]}