@angular/core 14.0.0-next.1 → 14.0.0-next.12

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@angular/core",
-  "version": "14.0.0-next.1",
+  "version": "14.0.0-next.12",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",
   "engines": {
-    "node": "^12.20.0 || ^14.15.0 || >=16.10.0"
+    "node": "^14.15.0 || >=16.10.0"
   },
   "exports": {
     "./schematics/*": {

package/schematics/migrations/entry-components/util.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
                     const entryComponentsProp = literal.properties.find(property => typescript_1.default.isPropertyAssignment(property) && typescript_1.default.isIdentifier(property.name) &&
                         property.name.text === 'entryComponents');
                     if (entryComponentsProp) {
-                        const replacementNode = typescript_1.default.updateObjectLiteral(literal, literal.properties.filter(prop => prop !== entryComponentsProp));
+                        const replacementNode = typescript_1.default.factory.updateObjectLiteralExpression(literal, literal.properties.filter(prop => prop !== entryComponentsProp));
                         results.push({
                             start: literal.getStart(),
                             length: literal.getWidth(),
@@ -54,4 +54,4 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     }
     exports.migrateEntryComponentsUsages = migrateEntryComponentsUsages;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/path-match-type/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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/migrations/path-match-type" />
+import { Rule } from '@angular-devkit/schematics';
+/** Migration that adds explicit type to `Route`/`Routes` which use `patchMatch` */
+export default function (): Rule;

package/schematics/migrations/path-match-type/index.js

@@ -0,0 +1,95 @@
+/**
+ * @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
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/core/schematics/migrations/path-match-type", ["require", "exports", "@angular-devkit/schematics", "path", "typescript", "@angular/core/schematics/utils/project_tsconfig_paths", "@angular/core/schematics/utils/typescript/compiler_host", "@angular/core/schematics/migrations/path-match-type/transform"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular-devkit/schematics");
+    const path_1 = require("path");
+    const typescript_1 = __importDefault(require("typescript"));
+    const project_tsconfig_paths_1 = require("@angular/core/schematics/utils/project_tsconfig_paths");
+    const compiler_host_1 = require("@angular/core/schematics/utils/typescript/compiler_host");
+    const transform_1 = require("@angular/core/schematics/migrations/path-match-type/transform");
+    /** Migration that adds explicit type to `Route`/`Routes` which use `patchMatch` */
+    function default_1() {
+        return (tree) => __awaiter(this, void 0, void 0, function* () {
+            const { buildPaths, testPaths } = yield (0, project_tsconfig_paths_1.getProjectTsConfigPaths)(tree);
+            const basePath = process.cwd();
+            const allPaths = [...buildPaths, ...testPaths];
+            if (!allPaths.length) {
+                throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot perform pathMatch migration.');
+            }
+            for (const tsconfigPath of allPaths) {
+                runMigration(tree, tsconfigPath, basePath);
+            }
+        });
+    }
+    exports.default = default_1;
+    function runMigration(tree, tsconfigPath, basePath) {
+        const { program } = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath);
+        const sourceFiles = program.getSourceFiles().filter(sourceFile => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program));
+        const updateRecorders = new Map();
+        const transform = new transform_1.PathMatchTypeTransform(getUpdateRecorder);
+        // Migrate all source files in the project.
+        transform.migrate(sourceFiles);
+        // Record the changes collected in the import manager.
+        transform.recordChanges();
+        // Walk through each update recorder and commit the update. We need to commit the
+        // updates in batches per source file as there can be only one recorder per source
+        // file in order to avoid shifted character offsets.
+        updateRecorders.forEach(recorder => recorder.commitUpdate());
+        /** Gets the update recorder for the specified source file. */
+        function getUpdateRecorder(sourceFile) {
+            if (updateRecorders.has(sourceFile)) {
+                return updateRecorders.get(sourceFile);
+            }
+            const printer = typescript_1.default.createPrinter();
+            const treeRecorder = tree.beginUpdate((0, path_1.relative)(basePath, sourceFile.fileName));
+            const recorder = {
+                updateNode(oldExpr, newExpr) {
+                    treeRecorder.insertRight(oldExpr.name.getEnd(), ': ' + printer.printNode(typescript_1.default.EmitHint.Unspecified, newExpr.type, sourceFile));
+                },
+                addNewImport(start, importText) {
+                    // New imports should be inserted at the left while decorators should be inserted
+                    // at the right in order to ensure that imports are inserted before the decorator
+                    // if the start position of import and decorator is the source file start.
+                    treeRecorder.insertLeft(start, importText);
+                },
+                updateExistingImport(namedBindings, newNamedBindings) {
+                    treeRecorder.remove(namedBindings.getStart(), namedBindings.getWidth());
+                    treeRecorder.insertRight(namedBindings.getStart(), newNamedBindings);
+                },
+                commitUpdate() {
+                    tree.commitUpdate(treeRecorder);
+                }
+            };
+            updateRecorders.set(sourceFile, recorder);
+            return recorder;
+        }
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/path-match-type/transform.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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/migrations/path-match-type/transform" />
+import ts from 'typescript';
+import { UpdateRecorder } from './update_recorder';
+export declare class PathMatchTypeTransform {
+    private getUpdateRecorder;
+    private printer;
+    private importManager;
+    constructor(getUpdateRecorder: (sf: ts.SourceFile) => UpdateRecorder);
+    migrate(sourceFiles: ts.SourceFile[]): void;
+    /** Records all changes that were made in the import manager. */
+    recordChanges(): void;
+}

package/schematics/migrations/path-match-type/transform.js

@@ -0,0 +1,48 @@
+/**
+ * @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
+ */
+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);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/core/schematics/migrations/path-match-type/transform", ["require", "exports", "typescript", "@angular/core/schematics/utils/import_manager", "@angular/core/schematics/migrations/path-match-type/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PathMatchTypeTransform = void 0;
+    const typescript_1 = __importDefault(require("typescript"));
+    const import_manager_1 = require("@angular/core/schematics/utils/import_manager");
+    const util_1 = require("@angular/core/schematics/migrations/path-match-type/util");
+    class PathMatchTypeTransform {
+        constructor(getUpdateRecorder) {
+            this.getUpdateRecorder = getUpdateRecorder;
+            this.printer = typescript_1.default.createPrinter();
+            this.importManager = new import_manager_1.ImportManager(this.getUpdateRecorder, this.printer);
+        }
+        migrate(sourceFiles) {
+            for (const sourceFile of sourceFiles) {
+                const toMigrate = (0, util_1.findExpressionsToMigrate)(sourceFile, this.importManager);
+                const recorder = this.getUpdateRecorder(sourceFile);
+                for (const [oldNode, newNode] of toMigrate) {
+                    recorder.updateNode(oldNode, newNode, sourceFile);
+                }
+            }
+        }
+        /** Records all changes that were made in the import manager. */
+        recordChanges() {
+            this.importManager.recordChanges();
+        }
+    }
+    exports.PathMatchTypeTransform = PathMatchTypeTransform;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/path-match-type/update_recorder.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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/migrations/path-match-type/update_recorder" />
+import ts from 'typescript';
+import { ImportManagerUpdateRecorder } from '../../utils/import_manager';
+/**
+ * Update recorder interface that is used to transform source files
+ * in a non-colliding way.
+ */
+export interface UpdateRecorder extends ImportManagerUpdateRecorder {
+    updateNode(oldNode: ts.VariableDeclaration, newNode: ts.VariableDeclaration, sourceFile: ts.SourceFile): void;
+    commitUpdate(): void;
+}

package/schematics/migrations/path-match-type/update_recorder.js

@@ -0,0 +1,20 @@
+/**
+ * @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/migrations/path-match-type/update_recorder", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlX3JlY29yZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zY2hlbWF0aWNzL21pZ3JhdGlvbnMvcGF0aC1tYXRjaC10eXBlL3VwZGF0ZV9yZWNvcmRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHRzIGZyb20gJ3R5cGVzY3JpcHQnO1xuXG5pbXBvcnQge0ltcG9ydE1hbmFnZXJVcGRhdGVSZWNvcmRlcn0gZnJvbSAnLi4vLi4vdXRpbHMvaW1wb3J0X21hbmFnZXInO1xuXG4vKipcbiAqIFVwZGF0ZSByZWNvcmRlciBpbnRlcmZhY2UgdGhhdCBpcyB1c2VkIHRvIHRyYW5zZm9ybSBzb3VyY2UgZmlsZXNcbiAqIGluIGEgbm9uLWNvbGxpZGluZyB3YXkuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVXBkYXRlUmVjb3JkZXIgZXh0ZW5kcyBJbXBvcnRNYW5hZ2VyVXBkYXRlUmVjb3JkZXIge1xuICB1cGRhdGVOb2RlKFxuICAgICAgb2xkTm9kZTogdHMuVmFyaWFibGVEZWNsYXJhdGlvbiwgbmV3Tm9kZTogdHMuVmFyaWFibGVEZWNsYXJhdGlvbixcbiAgICAgIHNvdXJjZUZpbGU6IHRzLlNvdXJjZUZpbGUpOiB2b2lkO1xuICBjb21taXRVcGRhdGUoKTogdm9pZDtcbn1cbiJdfQ==

package/schematics/migrations/path-match-type/util.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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/migrations/path-match-type/util" />
+import ts from 'typescript';
+import { ImportManager } from '../../utils/import_manager';
+export declare function findExpressionsToMigrate(sourceFile: ts.SourceFile, importManager: ImportManager): Map<ts.VariableDeclaration, ts.VariableDeclaration>;

package/schematics/migrations/path-match-type/util.js

@@ -0,0 +1,106 @@
+/**
+ * @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
+ */
+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);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/core/schematics/migrations/path-match-type/util", ["require", "exports", "typescript"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.findExpressionsToMigrate = void 0;
+    const typescript_1 = __importDefault(require("typescript"));
+    function findExpressionsToMigrate(sourceFile, importManager) {
+        const migratedNodesMap = new Map();
+        let _currentVariableDecl = null;
+        (() => {
+            sourceFile.forEachChild(function visitNode(node) {
+                if (typescript_1.default.isVariableDeclaration(node)) {
+                    _currentVariableDecl = node;
+                    node.forEachChild(visitNode);
+                    _currentVariableDecl = null;
+                }
+                if (isRouteOrRoutesVariableDeclaration(node)) {
+                    // The variable declaration is already explicitly typed as `Route` or `Routes` so it does
+                    // not need a migration.
+                    return;
+                }
+                else if (typescript_1.default.isObjectLiteralExpression(node)) {
+                    if (_currentVariableDecl !== null && _currentVariableDecl.type === undefined) {
+                        visitObjectLiteral(node);
+                    }
+                }
+                else {
+                    node.forEachChild(visitNode);
+                }
+            });
+            function visitObjectLiteral(obj) {
+                const hasPathMatch = obj.properties.some(p => isPropertyWithName(p, 'pathMatch'));
+                const hasPath = obj.properties.some(p => isPropertyWithName(p, 'path'));
+                const childrenProperty = obj.properties.find(p => isPropertyWithName(p, 'children'));
+                // The object must have _both_ pathMatch _and_ path for us to be reasonably sure that it's
+                // a `Route` definition.
+                if (hasPath && hasPathMatch) {
+                    updateCurrentVariableDeclaration();
+                }
+                else if (childrenProperty !== undefined && typescript_1.default.isPropertyAssignment(childrenProperty) &&
+                    typescript_1.default.isArrayLiteralExpression(childrenProperty.initializer)) {
+                    // Also need to check the children if it exists
+                    for (const child of childrenProperty.initializer.elements) {
+                        if (typescript_1.default.isObjectLiteralExpression(child)) {
+                            visitObjectLiteral(child);
+                            // If the child caused a migration, we can exit early
+                            if (_currentVariableDecl && migratedNodesMap.has(_currentVariableDecl)) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            function isPropertyWithName(p, name) {
+                if (typescript_1.default.isPropertyAssignment(p)) {
+                    return p.name.getText() === name;
+                }
+                else if (typescript_1.default.isShorthandPropertyAssignment(p)) {
+                    return p.name.getText() === name;
+                }
+                else {
+                    // Don't attempt to migrate edge case spreadAssignment
+                    return false;
+                }
+            }
+            function updateCurrentVariableDeclaration() {
+                if (_currentVariableDecl === null || _currentVariableDecl.initializer === undefined) {
+                    return;
+                }
+                let typeToUse;
+                if (typescript_1.default.isArrayLiteralExpression(_currentVariableDecl.initializer)) {
+                    typeToUse = importManager.addImportToSourceFile(sourceFile, 'Routes', '@angular/router');
+                }
+                else {
+                    typeToUse = importManager.addImportToSourceFile(sourceFile, 'Route', '@angular/router');
+                }
+                const migrated = typescript_1.default.factory.updateVariableDeclaration(_currentVariableDecl, _currentVariableDecl.name, _currentVariableDecl.exclamationToken, typeToUse, _currentVariableDecl.initializer);
+                migratedNodesMap.set(_currentVariableDecl, migrated);
+            }
+        })();
+        return migratedNodesMap;
+    }
+    exports.findExpressionsToMigrate = findExpressionsToMigrate;
+    function isRouteOrRoutesVariableDeclaration(node) {
+        return typescript_1.default.isVariableDeclaration(node) && node.type &&
+            (node.type.getText() === 'Route' || node.type.getText() === 'Routes');
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/path-match-type/util.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;IAEH,4DAA4B;IAK5B,SAAgB,wBAAwB,CAAC,UAAyB,EAAE,aAA4B;QAC9F,MAAM,gBAAgB,GAAwD,IAAI,GAAG,EAAE,CAAC;QACxF,IAAI,oBAAoB,GAAgC,IAAI,CAAC;QAC7D,CAAC,GAAG,EAAE;YACJ,UAAU,CAAC,YAAY,CAAC,SAAS,SAAS,CAAC,IAAa;gBACtD,IAAI,oBAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE;oBAClC,oBAAoB,GAAG,IAAI,CAAC;oBAC5B,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;oBAC7B,oBAAoB,GAAG,IAAI,CAAC;iBAC7B;gBACD,IAAI,kCAAkC,CAAC,IAAI,CAAC,EAAE;oBAC5C,yFAAyF;oBACzF,wBAAwB;oBACxB,OAAO;iBACR;qBAAM,IAAI,oBAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE;oBAC7C,IAAI,oBAAoB,KAAK,IAAI,IAAI,oBAAoB,CAAC,IAAI,KAAK,SAAS,EAAE;wBAC5E,kBAAkB,CAAC,IAAI,CAAC,CAAC;qBAC1B;iBACF;qBAAM;oBACL,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;iBAC9B;YACH,CAAC,CAAC,CAAC;YAEH,SAAS,kBAAkB,CAAC,GAA+B;gBACzD,MAAM,YAAY,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;gBAClF,MAAM,OAAO,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;gBACxE,MAAM,gBAAgB,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;gBACrF,0FAA0F;gBAC1F,wBAAwB;gBACxB,IAAI,OAAO,IAAI,YAAY,EAAE;oBAC3B,gCAAgC,EAAE,CAAC;iBACpC;qBAAM,IACH,gBAAgB,KAAK,SAAS,IAAI,oBAAE,CAAC,oBAAoB,CAAC,gBAAgB,CAAC;oBAC3E,oBAAE,CAAC,wBAAwB,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE;oBAC7D,+CAA+C;oBAC/C,KAAK,MAAM,KAAK,IAAI,gBAAgB,CAAC,WAAW,CAAC,QAAQ,EAAE;wBACzD,IAAI,oBAAE,CAAC,yBAAyB,CAAC,KAAK,CAAC,EAAE;4BACvC,kBAAkB,CAAC,KAAK,CAAC,CAAC;4BAC1B,qDAAqD;4BACrD,IAAI,oBAAoB,IAAI,gBAAgB,CAAC,GAAG,CAAC,oBAAoB,CAAC,EAAE;gCACtE,MAAM;6BACP;yBACF;qBACF;iBACF;YACH,CAAC;YAED,SAAS,kBAAkB,CAAC,CAA8B,EAAE,IAAY;gBACtE,IAAI,oBAAE,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE;oBAC9B,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,IAAI,CAAC;iBAClC;qBAAM,IAAI,oBAAE,CAAC,6BAA6B,CAAC,CAAC,CAAC,EAAE;oBAC9C,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,IAAI,CAAC;iBAClC;qBAAM;oBACL,sDAAsD;oBACtD,OAAO,KAAK,CAAC;iBACd;YACH,CAAC;YAED,SAAS,gCAAgC;gBACvC,IAAI,oBAAoB,KAAK,IAAI,IAAI,oBAAoB,CAAC,WAAW,KAAK,SAAS,EAAE;oBACnF,OAAO;iBACR;gBACD,IAAI,SAAsB,CAAC;gBAC3B,IAAI,oBAAE,CAAC,wBAAwB,CAAC,oBAAoB,CAAC,WAAW,CAAC,EAAE;oBACjE,SAAS,GAAG,aAAa,CAAC,qBAAqB,CAAC,UAAU,EAAE,QAAQ,EAAE,iBAAiB,CAC7D,CAAC;iBAC5B;qBAAM;oBACL,SAAS,GAAG,aAAa,CAAC,qBAAqB,CAAC,UAAU,EAAE,OAAO,EAAE,iBAAiB,CAC5D,CAAC;iBAC5B;gBAED,MAAM,QAAQ,GAAG,oBAAE,CAAC,OAAO,CAAC,yBAAyB,CACjD,oBAAoB,EAAE,oBAAoB,CAAC,IAAI,EAAE,oBAAoB,CAAC,gBAAgB,EACtF,SAAS,EAAE,oBAAoB,CAAC,WAAW,CAAC,CAAC;gBACjD,gBAAgB,CAAC,GAAG,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAC;YACvD,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;QAEL,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IA/ED,4DA+EC;IAED,SAAS,kCAAkC,CAAC,IAAa;QACvD,OAAO,oBAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI;YAC9C,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC;IAC5E,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport ts from 'typescript';\n\nimport {ImportManager} from '../../utils/import_manager';\n\n\nexport function findExpressionsToMigrate(sourceFile: ts.SourceFile, importManager: ImportManager) {\n  const migratedNodesMap: Map<ts.VariableDeclaration, ts.VariableDeclaration> = new Map();\n  let _currentVariableDecl: ts.VariableDeclaration|null = null;\n  (() => {\n    sourceFile.forEachChild(function visitNode(node: ts.Node) {\n      if (ts.isVariableDeclaration(node)) {\n        _currentVariableDecl = node;\n        node.forEachChild(visitNode);\n        _currentVariableDecl = null;\n      }\n      if (isRouteOrRoutesVariableDeclaration(node)) {\n        // The variable declaration is already explicitly typed as `Route` or `Routes` so it does\n        // not need a migration.\n        return;\n      } else if (ts.isObjectLiteralExpression(node)) {\n        if (_currentVariableDecl !== null && _currentVariableDecl.type === undefined) {\n          visitObjectLiteral(node);\n        }\n      } else {\n        node.forEachChild(visitNode);\n      }\n    });\n\n    function visitObjectLiteral(obj: ts.ObjectLiteralExpression) {\n      const hasPathMatch = obj.properties.some(p => isPropertyWithName(p, 'pathMatch'));\n      const hasPath = obj.properties.some(p => isPropertyWithName(p, 'path'));\n      const childrenProperty = obj.properties.find(p => isPropertyWithName(p, 'children'));\n      // The object must have _both_ pathMatch _and_ path for us to be reasonably sure that it's\n      // a `Route` definition.\n      if (hasPath && hasPathMatch) {\n        updateCurrentVariableDeclaration();\n      } else if (\n          childrenProperty !== undefined && ts.isPropertyAssignment(childrenProperty) &&\n          ts.isArrayLiteralExpression(childrenProperty.initializer)) {\n        // Also need to check the children if it exists\n        for (const child of childrenProperty.initializer.elements) {\n          if (ts.isObjectLiteralExpression(child)) {\n            visitObjectLiteral(child);\n            // If the child caused a migration, we can exit early\n            if (_currentVariableDecl && migratedNodesMap.has(_currentVariableDecl)) {\n              break;\n            }\n          }\n        }\n      }\n    }\n\n    function isPropertyWithName(p: ts.ObjectLiteralElementLike, name: string) {\n      if (ts.isPropertyAssignment(p)) {\n        return p.name.getText() === name;\n      } else if (ts.isShorthandPropertyAssignment(p)) {\n        return p.name.getText() === name;\n      } else {\n        // Don't attempt to migrate edge case spreadAssignment\n        return false;\n      }\n    }\n\n    function updateCurrentVariableDeclaration() {\n      if (_currentVariableDecl === null || _currentVariableDecl.initializer === undefined) {\n        return;\n      }\n      let typeToUse: ts.TypeNode;\n      if (ts.isArrayLiteralExpression(_currentVariableDecl.initializer)) {\n        typeToUse = importManager.addImportToSourceFile(sourceFile, 'Routes', '@angular/router') as\n            unknown as ts.TypeNode;\n      } else {\n        typeToUse = importManager.addImportToSourceFile(sourceFile, 'Route', '@angular/router') as\n            unknown as ts.TypeNode;\n      }\n\n      const migrated = ts.factory.updateVariableDeclaration(\n          _currentVariableDecl, _currentVariableDecl.name, _currentVariableDecl.exclamationToken,\n          typeToUse, _currentVariableDecl.initializer);\n      migratedNodesMap.set(_currentVariableDecl, migrated);\n    }\n  })();\n\n  return migratedNodesMap;\n}\n\nfunction isRouteOrRoutesVariableDeclaration(node: ts.Node) {\n  return ts.isVariableDeclaration(node) && node.type &&\n      (node.type.getText() === 'Route' || node.type.getText() === 'Routes');\n}\n"]}

package/schematics/migrations/typed-forms/index.d.ts

@@ -6,9 +6,5 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/core/schematics/migrations/typed-forms" />
-import { Rule, UpdateRecorder } from '@angular-devkit/schematics';
-import ts from 'typescript';
-import { MigratableNode } from './util';
+import { Rule } from '@angular-devkit/schematics';
 export default function (): Rule;
-export declare function migrateNode(update: UpdateRecorder, node: MigratableNode, importd: ts.ImportSpecifier | null): void;
-export declare function insertAnyImport(update: UpdateRecorder, importd: ts.ImportSpecifier): void;

package/schematics/migrations/typed-forms/index.js

@@ -25,7 +25,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.insertAnyImport = exports.migrateNode = void 0;
     const schematics_1 = require("@angular-devkit/schematics");
     const path_1 = require("path");
     const project_tsconfig_paths_1 = require("@angular/core/schematics/utils/project_tsconfig_paths");
@@ -50,41 +49,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         const typeChecker = program.getTypeChecker();
         const sourceFiles = program.getSourceFiles().filter(sourceFile => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program));
         for (const sourceFile of sourceFiles) {
-            const controlClassImports = (0, util_1.getControlClassImports)(sourceFile);
-            const formBuilderImport = (0, util_1.getFormBuilderImport)(sourceFile);
-            // If no relevant classes are imported, we can exit early.
-            if (controlClassImports.length === 0 && formBuilderImport === null)
-                continue;
-            const update = tree.beginUpdate((0, path_1.relative)(basePath, sourceFile.fileName));
-            // For each control class, migrate all of its uses.
-            for (const importSpecifier of controlClassImports) {
-                const usages = (0, util_1.findControlClassUsages)(sourceFile, typeChecker, importSpecifier);
-                for (const node of usages) {
-                    migrateNode(update, node, importSpecifier);
+            let update = null;
+            const rewriter = (startPos, origLength, text) => {
+                if (update === null) {
+                    // Lazily initialize update, because most files will not require migration.
+                    update = tree.beginUpdate((0, path_1.relative)(basePath, sourceFile.fileName));
                 }
+                update.remove(startPos, origLength);
+                update.insertLeft(startPos, text);
+            };
+            (0, util_1.migrateFile)(sourceFile, typeChecker, rewriter);
+            if (update !== null) {
+                tree.commitUpdate(update);
             }
-            // For each FormBuilder method, migrate all of its uses.
-            const nodes = (0, util_1.findFormBuilderCalls)(sourceFile, typeChecker, formBuilderImport);
-            for (const n of nodes) {
-                migrateNode(update, n, formBuilderImport);
-            }
-            // Add the any symbol used by the migrated calls.
-            if ((0, util_1.getAnyImport)(sourceFile) === null) {
-                const firstValidFormsImport = [...controlClassImports, formBuilderImport].sort().filter(i => i !== null)[0];
-                insertAnyImport(update, firstValidFormsImport);
-            }
-            tree.commitUpdate(update);
         }
     }
-    function migrateNode(update, node, importd) {
-        if (importd === null)
-            return;
-        update.insertRight(node.node.getEnd(), node.generic);
-    }
-    exports.migrateNode = migrateNode;
-    function insertAnyImport(update, importd) {
-        update.insertLeft(importd.getStart(), `${util_1.anySymbolName}, `);
-    }
-    exports.insertAnyImport = insertAnyImport;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/typed-forms/util.d.ts

@@ -7,15 +7,13 @@
  */
 /// <amd-module name="@angular/core/schematics/migrations/typed-forms/util" />
 import ts from 'typescript';
-export declare const controlClassNames: string[];
-export declare const builderMethodNames: string[];
-export declare const anySymbolName = "AnyForUntypedForms";
+export declare const classes: Set<string>;
+export declare const formControl = "FormControl";
+export declare const untypedPrefix = "Untyped";
+export declare const forms = "@angular/forms";
 export interface MigratableNode {
-    node: ts.Expression;
-    generic: string;
+    node: ts.Node;
+    importName: string;
 }
-export declare function getControlClassImports(sourceFile: ts.SourceFile): (ts.ImportSpecifier | null)[];
-export declare function getFormBuilderImport(sourceFile: ts.SourceFile): ts.ImportSpecifier | null;
-export declare function getAnyImport(sourceFile: ts.SourceFile): ts.ImportSpecifier | null;
-export declare function findControlClassUsages(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, importSpecifier: ts.ImportSpecifier | null): MigratableNode[];
-export declare function findFormBuilderCalls(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, importSpecifier: ts.ImportSpecifier | null): MigratableNode[];
+export declare type rewriteFn = (startPos: number, origLength: number, text: string) => void;
+export declare function migrateFile(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, rewrite: rewriteFn): void;