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

package/schematics/utils/ng_component_template.js

@@ -5,6 +5,9 @@
  * 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
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
@@ -19,7 +22,7 @@
     exports.NgComponentTemplateVisitor = void 0;
     const fs_1 = require("fs");
     const path_1 = require("path");
-    const ts = require("typescript");
+    const typescript_1 = __importDefault(require("typescript"));
     const line_mappings_1 = require("@angular/core/schematics/utils/line_mappings");
     const ng_decorators_1 = require("@angular/core/schematics/utils/ng_decorators");
     const functions_1 = require("@angular/core/schematics/utils/typescript/functions");
@@ -34,10 +37,10 @@
             this.resolvedTemplates = [];
         }
         visitNode(node) {
-            if (node.kind === ts.SyntaxKind.ClassDeclaration) {
+            if (node.kind === typescript_1.default.SyntaxKind.ClassDeclaration) {
                 this.visitClassDeclaration(node);
             }
-            ts.forEachChild(node, n => this.visitNode(n));
+            typescript_1.default.forEachChild(node, n => this.visitNode(n));
         }
         visitClassDeclaration(node) {
             if (!node.decorators || !node.decorators.length) {
@@ -56,7 +59,7 @@
             }
             const componentMetadata = (0, functions_1.unwrapExpression)(decoratorCall.arguments[0]);
             // Ensure that the component metadata is an object literal expression.
-            if (!ts.isObjectLiteralExpression(componentMetadata)) {
+            if (!typescript_1.default.isObjectLiteralExpression(componentMetadata)) {
                 return;
             }
             const sourceFile = node.getSourceFile();
@@ -64,13 +67,13 @@
             // Walk through all component metadata properties and determine the referenced
             // HTML templates (either external or inline)
             componentMetadata.properties.forEach(property => {
-                if (!ts.isPropertyAssignment(property)) {
+                if (!typescript_1.default.isPropertyAssignment(property)) {
                     return;
                 }
                 const propertyName = (0, property_name_1.getPropertyNameText)(property.name);
                 // In case there is an inline template specified, ensure that the value is statically
                 // analyzable by checking if the initializer is a string literal-like node.
-                if (propertyName === 'template' && ts.isStringLiteralLike(property.initializer)) {
+                if (propertyName === 'template' && typescript_1.default.isStringLiteralLike(property.initializer)) {
                     // Need to add an offset of one to the start because the template quotes are
                     // not part of the template content.
                     const templateStartIdx = property.initializer.getStart() + 1;
@@ -81,10 +84,10 @@
                         content: property.initializer.text,
                         inline: true,
                         start: templateStartIdx,
-                        getCharacterAndLineOfPosition: pos => ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx)
+                        getCharacterAndLineOfPosition: pos => typescript_1.default.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx)
                     });
                 }
-                if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {
+                if (propertyName === 'templateUrl' && typescript_1.default.isStringLiteralLike(property.initializer)) {
                     const templatePath = (0, path_1.resolve)((0, path_1.dirname)(sourceFileName), property.initializer.text);
                     // In case the template does not exist in the file system, skip this
                     // external template.
@@ -107,4 +110,4 @@
     }
     exports.NgComponentTemplateVisitor = NgComponentTemplateVisitor;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng_component_template.js","sourceRoot":"","sources":["../../../../../../../packages/core/schematics/utils/ng_component_template.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 {existsSync, readFileSync} from 'fs';\nimport {dirname, resolve} from 'path';\nimport * as ts from 'typescript';\n\nimport {computeLineStartsMap, getLineAndCharacterFromPosition} from './line_mappings';\nimport {getAngularDecorators} from './ng_decorators';\nimport {unwrapExpression} from './typescript/functions';\nimport {getPropertyNameText} from './typescript/property_name';\n\nexport interface ResolvedTemplate {\n  /** Class declaration that contains this template. */\n  container: ts.ClassDeclaration;\n  /** File content of the given template. */\n  content: string;\n  /** Start offset of the template content (e.g. in the inline source file) */\n  start: number;\n  /** Whether the given template is inline or not. */\n  inline: boolean;\n  /** Path to the file that contains this template. */\n  filePath: string;\n  /**\n   * Gets the character and line of a given position index in the template.\n   * If the template is declared inline within a TypeScript source file, the line and\n   * character are based on the full source file content.\n   */\n  getCharacterAndLineOfPosition: (pos: number) => {\n    character: number, line: number\n  };\n}\n\n/**\n * Visitor that can be used to determine Angular templates referenced within given\n * TypeScript source files (inline templates or external referenced templates)\n */\nexport class NgComponentTemplateVisitor {\n  resolvedTemplates: ResolvedTemplate[] = [];\n\n  constructor(public typeChecker: ts.TypeChecker) {}\n\n  visitNode(node: ts.Node) {\n    if (node.kind === ts.SyntaxKind.ClassDeclaration) {\n      this.visitClassDeclaration(node as ts.ClassDeclaration);\n    }\n\n    ts.forEachChild(node, n => this.visitNode(n));\n  }\n\n  private visitClassDeclaration(node: ts.ClassDeclaration) {\n    if (!node.decorators || !node.decorators.length) {\n      return;\n    }\n\n    const ngDecorators = getAngularDecorators(this.typeChecker, node.decorators);\n    const componentDecorator = ngDecorators.find(dec => dec.name === 'Component');\n\n    // In case no \"@Component\" decorator could be found on the current class, skip.\n    if (!componentDecorator) {\n      return;\n    }\n\n    const decoratorCall = componentDecorator.node.expression;\n\n    // In case the component decorator call is not valid, skip this class declaration.\n    if (decoratorCall.arguments.length !== 1) {\n      return;\n    }\n\n    const componentMetadata = unwrapExpression(decoratorCall.arguments[0]);\n\n    // Ensure that the component metadata is an object literal expression.\n    if (!ts.isObjectLiteralExpression(componentMetadata)) {\n      return;\n    }\n\n    const sourceFile = node.getSourceFile();\n    const sourceFileName = sourceFile.fileName;\n\n    // Walk through all component metadata properties and determine the referenced\n    // HTML templates (either external or inline)\n    componentMetadata.properties.forEach(property => {\n      if (!ts.isPropertyAssignment(property)) {\n        return;\n      }\n\n      const propertyName = getPropertyNameText(property.name);\n\n      // In case there is an inline template specified, ensure that the value is statically\n      // analyzable by checking if the initializer is a string literal-like node.\n      if (propertyName === 'template' && ts.isStringLiteralLike(property.initializer)) {\n        // Need to add an offset of one to the start because the template quotes are\n        // not part of the template content.\n        const templateStartIdx = property.initializer.getStart() + 1;\n        const filePath = resolve(sourceFileName);\n        this.resolvedTemplates.push({\n          filePath: filePath,\n          container: node,\n          content: property.initializer.text,\n          inline: true,\n          start: templateStartIdx,\n          getCharacterAndLineOfPosition: pos =>\n              ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx)\n        });\n      }\n      if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {\n        const templatePath = resolve(dirname(sourceFileName), property.initializer.text);\n\n        // In case the template does not exist in the file system, skip this\n        // external template.\n        if (!existsSync(templatePath)) {\n          return;\n        }\n\n        const fileContent = readFileSync(templatePath, 'utf8');\n        const lineStartsMap = computeLineStartsMap(fileContent);\n\n        this.resolvedTemplates.push({\n          filePath: templatePath,\n          container: node,\n          content: fileContent,\n          inline: false,\n          start: 0,\n          getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),\n        });\n      }\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng_component_template.js","sourceRoot":"","sources":["../../../../../../../packages/core/schematics/utils/ng_component_template.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;IAEH,2BAA4C;IAC5C,+BAAsC;IACtC,4DAA4B;IAE5B,gFAAsF;IACtF,gFAAqD;IACrD,mFAAwD;IACxD,2FAA+D;IAuB/D;;;OAGG;IACH,MAAa,0BAA0B;QAGrC,YAAmB,WAA2B;YAA3B,gBAAW,GAAX,WAAW,CAAgB;YAF9C,sBAAiB,GAAuB,EAAE,CAAC;QAEM,CAAC;QAElD,SAAS,CAAC,IAAa;YACrB,IAAI,IAAI,CAAC,IAAI,KAAK,oBAAE,CAAC,UAAU,CAAC,gBAAgB,EAAE;gBAChD,IAAI,CAAC,qBAAqB,CAAC,IAA2B,CAAC,CAAC;aACzD;YAED,oBAAE,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,CAAC;QAEO,qBAAqB,CAAC,IAAyB;YACrD,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;gBAC/C,OAAO;aACR;YAED,MAAM,YAAY,GAAG,IAAA,oCAAoB,EAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;YAC7E,MAAM,kBAAkB,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,CAAC;YAE9E,+EAA+E;YAC/E,IAAI,CAAC,kBAAkB,EAAE;gBACvB,OAAO;aACR;YAED,MAAM,aAAa,GAAG,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC;YAEzD,kFAAkF;YAClF,IAAI,aAAa,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;gBACxC,OAAO;aACR;YAED,MAAM,iBAAiB,GAAG,IAAA,4BAAgB,EAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;YAEvE,sEAAsE;YACtE,IAAI,CAAC,oBAAE,CAAC,yBAAyB,CAAC,iBAAiB,CAAC,EAAE;gBACpD,OAAO;aACR;YAED,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,cAAc,GAAG,UAAU,CAAC,QAAQ,CAAC;YAE3C,8EAA8E;YAC9E,6CAA6C;YAC7C,iBAAiB,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAC9C,IAAI,CAAC,oBAAE,CAAC,oBAAoB,CAAC,QAAQ,CAAC,EAAE;oBACtC,OAAO;iBACR;gBAED,MAAM,YAAY,GAAG,IAAA,mCAAmB,EAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBAExD,qFAAqF;gBACrF,2EAA2E;gBAC3E,IAAI,YAAY,KAAK,UAAU,IAAI,oBAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;oBAC/E,4EAA4E;oBAC5E,oCAAoC;oBACpC,MAAM,gBAAgB,GAAG,QAAQ,CAAC,WAAW,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;oBAC7D,MAAM,QAAQ,GAAG,IAAA,cAAO,EAAC,cAAc,CAAC,CAAC;oBACzC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;wBAC1B,QAAQ,EAAE,QAAQ;wBAClB,SAAS,EAAE,IAAI;wBACf,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,IAAI;wBAClC,MAAM,EAAE,IAAI;wBACZ,KAAK,EAAE,gBAAgB;wBACvB,6BAA6B,EAAE,GAAG,CAAC,EAAE,CACjC,oBAAE,CAAC,6BAA6B,CAAC,UAAU,EAAE,GAAG,GAAG,gBAAgB,CAAC;qBACzE,CAAC,CAAC;iBACJ;gBACD,IAAI,YAAY,KAAK,aAAa,IAAI,oBAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;oBAClF,MAAM,YAAY,GAAG,IAAA,cAAO,EAAC,IAAA,cAAO,EAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;oBAEjF,oEAAoE;oBACpE,qBAAqB;oBACrB,IAAI,CAAC,IAAA,eAAU,EAAC,YAAY,CAAC,EAAE;wBAC7B,OAAO;qBACR;oBAED,MAAM,WAAW,GAAG,IAAA,iBAAY,EAAC,YAAY,EAAE,MAAM,CAAC,CAAC;oBACvD,MAAM,aAAa,GAAG,IAAA,oCAAoB,EAAC,WAAW,CAAC,CAAC;oBAExD,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;wBAC1B,QAAQ,EAAE,YAAY;wBACtB,SAAS,EAAE,IAAI;wBACf,OAAO,EAAE,WAAW;wBACpB,MAAM,EAAE,KAAK;wBACb,KAAK,EAAE,CAAC;wBACR,6BAA6B,EAAE,GAAG,CAAC,EAAE,CAAC,IAAA,+CAA+B,EAAC,aAAa,EAAE,GAAG,CAAC;qBAC1F,CAAC,CAAC;iBACJ;YACH,CAAC,CAAC,CAAC;QACL,CAAC;KACF;IA5FD,gEA4FC","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 {existsSync, readFileSync} from 'fs';\nimport {dirname, resolve} from 'path';\nimport ts from 'typescript';\n\nimport {computeLineStartsMap, getLineAndCharacterFromPosition} from './line_mappings';\nimport {getAngularDecorators} from './ng_decorators';\nimport {unwrapExpression} from './typescript/functions';\nimport {getPropertyNameText} from './typescript/property_name';\n\nexport interface ResolvedTemplate {\n  /** Class declaration that contains this template. */\n  container: ts.ClassDeclaration;\n  /** File content of the given template. */\n  content: string;\n  /** Start offset of the template content (e.g. in the inline source file) */\n  start: number;\n  /** Whether the given template is inline or not. */\n  inline: boolean;\n  /** Path to the file that contains this template. */\n  filePath: string;\n  /**\n   * Gets the character and line of a given position index in the template.\n   * If the template is declared inline within a TypeScript source file, the line and\n   * character are based on the full source file content.\n   */\n  getCharacterAndLineOfPosition: (pos: number) => {\n    character: number, line: number\n  };\n}\n\n/**\n * Visitor that can be used to determine Angular templates referenced within given\n * TypeScript source files (inline templates or external referenced templates)\n */\nexport class NgComponentTemplateVisitor {\n  resolvedTemplates: ResolvedTemplate[] = [];\n\n  constructor(public typeChecker: ts.TypeChecker) {}\n\n  visitNode(node: ts.Node) {\n    if (node.kind === ts.SyntaxKind.ClassDeclaration) {\n      this.visitClassDeclaration(node as ts.ClassDeclaration);\n    }\n\n    ts.forEachChild(node, n => this.visitNode(n));\n  }\n\n  private visitClassDeclaration(node: ts.ClassDeclaration) {\n    if (!node.decorators || !node.decorators.length) {\n      return;\n    }\n\n    const ngDecorators = getAngularDecorators(this.typeChecker, node.decorators);\n    const componentDecorator = ngDecorators.find(dec => dec.name === 'Component');\n\n    // In case no \"@Component\" decorator could be found on the current class, skip.\n    if (!componentDecorator) {\n      return;\n    }\n\n    const decoratorCall = componentDecorator.node.expression;\n\n    // In case the component decorator call is not valid, skip this class declaration.\n    if (decoratorCall.arguments.length !== 1) {\n      return;\n    }\n\n    const componentMetadata = unwrapExpression(decoratorCall.arguments[0]);\n\n    // Ensure that the component metadata is an object literal expression.\n    if (!ts.isObjectLiteralExpression(componentMetadata)) {\n      return;\n    }\n\n    const sourceFile = node.getSourceFile();\n    const sourceFileName = sourceFile.fileName;\n\n    // Walk through all component metadata properties and determine the referenced\n    // HTML templates (either external or inline)\n    componentMetadata.properties.forEach(property => {\n      if (!ts.isPropertyAssignment(property)) {\n        return;\n      }\n\n      const propertyName = getPropertyNameText(property.name);\n\n      // In case there is an inline template specified, ensure that the value is statically\n      // analyzable by checking if the initializer is a string literal-like node.\n      if (propertyName === 'template' && ts.isStringLiteralLike(property.initializer)) {\n        // Need to add an offset of one to the start because the template quotes are\n        // not part of the template content.\n        const templateStartIdx = property.initializer.getStart() + 1;\n        const filePath = resolve(sourceFileName);\n        this.resolvedTemplates.push({\n          filePath: filePath,\n          container: node,\n          content: property.initializer.text,\n          inline: true,\n          start: templateStartIdx,\n          getCharacterAndLineOfPosition: pos =>\n              ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx)\n        });\n      }\n      if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {\n        const templatePath = resolve(dirname(sourceFileName), property.initializer.text);\n\n        // In case the template does not exist in the file system, skip this\n        // external template.\n        if (!existsSync(templatePath)) {\n          return;\n        }\n\n        const fileContent = readFileSync(templatePath, 'utf8');\n        const lineStartsMap = computeLineStartsMap(fileContent);\n\n        this.resolvedTemplates.push({\n          filePath: templatePath,\n          container: node,\n          content: fileContent,\n          inline: false,\n          start: 0,\n          getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),\n        });\n      }\n    });\n  }\n}\n"]}

package/schematics/utils/ng_decorators.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/core/schematics/utils/ng_decorators" />
-import * as ts from 'typescript';
+import ts from 'typescript';
 export declare type CallExpressionDecorator = ts.Decorator & {
     expression: ts.CallExpression;
 };

package/schematics/utils/ng_decorators.js

@@ -34,4 +34,4 @@
     }
     exports.getAngularDecorators = getAngularDecorators;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/utils/parse_html.d.ts

@@ -6,9 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/core/schematics/utils/parse_html" />
-import { Node } from '@angular/compiler/src/render3/r3_ast';
+import type { TmplAstNode } from '@angular/compiler';
 /**
  * Parses the given HTML content using the Angular compiler. In case the parsing
  * fails, null is being returned.
  */
-export declare function parseHtmlGracefully(htmlContent: string, filePath: string): Node[] | null;
+export declare function parseHtmlGracefully(htmlContent: string, filePath: string, compilerModule: typeof import('@angular/compiler')): TmplAstNode[] | null;

package/schematics/utils/parse_html.js

@@ -11,20 +11,19 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/core/schematics/utils/parse_html", ["require", "exports", "@angular/compiler"], factory);
+        define("@angular/core/schematics/utils/parse_html", ["require", "exports"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.parseHtmlGracefully = void 0;
-    const compiler_1 = require("@angular/compiler");
     /**
      * Parses the given HTML content using the Angular compiler. In case the parsing
      * fails, null is being returned.
      */
-    function parseHtmlGracefully(htmlContent, filePath) {
+    function parseHtmlGracefully(htmlContent, filePath, compilerModule) {
         try {
-            return (0, compiler_1.parseTemplate)(htmlContent, filePath).nodes;
+            return compilerModule.parseTemplate(htmlContent, filePath).nodes;
         }
         catch (_a) {
             // Do nothing if the template couldn't be parsed. We don't want to throw any
@@ -35,4 +34,4 @@
     }
     exports.parseHtmlGracefully = parseHtmlGracefully;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VfaHRtbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc2NoZW1hdGljcy91dGlscy9wYXJzZV9odG1sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7OztJQUVILGdEQUFnRDtJQUdoRDs7O09BR0c7SUFDSCxTQUFnQixtQkFBbUIsQ0FBQyxXQUFtQixFQUFFLFFBQWdCO1FBQ3ZFLElBQUk7WUFDRixPQUFPLElBQUEsd0JBQWEsRUFBQyxXQUFXLEVBQUUsUUFBUSxDQUFDLENBQUMsS0FBSyxDQUFDO1NBQ25EO1FBQUMsV0FBTTtZQUNOLDRFQUE0RTtZQUM1RSw2RUFBNkU7WUFDN0UsNkJBQTZCO1lBQzdCLE9BQU8sSUFBSSxDQUFDO1NBQ2I7SUFDSCxDQUFDO0lBVEQsa0RBU0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtwYXJzZVRlbXBsYXRlfSBmcm9tICdAYW5ndWxhci9jb21waWxlcic7XG5pbXBvcnQge05vZGV9IGZyb20gJ0Bhbmd1bGFyL2NvbXBpbGVyL3NyYy9yZW5kZXIzL3IzX2FzdCc7XG5cbi8qKlxuICogUGFyc2VzIHRoZSBnaXZlbiBIVE1MIGNvbnRlbnQgdXNpbmcgdGhlIEFuZ3VsYXIgY29tcGlsZXIuIEluIGNhc2UgdGhlIHBhcnNpbmdcbiAqIGZhaWxzLCBudWxsIGlzIGJlaW5nIHJldHVybmVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gcGFyc2VIdG1sR3JhY2VmdWxseShodG1sQ29udGVudDogc3RyaW5nLCBmaWxlUGF0aDogc3RyaW5nKTogTm9kZVtdfG51bGwge1xuICB0cnkge1xuICAgIHJldHVybiBwYXJzZVRlbXBsYXRlKGh0bWxDb250ZW50LCBmaWxlUGF0aCkubm9kZXM7XG4gIH0gY2F0Y2gge1xuICAgIC8vIERvIG5vdGhpbmcgaWYgdGhlIHRlbXBsYXRlIGNvdWxkbid0IGJlIHBhcnNlZC4gV2UgZG9uJ3Qgd2FudCB0byB0aHJvdyBhbnlcbiAgICAvLyBleGNlcHRpb24gaWYgYSB0ZW1wbGF0ZSBpcyBzeW50YWN0aWNhbGx5IG5vdCB2YWxpZC4gZS5nLiB0ZW1wbGF0ZSBjb3VsZCBiZVxuICAgIC8vIHVzaW5nIHByZXByb2Nlc3NvciBzeW50YXguXG4gICAgcmV0dXJuIG51bGw7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VfaHRtbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc2NoZW1hdGljcy91dGlscy9wYXJzZV9odG1sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7OztJQUlIOzs7T0FHRztJQUNILFNBQWdCLG1CQUFtQixDQUMvQixXQUFtQixFQUFFLFFBQWdCLEVBQ3JDLGNBQWtEO1FBQ3BELElBQUk7WUFDRixPQUFPLGNBQWMsQ0FBQyxhQUFhLENBQUMsV0FBVyxFQUFFLFFBQVEsQ0FBQyxDQUFDLEtBQUssQ0FBQztTQUNsRTtRQUFDLFdBQU07WUFDTiw0RUFBNEU7WUFDNUUsNkVBQTZFO1lBQzdFLDZCQUE2QjtZQUM3QixPQUFPLElBQUksQ0FBQztTQUNiO0lBQ0gsQ0FBQztJQVhELGtEQVdDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB0eXBlIHtUbXBsQXN0Tm9kZX0gZnJvbSAnQGFuZ3VsYXIvY29tcGlsZXInO1xuXG4vKipcbiAqIFBhcnNlcyB0aGUgZ2l2ZW4gSFRNTCBjb250ZW50IHVzaW5nIHRoZSBBbmd1bGFyIGNvbXBpbGVyLiBJbiBjYXNlIHRoZSBwYXJzaW5nXG4gKiBmYWlscywgbnVsbCBpcyBiZWluZyByZXR1cm5lZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHBhcnNlSHRtbEdyYWNlZnVsbHkoXG4gICAgaHRtbENvbnRlbnQ6IHN0cmluZywgZmlsZVBhdGg6IHN0cmluZyxcbiAgICBjb21waWxlck1vZHVsZTogdHlwZW9mIGltcG9ydCgnQGFuZ3VsYXIvY29tcGlsZXInKSk6IFRtcGxBc3ROb2RlW118bnVsbCB7XG4gIHRyeSB7XG4gICAgcmV0dXJuIGNvbXBpbGVyTW9kdWxlLnBhcnNlVGVtcGxhdGUoaHRtbENvbnRlbnQsIGZpbGVQYXRoKS5ub2RlcztcbiAgfSBjYXRjaCB7XG4gICAgLy8gRG8gbm90aGluZyBpZiB0aGUgdGVtcGxhdGUgY291bGRuJ3QgYmUgcGFyc2VkLiBXZSBkb24ndCB3YW50IHRvIHRocm93IGFueVxuICAgIC8vIGV4Y2VwdGlvbiBpZiBhIHRlbXBsYXRlIGlzIHN5bnRhY3RpY2FsbHkgbm90IHZhbGlkLiBlLmcuIHRlbXBsYXRlIGNvdWxkIGJlXG4gICAgLy8gdXNpbmcgcHJlcHJvY2Vzc29yIHN5bnRheC5cbiAgICByZXR1cm4gbnVsbDtcbiAgfVxufVxuIl19

package/schematics/utils/template_ast_visitor.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/core/schematics/utils/template_ast_visitor" />
+import type { TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstBoundText, TmplAstContent, TmplAstElement, TmplAstIcu, TmplAstNode, TmplAstRecursiveVisitor, TmplAstReference, TmplAstTemplate, TmplAstText, TmplAstTextAttribute, TmplAstVariable } from '@angular/compiler';
+/**
+ * A base class that can be used to implement a Render3 Template AST visitor.
+ * This class is used instead of the `NullVisitor` found within the `@angular/compiler` because
+ * the `NullVisitor` requires a deep import which is no longer supported with the ESM bundled
+ * packages as of v13.
+ * Schematics are also currently required to be CommonJS to support execution within the Angular
+ * CLI. As a result, the ESM `@angular/compiler` package must be loaded via a native dynamic import.
+ * Using a dynamic import makes classes extending from classes present in `@angular/compiler`
+ * complicated due to the class not being present at module evaluation time. The classes using a
+ * base class found within `@angular/compiler` must be wrapped in a factory to allow the class value
+ * to be accessible at runtime after the dynamic import has completed. This class implements the
+ * interface of the `TmplAstRecursiveVisitor` class (but does not extend) as the
+ * `TmplAstRecursiveVisitor` as an interface provides the required set of visit methods. The base
+ * interface `Visitor<T>` is not exported.
+ */
+export declare class TemplateAstVisitor implements TmplAstRecursiveVisitor {
+    protected readonly compilerModule: typeof import('@angular/compiler');
+    /**
+     * Creates a new Render3 Template AST visitor using an instance of the `@angular/compiler`
+     * package. Passing in the compiler is required due to the need to dynamically import the
+     * ESM `@angular/compiler` into a CommonJS schematic.
+     *
+     * @param compilerModule The compiler instance that should be used within the visitor.
+     */
+    constructor(compilerModule: typeof import('@angular/compiler'));
+    visitElement(element: TmplAstElement): void;
+    visitTemplate(template: TmplAstTemplate): void;
+    visitContent(content: TmplAstContent): void;
+    visitVariable(variable: TmplAstVariable): void;
+    visitReference(reference: TmplAstReference): void;
+    visitTextAttribute(attribute: TmplAstTextAttribute): void;
+    visitBoundAttribute(attribute: TmplAstBoundAttribute): void;
+    visitBoundEvent(attribute: TmplAstBoundEvent): void;
+    visitText(text: TmplAstText): void;
+    visitBoundText(text: TmplAstBoundText): void;
+    visitIcu(icu: TmplAstIcu): void;
+    /**
+     * Visits all the provided nodes in order using this Visitor's visit methods.
+     * This is a simplified variant of the `visitAll` function found inside of (but not
+     * exported from) the `@angular/compiler` that does not support returning a value
+     * since the migrations do not directly transform the nodes.
+     *
+     * @param nodes An iterable of nodes to visit using this visitor.
+     */
+    visitAll(nodes: Iterable<TmplAstNode>): void;
+}

package/schematics/utils/template_ast_visitor.js

@@ -0,0 +1,73 @@
+/**
+ * @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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/core/schematics/utils/template_ast_visitor", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TemplateAstVisitor = void 0;
+    /**
+     * A base class that can be used to implement a Render3 Template AST visitor.
+     * This class is used instead of the `NullVisitor` found within the `@angular/compiler` because
+     * the `NullVisitor` requires a deep import which is no longer supported with the ESM bundled
+     * packages as of v13.
+     * Schematics are also currently required to be CommonJS to support execution within the Angular
+     * CLI. As a result, the ESM `@angular/compiler` package must be loaded via a native dynamic import.
+     * Using a dynamic import makes classes extending from classes present in `@angular/compiler`
+     * complicated due to the class not being present at module evaluation time. The classes using a
+     * base class found within `@angular/compiler` must be wrapped in a factory to allow the class value
+     * to be accessible at runtime after the dynamic import has completed. This class implements the
+     * interface of the `TmplAstRecursiveVisitor` class (but does not extend) as the
+     * `TmplAstRecursiveVisitor` as an interface provides the required set of visit methods. The base
+     * interface `Visitor<T>` is not exported.
+     */
+    class TemplateAstVisitor {
+        /**
+         * Creates a new Render3 Template AST visitor using an instance of the `@angular/compiler`
+         * package. Passing in the compiler is required due to the need to dynamically import the
+         * ESM `@angular/compiler` into a CommonJS schematic.
+         *
+         * @param compilerModule The compiler instance that should be used within the visitor.
+         */
+        constructor(compilerModule) {
+            this.compilerModule = compilerModule;
+        }
+        visitElement(element) { }
+        visitTemplate(template) { }
+        visitContent(content) { }
+        visitVariable(variable) { }
+        visitReference(reference) { }
+        visitTextAttribute(attribute) { }
+        visitBoundAttribute(attribute) { }
+        visitBoundEvent(attribute) { }
+        visitText(text) { }
+        visitBoundText(text) { }
+        visitIcu(icu) { }
+        /**
+         * Visits all the provided nodes in order using this Visitor's visit methods.
+         * This is a simplified variant of the `visitAll` function found inside of (but not
+         * exported from) the `@angular/compiler` that does not support returning a value
+         * since the migrations do not directly transform the nodes.
+         *
+         * @param nodes An iterable of nodes to visit using this visitor.
+         */
+        visitAll(nodes) {
+            for (const node of nodes) {
+                node.visit(this);
+            }
+        }
+    }
+    exports.TemplateAstVisitor = TemplateAstVisitor;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/utils/typescript/class_declaration.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/core/schematics/utils/typescript/class_declaration" />
-import * as ts from 'typescript';
+import ts from 'typescript';
 /** Determines the base type identifiers of a specified class declaration. */
 export declare function getBaseTypeIdentifiers(node: ts.ClassDeclaration): ts.Identifier[] | null;
 /** Gets the first found parent class declaration of a given node. */

package/schematics/utils/typescript/class_declaration.js

@@ -5,6 +5,9 @@
  * 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
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
@@ -17,22 +20,22 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.hasExplicitConstructor = exports.findParentClassDeclaration = exports.getBaseTypeIdentifiers = void 0;
-    const ts = require("typescript");
+    const typescript_1 = __importDefault(require("typescript"));
     /** Determines the base type identifiers of a specified class declaration. */
     function getBaseTypeIdentifiers(node) {
         if (!node.heritageClauses) {
             return null;
         }
-        return node.heritageClauses.filter(clause => clause.token === ts.SyntaxKind.ExtendsKeyword)
+        return node.heritageClauses.filter(clause => clause.token === typescript_1.default.SyntaxKind.ExtendsKeyword)
             .reduce((types, clause) => types.concat(clause.types), [])
             .map(typeExpression => typeExpression.expression)
-            .filter(ts.isIdentifier);
+            .filter(typescript_1.default.isIdentifier);
     }
     exports.getBaseTypeIdentifiers = getBaseTypeIdentifiers;
     /** Gets the first found parent class declaration of a given node. */
     function findParentClassDeclaration(node) {
-        while (!ts.isClassDeclaration(node)) {
-            if (ts.isSourceFile(node)) {
+        while (!typescript_1.default.isClassDeclaration(node)) {
+            if (typescript_1.default.isSourceFile(node)) {
                 return null;
             }
             node = node.parent;
@@ -42,8 +45,8 @@
     exports.findParentClassDeclaration = findParentClassDeclaration;
     /** Checks whether the given class declaration has an explicit constructor or not. */
     function hasExplicitConstructor(node) {
-        return node.members.some(ts.isConstructorDeclaration);
+        return node.members.some(typescript_1.default.isConstructorDeclaration);
     }
     exports.hasExplicitConstructor = hasExplicitConstructor;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/utils/typescript/compiler_host.d.ts

@@ -7,7 +7,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Tree } from '@angular-devkit/schematics';
-import * as ts from 'typescript';
+import ts from 'typescript';
 export declare type FakeReadFileFn = (fileName: string) => string | undefined;
 /**
  * Creates a TypeScript program instance for a TypeScript project within

package/schematics/utils/typescript/compiler_host.js

@@ -1,3 +1,6 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
@@ -11,7 +14,7 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.canMigrateFile = exports.createMigrationCompilerHost = exports.createMigrationProgram = void 0;
     const path_1 = require("path");
-    const ts = require("typescript");
+    const typescript_1 = __importDefault(require("typescript"));
     const parse_tsconfig_1 = require("@angular/core/schematics/utils/typescript/parse_tsconfig");
     /**
      * Creates a TypeScript program instance for a TypeScript project within
@@ -30,12 +33,12 @@
         tsconfigPath = (0, path_1.resolve)(basePath, tsconfigPath);
         const parsed = (0, parse_tsconfig_1.parseTsconfigFile)(tsconfigPath, (0, path_1.dirname)(tsconfigPath));
         const host = createMigrationCompilerHost(tree, parsed.options, basePath, fakeFileRead);
-        const program = ts.createProgram(parsed.fileNames.concat(additionalFiles || []), parsed.options, host);
+        const program = typescript_1.default.createProgram(parsed.fileNames.concat(additionalFiles || []), parsed.options, host);
         return { parsed, host, program };
     }
     exports.createMigrationProgram = createMigrationProgram;
     function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
-        const host = ts.createCompilerHost(options, true);
+        const host = typescript_1.default.createCompilerHost(options, true);
         const defaultReadFile = host.readFile;
         // We need to overwrite the host "readFile" method, as we want the TypeScript
         // program to be based on the file contents in the virtual file tree. Otherwise
@@ -79,4 +82,4 @@
     }
     exports.canMigrateFile = canMigrateFile;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler_host.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/utils/typescript/compiler_host.ts"],"names":[],"mappings":";;;;;;;;;;;;IAQA,+BAAgD;IAChD,iCAAiC;IACjC,6FAAmD;IAInD;;;;;;;;;OASG;IACH,SAAgB,sBAAsB,CAClC,IAAU,EAAE,YAAoB,EAAE,QAAgB,EAAE,YAA6B,EACjF,eAA0B;QAC5B,wFAAwF;QACxF,2FAA2F;QAC3F,gFAAgF;QAChF,YAAY,GAAG,IAAA,cAAO,EAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAA,kCAAiB,EAAC,YAAY,EAAE,IAAA,cAAO,EAAC,YAAY,CAAC,CAAC,CAAC;QACtE,MAAM,IAAI,GAAG,2BAA2B,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;QACvF,MAAM,OAAO,GACT,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC3F,OAAO,EAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAC,CAAC;IACjC,CAAC;IAZD,wDAYC;IAED,SAAgB,2BAA2B,CACvC,IAAU,EAAE,OAA2B,EAAE,QAAgB,EACzD,QAAyB;QAC3B,MAAM,IAAI,GAAG,EAAE,CAAC,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAClD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC;QAEtC,6EAA6E;QAC7E,+EAA+E;QAC/E,uEAAuE;QACvE,gBAAgB;QAChB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,EAAE;;YACzB,MAAM,gBAAgB,GAAG,IAAA,eAAQ,EAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YACtD,IAAI,MAAM,GAAqB,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAG,gBAAgB,CAAC,CAAC;YAE5D,IAAI,MAAM,KAAK,SAAS,EAAE;gBACxB,+EAA+E;gBAC/E,mFAAmF;gBACnF,MAAM,GAAG,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;oBACtC,MAAA,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,0CAAE,QAAQ,EAAE,CAAC;aACtF;YAED,2EAA2E;YAC3E,uCAAuC;YACvC,qDAAqD;YACrD,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC5D,CAAC,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IA5BD,kEA4BC;IAED;;;;;OAKG;IACH,SAAgB,cAAc,CAC1B,QAAgB,EAAE,UAAyB,EAAE,OAAmB;QAClE,sEAAsE;QACtE,IAAI,UAAU,CAAC,iBAAiB,IAAI,OAAO,CAAC,+BAA+B,CAAC,UAAU,CAAC,EAAE;YACvF,OAAO,KAAK,CAAC;SACd;QAED,iGAAiG;QACjG,2FAA2F;QAC3F,+FAA+F;QAC/F,wFAAwF;QACxF,qJAAqJ;QACrJ,OAAO,CAAC,IAAA,eAAQ,EAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IACnE,CAAC;IAbD,wCAaC","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 */\nimport {Tree} from '@angular-devkit/schematics';\nimport {dirname, relative, resolve} from 'path';\nimport * as ts from 'typescript';\nimport {parseTsconfigFile} from './parse_tsconfig';\n\nexport type FakeReadFileFn = (fileName: string) => string|undefined;\n\n/**\n * Creates a TypeScript program instance for a TypeScript project within\n * the virtual file system tree.\n * @param tree Virtual file system tree that contains the source files.\n * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.\n * @param basePath Base path for the virtual file system tree.\n * @param fakeFileRead Optional file reader function. Can be used to overwrite files in\n *   the TypeScript program, or to add in-memory files (e.g. to add global types).\n * @param additionalFiles Additional file paths that should be added to the program.\n */\nexport function createMigrationProgram(\n    tree: Tree, tsconfigPath: string, basePath: string, fakeFileRead?: FakeReadFileFn,\n    additionalFiles?: string[]) {\n  // Resolve the tsconfig path to an absolute path. This is needed as TypeScript otherwise\n  // is not able to resolve root directories in the given tsconfig. More details can be found\n  // in the following issue: https://github.com/microsoft/TypeScript/issues/37731.\n  tsconfigPath = resolve(basePath, tsconfigPath);\n  const parsed = parseTsconfigFile(tsconfigPath, dirname(tsconfigPath));\n  const host = createMigrationCompilerHost(tree, parsed.options, basePath, fakeFileRead);\n  const program =\n      ts.createProgram(parsed.fileNames.concat(additionalFiles || []), parsed.options, host);\n  return {parsed, host, program};\n}\n\nexport function createMigrationCompilerHost(\n    tree: Tree, options: ts.CompilerOptions, basePath: string,\n    fakeRead?: FakeReadFileFn): ts.CompilerHost {\n  const host = ts.createCompilerHost(options, true);\n  const defaultReadFile = host.readFile;\n\n  // We need to overwrite the host \"readFile\" method, as we want the TypeScript\n  // program to be based on the file contents in the virtual file tree. Otherwise\n  // if we run multiple migrations we might have intersecting changes and\n  // source files.\n  host.readFile = fileName => {\n    const treeRelativePath = relative(basePath, fileName);\n    let result: string|undefined = fakeRead?.(treeRelativePath);\n\n    if (result === undefined) {\n      // If the relative path resolved to somewhere outside of the tree, fall back to\n      // TypeScript's default file reading function since the `tree` will throw an error.\n      result = treeRelativePath.startsWith('..') ? defaultReadFile.call(host, fileName) :\n                                                   tree.read(treeRelativePath)?.toString();\n    }\n\n    // Strip BOM as otherwise TSC methods (Ex: getWidth) will return an offset,\n    // which breaks the CLI UpdateRecorder.\n    // See: https://github.com/angular/angular/pull/30719\n    return result ? result.replace(/^\\uFEFF/, '') : undefined;\n  };\n\n  return host;\n}\n\n/**\n * Checks whether a file can be migrate by our automated migrations.\n * @param basePath Absolute path to the project.\n * @param sourceFile File being checked.\n * @param program Program that includes the source file.\n */\nexport function canMigrateFile(\n    basePath: string, sourceFile: ts.SourceFile, program: ts.Program): boolean {\n  // We shouldn't migrate .d.ts files or files from an external library.\n  if (sourceFile.isDeclarationFile || program.isSourceFileFromExternalLibrary(sourceFile)) {\n    return false;\n  }\n\n  // Our migrations are set up to create a `Program` from the project's tsconfig and to migrate all\n  // the files within the program. This can include files that are outside of the Angular CLI\n  // project. We can't migrate files outside of the project, because our file system interactions\n  // go through the CLI's `Tree` which assumes that all files are within the project. See:\n  // https://github.com/angular/angular-cli/blob/0b0961c9c233a825b6e4bb59ab7f0790f9b14676/packages/angular_devkit/schematics/src/tree/host-tree.ts#L131\n  return !relative(basePath, sourceFile.fileName).startsWith('..');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler_host.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/utils/typescript/compiler_host.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;IAQA,+BAAgD;IAChD,4DAA4B;IAC5B,6FAAmD;IAInD;;;;;;;;;OASG;IACH,SAAgB,sBAAsB,CAClC,IAAU,EAAE,YAAoB,EAAE,QAAgB,EAAE,YAA6B,EACjF,eAA0B;QAC5B,wFAAwF;QACxF,2FAA2F;QAC3F,gFAAgF;QAChF,YAAY,GAAG,IAAA,cAAO,EAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAA,kCAAiB,EAAC,YAAY,EAAE,IAAA,cAAO,EAAC,YAAY,CAAC,CAAC,CAAC;QACtE,MAAM,IAAI,GAAG,2BAA2B,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;QACvF,MAAM,OAAO,GACT,oBAAE,CAAC,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC3F,OAAO,EAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAC,CAAC;IACjC,CAAC;IAZD,wDAYC;IAED,SAAgB,2BAA2B,CACvC,IAAU,EAAE,OAA2B,EAAE,QAAgB,EACzD,QAAyB;QAC3B,MAAM,IAAI,GAAG,oBAAE,CAAC,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAClD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC;QAEtC,6EAA6E;QAC7E,+EAA+E;QAC/E,uEAAuE;QACvE,gBAAgB;QAChB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,EAAE;;YACzB,MAAM,gBAAgB,GAAG,IAAA,eAAQ,EAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YACtD,IAAI,MAAM,GAAqB,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAG,gBAAgB,CAAC,CAAC;YAE5D,IAAI,MAAM,KAAK,SAAS,EAAE;gBACxB,+EAA+E;gBAC/E,mFAAmF;gBACnF,MAAM,GAAG,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;oBACtC,MAAA,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,0CAAE,QAAQ,EAAE,CAAC;aACtF;YAED,2EAA2E;YAC3E,uCAAuC;YACvC,qDAAqD;YACrD,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC5D,CAAC,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IA5BD,kEA4BC;IAED;;;;;OAKG;IACH,SAAgB,cAAc,CAC1B,QAAgB,EAAE,UAAyB,EAAE,OAAmB;QAClE,sEAAsE;QACtE,IAAI,UAAU,CAAC,iBAAiB,IAAI,OAAO,CAAC,+BAA+B,CAAC,UAAU,CAAC,EAAE;YACvF,OAAO,KAAK,CAAC;SACd;QAED,iGAAiG;QACjG,2FAA2F;QAC3F,+FAA+F;QAC/F,wFAAwF;QACxF,qJAAqJ;QACrJ,OAAO,CAAC,IAAA,eAAQ,EAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IACnE,CAAC;IAbD,wCAaC","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 */\nimport {Tree} from '@angular-devkit/schematics';\nimport {dirname, relative, resolve} from 'path';\nimport ts from 'typescript';\nimport {parseTsconfigFile} from './parse_tsconfig';\n\nexport type FakeReadFileFn = (fileName: string) => string|undefined;\n\n/**\n * Creates a TypeScript program instance for a TypeScript project within\n * the virtual file system tree.\n * @param tree Virtual file system tree that contains the source files.\n * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.\n * @param basePath Base path for the virtual file system tree.\n * @param fakeFileRead Optional file reader function. Can be used to overwrite files in\n *   the TypeScript program, or to add in-memory files (e.g. to add global types).\n * @param additionalFiles Additional file paths that should be added to the program.\n */\nexport function createMigrationProgram(\n    tree: Tree, tsconfigPath: string, basePath: string, fakeFileRead?: FakeReadFileFn,\n    additionalFiles?: string[]) {\n  // Resolve the tsconfig path to an absolute path. This is needed as TypeScript otherwise\n  // is not able to resolve root directories in the given tsconfig. More details can be found\n  // in the following issue: https://github.com/microsoft/TypeScript/issues/37731.\n  tsconfigPath = resolve(basePath, tsconfigPath);\n  const parsed = parseTsconfigFile(tsconfigPath, dirname(tsconfigPath));\n  const host = createMigrationCompilerHost(tree, parsed.options, basePath, fakeFileRead);\n  const program =\n      ts.createProgram(parsed.fileNames.concat(additionalFiles || []), parsed.options, host);\n  return {parsed, host, program};\n}\n\nexport function createMigrationCompilerHost(\n    tree: Tree, options: ts.CompilerOptions, basePath: string,\n    fakeRead?: FakeReadFileFn): ts.CompilerHost {\n  const host = ts.createCompilerHost(options, true);\n  const defaultReadFile = host.readFile;\n\n  // We need to overwrite the host \"readFile\" method, as we want the TypeScript\n  // program to be based on the file contents in the virtual file tree. Otherwise\n  // if we run multiple migrations we might have intersecting changes and\n  // source files.\n  host.readFile = fileName => {\n    const treeRelativePath = relative(basePath, fileName);\n    let result: string|undefined = fakeRead?.(treeRelativePath);\n\n    if (result === undefined) {\n      // If the relative path resolved to somewhere outside of the tree, fall back to\n      // TypeScript's default file reading function since the `tree` will throw an error.\n      result = treeRelativePath.startsWith('..') ? defaultReadFile.call(host, fileName) :\n                                                   tree.read(treeRelativePath)?.toString();\n    }\n\n    // Strip BOM as otherwise TSC methods (Ex: getWidth) will return an offset,\n    // which breaks the CLI UpdateRecorder.\n    // See: https://github.com/angular/angular/pull/30719\n    return result ? result.replace(/^\\uFEFF/, '') : undefined;\n  };\n\n  return host;\n}\n\n/**\n * Checks whether a file can be migrate by our automated migrations.\n * @param basePath Absolute path to the project.\n * @param sourceFile File being checked.\n * @param program Program that includes the source file.\n */\nexport function canMigrateFile(\n    basePath: string, sourceFile: ts.SourceFile, program: ts.Program): boolean {\n  // We shouldn't migrate .d.ts files or files from an external library.\n  if (sourceFile.isDeclarationFile || program.isSourceFileFromExternalLibrary(sourceFile)) {\n    return false;\n  }\n\n  // Our migrations are set up to create a `Program` from the project's tsconfig and to migrate all\n  // the files within the program. This can include files that are outside of the Angular CLI\n  // project. We can't migrate files outside of the project, because our file system interactions\n  // go through the CLI's `Tree` which assumes that all files are within the project. See:\n  // https://github.com/angular/angular-cli/blob/0b0961c9c233a825b6e4bb59ab7f0790f9b14676/packages/angular_devkit/schematics/src/tree/host-tree.ts#L131\n  return !relative(basePath, sourceFile.fileName).startsWith('..');\n}\n"]}

package/schematics/utils/typescript/decorators.d.ts

@@ -6,6 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/core/schematics/utils/typescript/decorators" />
-import * as ts from 'typescript';
+import ts from 'typescript';
 import { Import } from './imports';
 export declare function getCallDecoratorImport(typeChecker: ts.TypeChecker, decorator: ts.Decorator): Import | null;

package/schematics/utils/typescript/decorators.js

@@ -5,6 +5,9 @@
  * 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
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
@@ -17,13 +20,13 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.getCallDecoratorImport = void 0;
-    const ts = require("typescript");
+    const typescript_1 = __importDefault(require("typescript"));
     const imports_1 = require("@angular/core/schematics/utils/typescript/imports");
     function getCallDecoratorImport(typeChecker, decorator) {
         // Note that this does not cover the edge case where decorators are called from
         // a namespace import: e.g. "@core.Component()". This is not handled by Ngtsc either.
-        if (!ts.isCallExpression(decorator.expression) ||
-            !ts.isIdentifier(decorator.expression.expression)) {
+        if (!typescript_1.default.isCallExpression(decorator.expression) ||
+            !typescript_1.default.isIdentifier(decorator.expression.expression)) {
             return null;
         }
         const identifier = decorator.expression.expression;
@@ -31,4 +34,4 @@
     }
     exports.getCallDecoratorImport = getCallDecoratorImport;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc2NoZW1hdGljcy91dGlscy90eXBlc2NyaXB0L2RlY29yYXRvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7O0lBRUgsaUNBQWlDO0lBRWpDLCtFQUF3RDtJQUV4RCxTQUFnQixzQkFBc0IsQ0FDbEMsV0FBMkIsRUFBRSxTQUF1QjtRQUN0RCwrRUFBK0U7UUFDL0UscUZBQXFGO1FBQ3JGLElBQUksQ0FBQyxFQUFFLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQztZQUMxQyxDQUFDLEVBQUUsQ0FBQyxZQUFZLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsRUFBRTtZQUNyRCxPQUFPLElBQUksQ0FBQztTQUNiO1FBRUQsTUFBTSxVQUFVLEdBQUcsU0FBUyxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUM7UUFDbkQsT0FBTyxJQUFBLCtCQUFxQixFQUFDLFdBQVcsRUFBRSxVQUFVLENBQUMsQ0FBQztJQUN4RCxDQUFDO0lBWEQsd0RBV0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0ICogYXMgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5cbmltcG9ydCB7Z2V0SW1wb3J0T2ZJZGVudGlmaWVyLCBJbXBvcnR9IGZyb20gJy4vaW1wb3J0cyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRDYWxsRGVjb3JhdG9ySW1wb3J0KFxuICAgIHR5cGVDaGVja2VyOiB0cy5UeXBlQ2hlY2tlciwgZGVjb3JhdG9yOiB0cy5EZWNvcmF0b3IpOiBJbXBvcnR8bnVsbCB7XG4gIC8vIE5vdGUgdGhhdCB0aGlzIGRvZXMgbm90IGNvdmVyIHRoZSBlZGdlIGNhc2Ugd2hlcmUgZGVjb3JhdG9ycyBhcmUgY2FsbGVkIGZyb21cbiAgLy8gYSBuYW1lc3BhY2UgaW1wb3J0OiBlLmcuIFwiQGNvcmUuQ29tcG9uZW50KClcIi4gVGhpcyBpcyBub3QgaGFuZGxlZCBieSBOZ3RzYyBlaXRoZXIuXG4gIGlmICghdHMuaXNDYWxsRXhwcmVzc2lvbihkZWNvcmF0b3IuZXhwcmVzc2lvbikgfHxcbiAgICAgICF0cy5pc0lkZW50aWZpZXIoZGVjb3JhdG9yLmV4cHJlc3Npb24uZXhwcmVzc2lvbikpIHtcbiAgICByZXR1cm4gbnVsbDtcbiAgfVxuXG4gIGNvbnN0IGlkZW50aWZpZXIgPSBkZWNvcmF0b3IuZXhwcmVzc2lvbi5leHByZXNzaW9uO1xuICByZXR1cm4gZ2V0SW1wb3J0T2ZJZGVudGlmaWVyKHR5cGVDaGVja2VyLCBpZGVudGlmaWVyKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc2NoZW1hdGljcy91dGlscy90eXBlc2NyaXB0L2RlY29yYXRvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7Ozs7O0lBRUgsNERBQTRCO0lBRTVCLCtFQUF3RDtJQUV4RCxTQUFnQixzQkFBc0IsQ0FDbEMsV0FBMkIsRUFBRSxTQUF1QjtRQUN0RCwrRUFBK0U7UUFDL0UscUZBQXFGO1FBQ3JGLElBQUksQ0FBQyxvQkFBRSxDQUFDLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUM7WUFDMUMsQ0FBQyxvQkFBRSxDQUFDLFlBQVksQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxFQUFFO1lBQ3JELE9BQU8sSUFBSSxDQUFDO1NBQ2I7UUFFRCxNQUFNLFVBQVUsR0FBRyxTQUFTLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQztRQUNuRCxPQUFPLElBQUEsK0JBQXFCLEVBQUMsV0FBVyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFYRCx3REFXQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5cbmltcG9ydCB7Z2V0SW1wb3J0T2ZJZGVudGlmaWVyLCBJbXBvcnR9IGZyb20gJy4vaW1wb3J0cyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRDYWxsRGVjb3JhdG9ySW1wb3J0KFxuICAgIHR5cGVDaGVja2VyOiB0cy5UeXBlQ2hlY2tlciwgZGVjb3JhdG9yOiB0cy5EZWNvcmF0b3IpOiBJbXBvcnR8bnVsbCB7XG4gIC8vIE5vdGUgdGhhdCB0aGlzIGRvZXMgbm90IGNvdmVyIHRoZSBlZGdlIGNhc2Ugd2hlcmUgZGVjb3JhdG9ycyBhcmUgY2FsbGVkIGZyb21cbiAgLy8gYSBuYW1lc3BhY2UgaW1wb3J0OiBlLmcuIFwiQGNvcmUuQ29tcG9uZW50KClcIi4gVGhpcyBpcyBub3QgaGFuZGxlZCBieSBOZ3RzYyBlaXRoZXIuXG4gIGlmICghdHMuaXNDYWxsRXhwcmVzc2lvbihkZWNvcmF0b3IuZXhwcmVzc2lvbikgfHxcbiAgICAgICF0cy5pc0lkZW50aWZpZXIoZGVjb3JhdG9yLmV4cHJlc3Npb24uZXhwcmVzc2lvbikpIHtcbiAgICByZXR1cm4gbnVsbDtcbiAgfVxuXG4gIGNvbnN0IGlkZW50aWZpZXIgPSBkZWNvcmF0b3IuZXhwcmVzc2lvbi5leHByZXNzaW9uO1xuICByZXR1cm4gZ2V0SW1wb3J0T2ZJZGVudGlmaWVyKHR5cGVDaGVja2VyLCBpZGVudGlmaWVyKTtcbn1cbiJdfQ==

package/schematics/utils/typescript/find_base_classes.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/core/schematics/utils/typescript/find_base_classes" />
-import * as ts from 'typescript';
+import ts from 'typescript';
 /** Gets all base class declarations of the specified class declaration. */
 export declare function findBaseClassDeclarations(node: ts.ClassDeclaration, typeChecker: ts.TypeChecker): {
     identifier: ts.Identifier;

package/schematics/utils/typescript/find_base_classes.js

@@ -5,6 +5,9 @@
  * 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
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
@@ -17,7 +20,7 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.findBaseClassDeclarations = void 0;
-    const ts = require("typescript");
+    const typescript_1 = __importDefault(require("typescript"));
     const class_declaration_1 = require("@angular/core/schematics/utils/typescript/class_declaration");
     /** Gets all base class declarations of the specified class declaration. */
     function findBaseClassDeclarations(node, typeChecker) {
@@ -31,7 +34,7 @@
             const symbol = typeChecker.getTypeAtLocation(baseTypes[0]).getSymbol();
             // Note: `ts.Symbol#valueDeclaration` can be undefined. TypeScript has an incorrect type
             // for this: https://github.com/microsoft/TypeScript/issues/24706.
-            if (!symbol || !symbol.valueDeclaration || !ts.isClassDeclaration(symbol.valueDeclaration)) {
+            if (!symbol || !symbol.valueDeclaration || !typescript_1.default.isClassDeclaration(symbol.valueDeclaration)) {
                 break;
             }
             result.push({ identifier: baseTypes[0], node: symbol.valueDeclaration });
@@ -41,4 +44,4 @@
     }
     exports.findBaseClassDeclarations = findBaseClassDeclarations;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/utils/typescript/functions.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/core/schematics/utils/typescript/functions" />
-import * as ts from 'typescript';
+import ts from 'typescript';
 /** Checks whether a given node is a function like declaration. */
 export declare function isFunctionLikeDeclaration(node: ts.Node): node is ts.FunctionLikeDeclaration;
 /**