@angular/upgrade 13.0.0-next.9 → 13.0.0-rc.3

package/esm2020/src/dynamic/src/upgrade_ng1_adapter.mjs

@@ -0,0 +1,223 @@
+import { __decorate, __metadata, __param } from "tslib";
+/**
+ * @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 { Directive, ElementRef, EventEmitter, Inject, Injector } from '@angular/core';
+import { $SCOPE } from '../../common/src/constants';
+import { UpgradeHelper } from '../../common/src/upgrade_helper';
+import { isFunction, strictEquals } from '../../common/src/util';
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/src/upgrade_helper";
+const CAMEL_CASE = /([A-Z])/g;
+const INITIAL_VALUE = {
+    __UNINITIALIZED__: true
+};
+const NOT_SUPPORTED = 'NOT_SUPPORTED';
+export class UpgradeNg1ComponentAdapterBuilder {
+    constructor(name) {
+        this.name = name;
+        this.inputs = [];
+        this.inputsRename = [];
+        this.outputs = [];
+        this.outputsRename = [];
+        this.propertyOutputs = [];
+        this.checkProperties = [];
+        this.propertyMap = {};
+        this.directive = null;
+        const selector = name.replace(CAMEL_CASE, (all, next) => '-' + next.toLowerCase());
+        const self = this;
+        // Note: There is a bug in TS 2.4 that prevents us from
+        // inlining this into @Directive
+        // TODO(tbosch): find or file a bug against TypeScript for this.
+        const directive = { selector: selector, inputs: this.inputsRename, outputs: this.outputsRename };
+        let MyClass = class MyClass extends UpgradeNg1ComponentAdapter {
+            constructor(scope, injector, elementRef) {
+                super(new UpgradeHelper(injector, name, elementRef, self.directive || undefined), scope, self.template, self.inputs, self.outputs, self.propertyOutputs, self.checkProperties, self.propertyMap);
+            }
+        };
+        MyClass = __decorate([
+            Directive({ jit: true, ...directive }),
+            __param(0, Inject($SCOPE)),
+            __metadata("design:paramtypes", [Object, Injector, ElementRef])
+        ], MyClass);
+        this.type = MyClass;
+    }
+    extractBindings() {
+        const btcIsObject = typeof this.directive.bindToController === 'object';
+        if (btcIsObject && Object.keys(this.directive.scope).length) {
+            throw new Error(`Binding definitions on scope and controller at the same time are not supported.`);
+        }
+        const context = (btcIsObject) ? this.directive.bindToController : this.directive.scope;
+        if (typeof context == 'object') {
+            Object.keys(context).forEach(propName => {
+                const definition = context[propName];
+                const bindingType = definition.charAt(0);
+                const bindingOptions = definition.charAt(1);
+                const attrName = definition.substring(bindingOptions === '?' ? 2 : 1) || propName;
+                // QUESTION: What about `=*`? Ignore? Throw? Support?
+                const inputName = `input_${attrName}`;
+                const inputNameRename = `${inputName}: ${attrName}`;
+                const outputName = `output_${attrName}`;
+                const outputNameRename = `${outputName}: ${attrName}`;
+                const outputNameRenameChange = `${outputNameRename}Change`;
+                switch (bindingType) {
+                    case '@':
+                    case '<':
+                        this.inputs.push(inputName);
+                        this.inputsRename.push(inputNameRename);
+                        this.propertyMap[inputName] = propName;
+                        break;
+                    case '=':
+                        this.inputs.push(inputName);
+                        this.inputsRename.push(inputNameRename);
+                        this.propertyMap[inputName] = propName;
+                        this.outputs.push(outputName);
+                        this.outputsRename.push(outputNameRenameChange);
+                        this.propertyMap[outputName] = propName;
+                        this.checkProperties.push(propName);
+                        this.propertyOutputs.push(outputName);
+                        break;
+                    case '&':
+                        this.outputs.push(outputName);
+                        this.outputsRename.push(outputNameRename);
+                        this.propertyMap[outputName] = propName;
+                        break;
+                    default:
+                        let json = JSON.stringify(context);
+                        throw new Error(`Unexpected mapping '${bindingType}' in '${json}' in '${this.name}' directive.`);
+                }
+            });
+        }
+    }
+    /**
+     * Upgrade ng1 components into Angular.
+     */
+    static resolve(exportedComponents, $injector) {
+        const promises = Object.keys(exportedComponents).map(name => {
+            const exportedComponent = exportedComponents[name];
+            exportedComponent.directive = UpgradeHelper.getDirective($injector, name);
+            exportedComponent.extractBindings();
+            return Promise
+                .resolve(UpgradeHelper.getTemplate($injector, exportedComponent.directive, true))
+                .then(template => exportedComponent.template = template);
+        });
+        return Promise.all(promises);
+    }
+}
+class UpgradeNg1ComponentAdapter {
+    constructor(helper, scope, template, inputs, outputs, propOuts, checkProperties, propertyMap) {
+        this.helper = helper;
+        this.template = template;
+        this.inputs = inputs;
+        this.outputs = outputs;
+        this.propOuts = propOuts;
+        this.checkProperties = checkProperties;
+        this.propertyMap = propertyMap;
+        this.controllerInstance = null;
+        this.destinationObj = null;
+        this.checkLastValues = [];
+        this.$element = null;
+        this.directive = helper.directive;
+        this.element = helper.element;
+        this.$element = helper.$element;
+        this.componentScope = scope.$new(!!this.directive.scope);
+        const controllerType = this.directive.controller;
+        if (this.directive.bindToController && controllerType) {
+            this.controllerInstance = this.helper.buildController(controllerType, this.componentScope);
+            this.destinationObj = this.controllerInstance;
+        }
+        else {
+            this.destinationObj = this.componentScope;
+        }
+        for (let i = 0; i < inputs.length; i++) {
+            this[inputs[i]] = null;
+        }
+        for (let j = 0; j < outputs.length; j++) {
+            const emitter = this[outputs[j]] = new EventEmitter();
+            if (this.propOuts.indexOf(outputs[j]) === -1) {
+                this.setComponentProperty(outputs[j], (emitter => (value) => emitter.emit(value))(emitter));
+            }
+        }
+        for (let k = 0; k < propOuts.length; k++) {
+            this.checkLastValues.push(INITIAL_VALUE);
+        }
+    }
+    ngOnInit() {
+        // Collect contents, insert and compile template
+        const attachChildNodes = this.helper.prepareTransclusion();
+        const linkFn = this.helper.compileTemplate(this.template);
+        // Instantiate controller (if not already done so)
+        const controllerType = this.directive.controller;
+        const bindToController = this.directive.bindToController;
+        if (controllerType && !bindToController) {
+            this.controllerInstance = this.helper.buildController(controllerType, this.componentScope);
+        }
+        // Require other controllers
+        const requiredControllers = this.helper.resolveAndBindRequiredControllers(this.controllerInstance);
+        // Hook: $onInit
+        if (this.controllerInstance && isFunction(this.controllerInstance.$onInit)) {
+            this.controllerInstance.$onInit();
+        }
+        // Linking
+        const link = this.directive.link;
+        const preLink = typeof link == 'object' && link.pre;
+        const postLink = typeof link == 'object' ? link.post : link;
+        const attrs = NOT_SUPPORTED;
+        const transcludeFn = NOT_SUPPORTED;
+        if (preLink) {
+            preLink(this.componentScope, this.$element, attrs, requiredControllers, transcludeFn);
+        }
+        linkFn(this.componentScope, null, { parentBoundTranscludeFn: attachChildNodes });
+        if (postLink) {
+            postLink(this.componentScope, this.$element, attrs, requiredControllers, transcludeFn);
+        }
+        // Hook: $postLink
+        if (this.controllerInstance && isFunction(this.controllerInstance.$postLink)) {
+            this.controllerInstance.$postLink();
+        }
+    }
+    ngOnChanges(changes) {
+        const ng1Changes = {};
+        Object.keys(changes).forEach(name => {
+            const change = changes[name];
+            this.setComponentProperty(name, change.currentValue);
+            ng1Changes[this.propertyMap[name]] = change;
+        });
+        if (isFunction(this.destinationObj.$onChanges)) {
+            this.destinationObj.$onChanges(ng1Changes);
+        }
+    }
+    ngDoCheck() {
+        const destinationObj = this.destinationObj;
+        const lastValues = this.checkLastValues;
+        const checkProperties = this.checkProperties;
+        const propOuts = this.propOuts;
+        checkProperties.forEach((propName, i) => {
+            const value = destinationObj[propName];
+            const last = lastValues[i];
+            if (!strictEquals(last, value)) {
+                const eventEmitter = this[propOuts[i]];
+                eventEmitter.emit(lastValues[i] = value);
+            }
+        });
+        if (this.controllerInstance && isFunction(this.controllerInstance.$doCheck)) {
+            this.controllerInstance.$doCheck();
+        }
+    }
+    ngOnDestroy() {
+        this.helper.onDestroy(this.componentScope, this.controllerInstance);
+    }
+    setComponentProperty(name, value) {
+        this.destinationObj[this.propertyMap[name]] = value;
+    }
+}
+UpgradeNg1ComponentAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: UpgradeNg1ComponentAdapter, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+UpgradeNg1ComponentAdapter.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-rc.3", type: UpgradeNg1ComponentAdapter, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: UpgradeNg1ComponentAdapter, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.UpgradeHelper }, { type: undefined }, { type: undefined }, { type: undefined }, { type: undefined }, { type: undefined }, { type: undefined }, { type: undefined }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgrade_ng1_adapter.js","sourceRoot":"","sources":["../../../../../../../../packages/upgrade/src/dynamic/src/upgrade_ng1_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 {Directive, DoCheck, ElementRef, EventEmitter, Inject, Injector, OnChanges, OnDestroy, OnInit, SimpleChange, SimpleChanges, Type} from '@angular/core';\n\nimport {IAttributes, IDirective, IDirectivePrePost, IInjectorService, ILinkFn, IScope, ITranscludeFunction} from '../../common/src/angular1';\nimport {$SCOPE} from '../../common/src/constants';\nimport {IBindingDestination, IControllerInstance, UpgradeHelper} from '../../common/src/upgrade_helper';\nimport {isFunction, strictEquals} from '../../common/src/util';\n\n\nconst CAMEL_CASE = /([A-Z])/g;\nconst INITIAL_VALUE = {\n  __UNINITIALIZED__: true\n};\nconst NOT_SUPPORTED: any = 'NOT_SUPPORTED';\n\n\nexport class UpgradeNg1ComponentAdapterBuilder {\n  // TODO(issue/24571): remove '!'.\n  type!: Type<any>;\n  inputs: string[] = [];\n  inputsRename: string[] = [];\n  outputs: string[] = [];\n  outputsRename: string[] = [];\n  propertyOutputs: string[] = [];\n  checkProperties: string[] = [];\n  propertyMap: {[name: string]: string} = {};\n  directive: IDirective|null = null;\n  // TODO(issue/24571): remove '!'.\n  template !: string;\n\n  constructor(public name: string) {\n    const selector =\n        name.replace(CAMEL_CASE, (all: string, next: string) => '-' + next.toLowerCase());\n    const self = this;\n\n    // Note: There is a bug in TS 2.4 that prevents us from\n    // inlining this into @Directive\n    // TODO(tbosch): find or file a bug against TypeScript for this.\n    const directive = {selector: selector, inputs: this.inputsRename, outputs: this.outputsRename};\n\n    @Directive({jit: true, ...directive})\n    class MyClass extends UpgradeNg1ComponentAdapter implements OnInit, OnChanges, DoCheck,\n                                                                OnDestroy {\n      constructor(@Inject($SCOPE) scope: IScope, injector: Injector, elementRef: ElementRef) {\n        super(\n            new UpgradeHelper(injector, name, elementRef, self.directive || undefined), scope,\n            self.template, self.inputs, self.outputs, self.propertyOutputs, self.checkProperties,\n            self.propertyMap) as any;\n      }\n    }\n    this.type = MyClass;\n  }\n\n  extractBindings() {\n    const btcIsObject = typeof this.directive!.bindToController === 'object';\n    if (btcIsObject && Object.keys(this.directive!.scope!).length) {\n      throw new Error(\n          `Binding definitions on scope and controller at the same time are not supported.`);\n    }\n\n    const context = (btcIsObject) ? this.directive!.bindToController : this.directive!.scope;\n\n    if (typeof context == 'object') {\n      Object.keys(context).forEach(propName => {\n        const definition = context[propName];\n        const bindingType = definition.charAt(0);\n        const bindingOptions = definition.charAt(1);\n        const attrName = definition.substring(bindingOptions === '?' ? 2 : 1) || propName;\n\n        // QUESTION: What about `=*`? Ignore? Throw? Support?\n\n        const inputName = `input_${attrName}`;\n        const inputNameRename = `${inputName}: ${attrName}`;\n        const outputName = `output_${attrName}`;\n        const outputNameRename = `${outputName}: ${attrName}`;\n        const outputNameRenameChange = `${outputNameRename}Change`;\n\n        switch (bindingType) {\n          case '@':\n          case '<':\n            this.inputs.push(inputName);\n            this.inputsRename.push(inputNameRename);\n            this.propertyMap[inputName] = propName;\n            break;\n          case '=':\n            this.inputs.push(inputName);\n            this.inputsRename.push(inputNameRename);\n            this.propertyMap[inputName] = propName;\n\n            this.outputs.push(outputName);\n            this.outputsRename.push(outputNameRenameChange);\n            this.propertyMap[outputName] = propName;\n\n            this.checkProperties.push(propName);\n            this.propertyOutputs.push(outputName);\n            break;\n          case '&':\n            this.outputs.push(outputName);\n            this.outputsRename.push(outputNameRename);\n            this.propertyMap[outputName] = propName;\n            break;\n          default:\n            let json = JSON.stringify(context);\n            throw new Error(\n                `Unexpected mapping '${bindingType}' in '${json}' in '${this.name}' directive.`);\n        }\n      });\n    }\n  }\n\n  /**\n   * Upgrade ng1 components into Angular.\n   */\n  static resolve(\n      exportedComponents: {[name: string]: UpgradeNg1ComponentAdapterBuilder},\n      $injector: IInjectorService): Promise<string[]> {\n    const promises = Object.keys(exportedComponents).map(name => {\n      const exportedComponent = exportedComponents[name];\n      exportedComponent.directive = UpgradeHelper.getDirective($injector, name);\n      exportedComponent.extractBindings();\n\n      return Promise\n          .resolve(UpgradeHelper.getTemplate($injector, exportedComponent.directive, true))\n          .then(template => exportedComponent.template = template);\n    });\n\n    return Promise.all(promises);\n  }\n}\n\n@Directive()\nclass UpgradeNg1ComponentAdapter implements OnInit, OnChanges, DoCheck {\n  private controllerInstance: IControllerInstance|null = null;\n  destinationObj: IBindingDestination|null = null;\n  checkLastValues: any[] = [];\n  directive: IDirective;\n  element: Element;\n  $element: any = null;\n  componentScope: IScope;\n\n  constructor(\n      private helper: UpgradeHelper, scope: IScope, private template: string,\n      private inputs: string[], private outputs: string[], private propOuts: string[],\n      private checkProperties: string[], private propertyMap: {[key: string]: string}) {\n    this.directive = helper.directive;\n    this.element = helper.element;\n    this.$element = helper.$element;\n    this.componentScope = scope.$new(!!this.directive.scope);\n\n    const controllerType = this.directive.controller;\n\n    if (this.directive.bindToController && controllerType) {\n      this.controllerInstance = this.helper.buildController(controllerType, this.componentScope);\n      this.destinationObj = this.controllerInstance;\n    } else {\n      this.destinationObj = this.componentScope;\n    }\n\n    for (let i = 0; i < inputs.length; i++) {\n      (this as any)[inputs[i]] = null;\n    }\n    for (let j = 0; j < outputs.length; j++) {\n      const emitter = (this as any)[outputs[j]] = new EventEmitter<any>();\n      if (this.propOuts.indexOf(outputs[j]) === -1) {\n        this.setComponentProperty(\n            outputs[j], (emitter => (value: any) => emitter.emit(value))(emitter));\n      }\n    }\n    for (let k = 0; k < propOuts.length; k++) {\n      this.checkLastValues.push(INITIAL_VALUE);\n    }\n  }\n\n  ngOnInit() {\n    // Collect contents, insert and compile template\n    const attachChildNodes: ILinkFn|undefined = this.helper.prepareTransclusion();\n    const linkFn = this.helper.compileTemplate(this.template);\n\n    // Instantiate controller (if not already done so)\n    const controllerType = this.directive.controller;\n    const bindToController = this.directive.bindToController;\n    if (controllerType && !bindToController) {\n      this.controllerInstance = this.helper.buildController(controllerType, this.componentScope);\n    }\n\n    // Require other controllers\n    const requiredControllers =\n        this.helper.resolveAndBindRequiredControllers(this.controllerInstance);\n\n    // Hook: $onInit\n    if (this.controllerInstance && isFunction(this.controllerInstance.$onInit)) {\n      this.controllerInstance.$onInit();\n    }\n\n    // Linking\n    const link = this.directive.link;\n    const preLink = typeof link == 'object' && link.pre;\n    const postLink = typeof link == 'object' ? link.post : link;\n    const attrs: IAttributes = NOT_SUPPORTED;\n    const transcludeFn: ITranscludeFunction = NOT_SUPPORTED;\n    if (preLink) {\n      preLink(this.componentScope, this.$element, attrs, requiredControllers, transcludeFn);\n    }\n\n    linkFn(this.componentScope, null!, {parentBoundTranscludeFn: attachChildNodes});\n\n    if (postLink) {\n      postLink(this.componentScope, this.$element, attrs, requiredControllers, transcludeFn);\n    }\n\n    // Hook: $postLink\n    if (this.controllerInstance && isFunction(this.controllerInstance.$postLink)) {\n      this.controllerInstance.$postLink();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    const ng1Changes: any = {};\n    Object.keys(changes).forEach(name => {\n      const change: SimpleChange = changes[name];\n      this.setComponentProperty(name, change.currentValue);\n      ng1Changes[this.propertyMap[name]] = change;\n    });\n\n    if (isFunction(this.destinationObj!.$onChanges)) {\n      this.destinationObj!.$onChanges!(ng1Changes);\n    }\n  }\n\n  ngDoCheck() {\n    const destinationObj = this.destinationObj;\n    const lastValues = this.checkLastValues;\n    const checkProperties = this.checkProperties;\n    const propOuts = this.propOuts;\n    checkProperties.forEach((propName, i) => {\n      const value = destinationObj![propName];\n      const last = lastValues[i];\n      if (!strictEquals(last, value)) {\n        const eventEmitter: EventEmitter<any> = (this as any)[propOuts[i]];\n        eventEmitter.emit(lastValues[i] = value);\n      }\n    });\n\n    if (this.controllerInstance && isFunction(this.controllerInstance.$doCheck)) {\n      this.controllerInstance.$doCheck();\n    }\n  }\n\n  ngOnDestroy() {\n    this.helper.onDestroy(this.componentScope, this.controllerInstance);\n  }\n\n  setComponentProperty(name: string, value: any) {\n    this.destinationObj![this.propertyMap[name]] = value;\n  }\n}\n"]}

package/esm2020/static/src/upgrade_component.mjs

@@ -0,0 +1,240 @@
+/**
+ * @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 { Directive, ElementRef, EventEmitter, Injector } from '@angular/core';
+import { $SCOPE } from '../../src/common/src/constants';
+import { UpgradeHelper } from '../../src/common/src/upgrade_helper';
+import { isFunction } from '../../src/common/src/util';
+import * as i0 from "@angular/core";
+const NOT_SUPPORTED = 'NOT_SUPPORTED';
+const INITIAL_VALUE = {
+    __UNINITIALIZED__: true
+};
+class Bindings {
+    constructor() {
+        this.twoWayBoundProperties = [];
+        this.twoWayBoundLastValues = [];
+        this.expressionBoundProperties = [];
+        this.propertyToOutputMap = {};
+    }
+}
+/**
+ * @description
+ *
+ * A helper class that allows an AngularJS component to be used from Angular.
+ *
+ * *Part of the [upgrade/static](api?query=upgrade%2Fstatic)
+ * library for hybrid upgrade apps that support AOT compilation.*
+ *
+ * This helper class should be used as a base class for creating Angular directives
+ * that wrap AngularJS components that need to be "upgraded".
+ *
+ * @usageNotes
+ * ### Examples
+ *
+ * Let's assume that you have an AngularJS component called `ng1Hero` that needs
+ * to be made available in Angular templates.
+ *
+ * {@example upgrade/static/ts/full/module.ts region="ng1-hero"}
+ *
+ * We must create a `Directive` that will make this AngularJS component
+ * available inside Angular templates.
+ *
+ * {@example upgrade/static/ts/full/module.ts region="ng1-hero-wrapper"}
+ *
+ * In this example you can see that we must derive from the `UpgradeComponent`
+ * base class but also provide an {@link Directive `@Directive`} decorator. This is
+ * because the AOT compiler requires that this information is statically available at
+ * compile time.
+ *
+ * Note that we must do the following:
+ * * specify the directive's selector (`ng1-hero`)
+ * * specify all inputs and outputs that the AngularJS component expects
+ * * derive from `UpgradeComponent`
+ * * call the base class from the constructor, passing
+ *   * the AngularJS name of the component (`ng1Hero`)
+ *   * the `ElementRef` and `Injector` for the component wrapper
+ *
+ * @publicApi
+ * @extensible
+ */
+export class UpgradeComponent {
+    /**
+     * Create a new `UpgradeComponent` instance. You should not normally need to do this.
+     * Instead you should derive a new class from this one and call the super constructor
+     * from the base class.
+     *
+     * {@example upgrade/static/ts/full/module.ts region="ng1-hero-wrapper" }
+     *
+     * * The `name` parameter should be the name of the AngularJS directive.
+     * * The `elementRef` and `injector` parameters should be acquired from Angular by dependency
+     *   injection into the base class constructor.
+     */
+    constructor(name, elementRef, injector) {
+        this.name = name;
+        this.elementRef = elementRef;
+        this.injector = injector;
+        this.helper = new UpgradeHelper(injector, name, elementRef);
+        this.$injector = this.helper.$injector;
+        this.element = this.helper.element;
+        this.$element = this.helper.$element;
+        this.directive = this.helper.directive;
+        this.bindings = this.initializeBindings(this.directive);
+        // We ask for the AngularJS scope from the Angular injector, since
+        // we will put the new component scope onto the new injector for each component
+        const $parentScope = injector.get($SCOPE);
+        // QUESTION 1: Should we create an isolated scope if the scope is only true?
+        // QUESTION 2: Should we make the scope accessible through `$element.scope()/isolateScope()`?
+        this.$componentScope = $parentScope.$new(!!this.directive.scope);
+        this.initializeOutputs();
+    }
+    ngOnInit() {
+        // Collect contents, insert and compile template
+        const attachChildNodes = this.helper.prepareTransclusion();
+        const linkFn = this.helper.compileTemplate();
+        // Instantiate controller
+        const controllerType = this.directive.controller;
+        const bindToController = this.directive.bindToController;
+        if (controllerType) {
+            this.controllerInstance = this.helper.buildController(controllerType, this.$componentScope);
+        }
+        else if (bindToController) {
+            throw new Error(`Upgraded directive '${this.directive.name}' specifies 'bindToController' but no controller.`);
+        }
+        // Set up outputs
+        this.bindingDestination = bindToController ? this.controllerInstance : this.$componentScope;
+        this.bindOutputs();
+        // Require other controllers
+        const requiredControllers = this.helper.resolveAndBindRequiredControllers(this.controllerInstance);
+        // Hook: $onChanges
+        if (this.pendingChanges) {
+            this.forwardChanges(this.pendingChanges);
+            this.pendingChanges = null;
+        }
+        // Hook: $onInit
+        if (this.controllerInstance && isFunction(this.controllerInstance.$onInit)) {
+            this.controllerInstance.$onInit();
+        }
+        // Hook: $doCheck
+        if (this.controllerInstance && isFunction(this.controllerInstance.$doCheck)) {
+            const callDoCheck = () => this.controllerInstance.$doCheck();
+            this.unregisterDoCheckWatcher = this.$componentScope.$parent.$watch(callDoCheck);
+            callDoCheck();
+        }
+        // Linking
+        const link = this.directive.link;
+        const preLink = typeof link == 'object' && link.pre;
+        const postLink = typeof link == 'object' ? link.post : link;
+        const attrs = NOT_SUPPORTED;
+        const transcludeFn = NOT_SUPPORTED;
+        if (preLink) {
+            preLink(this.$componentScope, this.$element, attrs, requiredControllers, transcludeFn);
+        }
+        linkFn(this.$componentScope, null, { parentBoundTranscludeFn: attachChildNodes });
+        if (postLink) {
+            postLink(this.$componentScope, this.$element, attrs, requiredControllers, transcludeFn);
+        }
+        // Hook: $postLink
+        if (this.controllerInstance && isFunction(this.controllerInstance.$postLink)) {
+            this.controllerInstance.$postLink();
+        }
+    }
+    ngOnChanges(changes) {
+        if (!this.bindingDestination) {
+            this.pendingChanges = changes;
+        }
+        else {
+            this.forwardChanges(changes);
+        }
+    }
+    ngDoCheck() {
+        const twoWayBoundProperties = this.bindings.twoWayBoundProperties;
+        const twoWayBoundLastValues = this.bindings.twoWayBoundLastValues;
+        const propertyToOutputMap = this.bindings.propertyToOutputMap;
+        twoWayBoundProperties.forEach((propName, idx) => {
+            const newValue = this.bindingDestination[propName];
+            const oldValue = twoWayBoundLastValues[idx];
+            if (!Object.is(newValue, oldValue)) {
+                const outputName = propertyToOutputMap[propName];
+                const eventEmitter = this[outputName];
+                eventEmitter.emit(newValue);
+                twoWayBoundLastValues[idx] = newValue;
+            }
+        });
+    }
+    ngOnDestroy() {
+        if (isFunction(this.unregisterDoCheckWatcher)) {
+            this.unregisterDoCheckWatcher();
+        }
+        this.helper.onDestroy(this.$componentScope, this.controllerInstance);
+    }
+    initializeBindings(directive) {
+        const btcIsObject = typeof directive.bindToController === 'object';
+        if (btcIsObject && Object.keys(directive.scope).length) {
+            throw new Error(`Binding definitions on scope and controller at the same time is not supported.`);
+        }
+        const context = btcIsObject ? directive.bindToController : directive.scope;
+        const bindings = new Bindings();
+        if (typeof context == 'object') {
+            Object.keys(context).forEach(propName => {
+                const definition = context[propName];
+                const bindingType = definition.charAt(0);
+                // QUESTION: What about `=*`? Ignore? Throw? Support?
+                switch (bindingType) {
+                    case '@':
+                    case '<':
+                        // We don't need to do anything special. They will be defined as inputs on the
+                        // upgraded component facade and the change propagation will be handled by
+                        // `ngOnChanges()`.
+                        break;
+                    case '=':
+                        bindings.twoWayBoundProperties.push(propName);
+                        bindings.twoWayBoundLastValues.push(INITIAL_VALUE);
+                        bindings.propertyToOutputMap[propName] = propName + 'Change';
+                        break;
+                    case '&':
+                        bindings.expressionBoundProperties.push(propName);
+                        bindings.propertyToOutputMap[propName] = propName;
+                        break;
+                    default:
+                        let json = JSON.stringify(context);
+                        throw new Error(`Unexpected mapping '${bindingType}' in '${json}' in '${this.name}' directive.`);
+                }
+            });
+        }
+        return bindings;
+    }
+    initializeOutputs() {
+        // Initialize the outputs for `=` and `&` bindings
+        this.bindings.twoWayBoundProperties.concat(this.bindings.expressionBoundProperties)
+            .forEach(propName => {
+            const outputName = this.bindings.propertyToOutputMap[propName];
+            this[outputName] = new EventEmitter();
+        });
+    }
+    bindOutputs() {
+        // Bind `&` bindings to the corresponding outputs
+        this.bindings.expressionBoundProperties.forEach(propName => {
+            const outputName = this.bindings.propertyToOutputMap[propName];
+            const emitter = this[outputName];
+            this.bindingDestination[propName] = (value) => emitter.emit(value);
+        });
+    }
+    forwardChanges(changes) {
+        // Forward input changes to `bindingDestination`
+        Object.keys(changes).forEach(propName => this.bindingDestination[propName] = changes[propName].currentValue);
+        if (isFunction(this.bindingDestination.$onChanges)) {
+            this.bindingDestination.$onChanges(changes);
+        }
+    }
+}
+UpgradeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: UpgradeComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+UpgradeComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-rc.3", type: UpgradeComponent, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: UpgradeComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: i0.ElementRef }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgrade_component.js","sourceRoot":"","sources":["../../../../../../../packages/upgrade/static/src/upgrade_component.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 {Directive, DoCheck, ElementRef, EventEmitter, Injector, OnChanges, OnDestroy, OnInit, SimpleChanges} from '@angular/core';\n\nimport {IAttributes, IAugmentedJQuery, IDirective, IInjectorService, ILinkFn, IScope, ITranscludeFunction} from '../../src/common/src/angular1';\nimport {$SCOPE} from '../../src/common/src/constants';\nimport {IBindingDestination, IControllerInstance, UpgradeHelper} from '../../src/common/src/upgrade_helper';\nimport {isFunction} from '../../src/common/src/util';\n\nconst NOT_SUPPORTED: any = 'NOT_SUPPORTED';\nconst INITIAL_VALUE = {\n  __UNINITIALIZED__: true\n};\n\nclass Bindings {\n  twoWayBoundProperties: string[] = [];\n  twoWayBoundLastValues: any[] = [];\n\n  expressionBoundProperties: string[] = [];\n\n  propertyToOutputMap: {[propName: string]: string} = {};\n}\n\n/**\n * @description\n *\n * A helper class that allows an AngularJS component to be used from Angular.\n *\n * *Part of the [upgrade/static](api?query=upgrade%2Fstatic)\n * library for hybrid upgrade apps that support AOT compilation.*\n *\n * This helper class should be used as a base class for creating Angular directives\n * that wrap AngularJS components that need to be \"upgraded\".\n *\n * @usageNotes\n * ### Examples\n *\n * Let's assume that you have an AngularJS component called `ng1Hero` that needs\n * to be made available in Angular templates.\n *\n * {@example upgrade/static/ts/full/module.ts region=\"ng1-hero\"}\n *\n * We must create a `Directive` that will make this AngularJS component\n * available inside Angular templates.\n *\n * {@example upgrade/static/ts/full/module.ts region=\"ng1-hero-wrapper\"}\n *\n * In this example you can see that we must derive from the `UpgradeComponent`\n * base class but also provide an {@link Directive `@Directive`} decorator. This is\n * because the AOT compiler requires that this information is statically available at\n * compile time.\n *\n * Note that we must do the following:\n * * specify the directive's selector (`ng1-hero`)\n * * specify all inputs and outputs that the AngularJS component expects\n * * derive from `UpgradeComponent`\n * * call the base class from the constructor, passing\n *   * the AngularJS name of the component (`ng1Hero`)\n *   * the `ElementRef` and `Injector` for the component wrapper\n *\n * @publicApi\n * @extensible\n */\n@Directive()\nexport class UpgradeComponent implements OnInit, OnChanges, DoCheck, OnDestroy {\n  private helper: UpgradeHelper;\n\n  private $injector: IInjectorService;\n\n  private element: Element;\n  private $element: IAugmentedJQuery;\n  private $componentScope: IScope;\n\n  private directive: IDirective;\n  private bindings: Bindings;\n\n  // TODO(issue/24571): remove '!'.\n  private controllerInstance!: IControllerInstance;\n  // TODO(issue/24571): remove '!'.\n  private bindingDestination!: IBindingDestination;\n\n  // We will be instantiating the controller in the `ngOnInit` hook, when the\n  // first `ngOnChanges` will have been already triggered. We store the\n  // `SimpleChanges` and \"play them back\" later.\n  // TODO(issue/24571): remove '!'.\n  private pendingChanges!: SimpleChanges|null;\n\n  // TODO(issue/24571): remove '!'.\n  private unregisterDoCheckWatcher!: Function;\n\n  /**\n   * Create a new `UpgradeComponent` instance. You should not normally need to do this.\n   * Instead you should derive a new class from this one and call the super constructor\n   * from the base class.\n   *\n   * {@example upgrade/static/ts/full/module.ts region=\"ng1-hero-wrapper\" }\n   *\n   * * The `name` parameter should be the name of the AngularJS directive.\n   * * The `elementRef` and `injector` parameters should be acquired from Angular by dependency\n   *   injection into the base class constructor.\n   */\n  constructor(private name: string, private elementRef: ElementRef, private injector: Injector) {\n    this.helper = new UpgradeHelper(injector, name, elementRef);\n\n    this.$injector = this.helper.$injector;\n\n    this.element = this.helper.element;\n    this.$element = this.helper.$element;\n\n    this.directive = this.helper.directive;\n    this.bindings = this.initializeBindings(this.directive);\n\n    // We ask for the AngularJS scope from the Angular injector, since\n    // we will put the new component scope onto the new injector for each component\n    const $parentScope = injector.get($SCOPE);\n    // QUESTION 1: Should we create an isolated scope if the scope is only true?\n    // QUESTION 2: Should we make the scope accessible through `$element.scope()/isolateScope()`?\n    this.$componentScope = $parentScope.$new(!!this.directive.scope);\n\n    this.initializeOutputs();\n  }\n\n  ngOnInit() {\n    // Collect contents, insert and compile template\n    const attachChildNodes: ILinkFn|undefined = this.helper.prepareTransclusion();\n    const linkFn = this.helper.compileTemplate();\n\n    // Instantiate controller\n    const controllerType = this.directive.controller;\n    const bindToController = this.directive.bindToController;\n    if (controllerType) {\n      this.controllerInstance = this.helper.buildController(controllerType, this.$componentScope);\n    } else if (bindToController) {\n      throw new Error(`Upgraded directive '${\n          this.directive.name}' specifies 'bindToController' but no controller.`);\n    }\n\n    // Set up outputs\n    this.bindingDestination = bindToController ? this.controllerInstance : this.$componentScope;\n    this.bindOutputs();\n\n    // Require other controllers\n    const requiredControllers =\n        this.helper.resolveAndBindRequiredControllers(this.controllerInstance);\n\n    // Hook: $onChanges\n    if (this.pendingChanges) {\n      this.forwardChanges(this.pendingChanges);\n      this.pendingChanges = null;\n    }\n\n    // Hook: $onInit\n    if (this.controllerInstance && isFunction(this.controllerInstance.$onInit)) {\n      this.controllerInstance.$onInit();\n    }\n\n    // Hook: $doCheck\n    if (this.controllerInstance && isFunction(this.controllerInstance.$doCheck)) {\n      const callDoCheck = () => this.controllerInstance.$doCheck!();\n\n      this.unregisterDoCheckWatcher = this.$componentScope.$parent.$watch(callDoCheck);\n      callDoCheck();\n    }\n\n    // Linking\n    const link = this.directive.link;\n    const preLink = typeof link == 'object' && link.pre;\n    const postLink = typeof link == 'object' ? link.post : link;\n    const attrs: IAttributes = NOT_SUPPORTED;\n    const transcludeFn: ITranscludeFunction = NOT_SUPPORTED;\n    if (preLink) {\n      preLink(this.$componentScope, this.$element, attrs, requiredControllers, transcludeFn);\n    }\n\n    linkFn(this.$componentScope, null!, {parentBoundTranscludeFn: attachChildNodes});\n\n    if (postLink) {\n      postLink(this.$componentScope, this.$element, attrs, requiredControllers, transcludeFn);\n    }\n\n    // Hook: $postLink\n    if (this.controllerInstance && isFunction(this.controllerInstance.$postLink)) {\n      this.controllerInstance.$postLink();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (!this.bindingDestination) {\n      this.pendingChanges = changes;\n    } else {\n      this.forwardChanges(changes);\n    }\n  }\n\n  ngDoCheck() {\n    const twoWayBoundProperties = this.bindings.twoWayBoundProperties;\n    const twoWayBoundLastValues = this.bindings.twoWayBoundLastValues;\n    const propertyToOutputMap = this.bindings.propertyToOutputMap;\n\n    twoWayBoundProperties.forEach((propName, idx) => {\n      const newValue = this.bindingDestination[propName];\n      const oldValue = twoWayBoundLastValues[idx];\n\n      if (!Object.is(newValue, oldValue)) {\n        const outputName = propertyToOutputMap[propName];\n        const eventEmitter: EventEmitter<any> = (this as any)[outputName];\n\n        eventEmitter.emit(newValue);\n        twoWayBoundLastValues[idx] = newValue;\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    if (isFunction(this.unregisterDoCheckWatcher)) {\n      this.unregisterDoCheckWatcher();\n    }\n    this.helper.onDestroy(this.$componentScope, this.controllerInstance);\n  }\n\n  private initializeBindings(directive: IDirective) {\n    const btcIsObject = typeof directive.bindToController === 'object';\n    if (btcIsObject && Object.keys(directive.scope!).length) {\n      throw new Error(\n          `Binding definitions on scope and controller at the same time is not supported.`);\n    }\n\n    const context = btcIsObject ? directive.bindToController : directive.scope;\n    const bindings = new Bindings();\n\n    if (typeof context == 'object') {\n      Object.keys(context).forEach(propName => {\n        const definition = context[propName];\n        const bindingType = definition.charAt(0);\n\n        // QUESTION: What about `=*`? Ignore? Throw? Support?\n\n        switch (bindingType) {\n          case '@':\n          case '<':\n            // We don't need to do anything special. They will be defined as inputs on the\n            // upgraded component facade and the change propagation will be handled by\n            // `ngOnChanges()`.\n            break;\n          case '=':\n            bindings.twoWayBoundProperties.push(propName);\n            bindings.twoWayBoundLastValues.push(INITIAL_VALUE);\n            bindings.propertyToOutputMap[propName] = propName + 'Change';\n            break;\n          case '&':\n            bindings.expressionBoundProperties.push(propName);\n            bindings.propertyToOutputMap[propName] = propName;\n            break;\n          default:\n            let json = JSON.stringify(context);\n            throw new Error(\n                `Unexpected mapping '${bindingType}' in '${json}' in '${this.name}' directive.`);\n        }\n      });\n    }\n\n    return bindings;\n  }\n\n  private initializeOutputs() {\n    // Initialize the outputs for `=` and `&` bindings\n    this.bindings.twoWayBoundProperties.concat(this.bindings.expressionBoundProperties)\n        .forEach(propName => {\n          const outputName = this.bindings.propertyToOutputMap[propName];\n          (this as any)[outputName] = new EventEmitter();\n        });\n  }\n\n  private bindOutputs() {\n    // Bind `&` bindings to the corresponding outputs\n    this.bindings.expressionBoundProperties.forEach(propName => {\n      const outputName = this.bindings.propertyToOutputMap[propName];\n      const emitter = (this as any)[outputName];\n\n      this.bindingDestination[propName] = (value: any) => emitter.emit(value);\n    });\n  }\n\n  private forwardChanges(changes: SimpleChanges) {\n    // Forward input changes to `bindingDestination`\n    Object.keys(changes).forEach(\n        propName => this.bindingDestination[propName] = changes[propName].currentValue);\n\n    if (isFunction(this.bindingDestination.$onChanges)) {\n      this.bindingDestination.$onChanges(changes);\n    }\n  }\n}\n"]}