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

package/schematics/migrations/testbed-teardown/index.js

@@ -0,0 +1,92 @@
+/**
+ * @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/testbed-teardown", ["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/testbed-teardown/util"], 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 util_1 = require("@angular/core/schematics/migrations/testbed-teardown/util");
+    /** Migration that adds the `teardown` flag to `TestBed` calls. */
+    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 add `teardown` flag to `TestBed`.');
+            }
+            for (const tsconfigPath of allPaths) {
+                runTestbedTeardownMigration(tree, tsconfigPath, basePath);
+            }
+        });
+    }
+    exports.default = default_1;
+    function runTestbedTeardownMigration(tree, tsconfigPath, basePath) {
+        const { program } = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath);
+        const typeChecker = program.getTypeChecker();
+        const sourceFiles = program.getSourceFiles().filter(sourceFile => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program));
+        const initTestEnvironmentResult = (0, util_1.findInitTestEnvironmentCalls)(typeChecker, sourceFiles);
+        const printer = typescript_1.default.createPrinter();
+        // If we identified at least one call to `initTestEnvironment` (can be migrated or unmigrated),
+        // we don't need to migrate `configureTestingModule` or `withModule` calls, because they'll take
+        // the default teardown behavior from the environment. This is preferrable, because it'll result
+        // in the least number of changes to users' code.
+        if (initTestEnvironmentResult.totalCalls > 0) {
+            // Migrate all of the unmigrated calls `initTestEnvironment`. This could be zero
+            // if the user has already opted into the new teardown behavior themselves.
+            initTestEnvironmentResult.callsToMigrate.forEach(node => {
+                const { span, text } = (0, util_1.getInitTestEnvironmentLiteralReplacement)(node, printer);
+                const update = tree.beginUpdate((0, path_1.relative)(basePath, node.getSourceFile().fileName));
+                // The update appears to break if we try to call `remove` with a zero length.
+                if (span.length > 0) {
+                    update.remove(span.start, span.length);
+                }
+                update.insertRight(span.start, text);
+                tree.commitUpdate(update);
+            });
+        }
+        else {
+            // Otherwise migrate the metadata passed into the `configureTestingModule` and `withModule`
+            // calls. This scenario is less likely, but it could happen if `initTestEnvironment` has been
+            // abstracted away or is inside a .js file.
+            sourceFiles.forEach(sourceFile => {
+                (0, util_1.findTestModuleMetadataNodes)(typeChecker, sourceFile).forEach(node => {
+                    const migrated = (0, util_1.migrateTestModuleMetadataLiteral)(node);
+                    const update = tree.beginUpdate((0, path_1.relative)(basePath, node.getSourceFile().fileName));
+                    update.remove(node.getStart(), node.getWidth());
+                    update.insertRight(node.getStart(), printer.printNode(typescript_1.default.EmitHint.Unspecified, migrated, node.getSourceFile()));
+                    tree.commitUpdate(update);
+                });
+            });
+        }
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/testbed-teardown/index.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 {Rule, SchematicsException, Tree} from '@angular-devkit/schematics';\nimport {relative} from 'path';\nimport ts from 'typescript';\n\nimport {getProjectTsConfigPaths} from '../../utils/project_tsconfig_paths';\nimport {canMigrateFile, createMigrationProgram} from '../../utils/typescript/compiler_host';\nimport {findInitTestEnvironmentCalls, findTestModuleMetadataNodes, getInitTestEnvironmentLiteralReplacement, migrateTestModuleMetadataLiteral} from './util';\n\n\n/** Migration that adds the `teardown` flag to `TestBed` calls. */\nexport default function(): Rule {\n  return async (tree: Tree) => {\n    const {buildPaths, testPaths} = await getProjectTsConfigPaths(tree);\n    const basePath = process.cwd();\n    const allPaths = [...buildPaths, ...testPaths];\n\n    if (!allPaths.length) {\n      throw new SchematicsException(\n          'Could not find any tsconfig file. Cannot add `teardown` flag to `TestBed`.');\n    }\n\n    for (const tsconfigPath of allPaths) {\n      runTestbedTeardownMigration(tree, tsconfigPath, basePath);\n    }\n  };\n}\n\nfunction runTestbedTeardownMigration(tree: Tree, tsconfigPath: string, basePath: string) {\n  const {program} = createMigrationProgram(tree, tsconfigPath, basePath);\n  const typeChecker = program.getTypeChecker();\n  const sourceFiles =\n      program.getSourceFiles().filter(sourceFile => canMigrateFile(basePath, sourceFile, program));\n  const initTestEnvironmentResult = findInitTestEnvironmentCalls(typeChecker, sourceFiles);\n  const printer = ts.createPrinter();\n\n  // If we identified at least one call to `initTestEnvironment` (can be migrated or unmigrated),\n  // we don't need to migrate `configureTestingModule` or `withModule` calls, because they'll take\n  // the default teardown behavior from the environment. This is preferrable, because it'll result\n  // in the least number of changes to users' code.\n  if (initTestEnvironmentResult.totalCalls > 0) {\n    // Migrate all of the unmigrated calls `initTestEnvironment`. This could be zero\n    // if the user has already opted into the new teardown behavior themselves.\n    initTestEnvironmentResult.callsToMigrate.forEach(node => {\n      const {span, text} = getInitTestEnvironmentLiteralReplacement(node, printer);\n      const update = tree.beginUpdate(relative(basePath, node.getSourceFile().fileName));\n      // The update appears to break if we try to call `remove` with a zero length.\n      if (span.length > 0) {\n        update.remove(span.start, span.length);\n      }\n      update.insertRight(span.start, text);\n      tree.commitUpdate(update);\n    });\n  } else {\n    // Otherwise migrate the metadata passed into the `configureTestingModule` and `withModule`\n    // calls. This scenario is less likely, but it could happen if `initTestEnvironment` has been\n    // abstracted away or is inside a .js file.\n    sourceFiles.forEach(sourceFile => {\n      findTestModuleMetadataNodes(typeChecker, sourceFile).forEach(node => {\n        const migrated = migrateTestModuleMetadataLiteral(node);\n        const update = tree.beginUpdate(relative(basePath, node.getSourceFile().fileName));\n        update.remove(node.getStart(), node.getWidth());\n        update.insertRight(\n            node.getStart(),\n            printer.printNode(ts.EmitHint.Unspecified, migrated, node.getSourceFile()));\n        tree.commitUpdate(update);\n      });\n    });\n  }\n}\n"]}

package/schematics/migrations/testbed-teardown/util.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @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/testbed-teardown/util" />
+import ts from 'typescript';
+/** Result of a full-program analysis looking for `initTestEnvironment` calls. */
+export interface InitTestEnvironmentAnalysis {
+    /** Total number of calls that were found. */
+    totalCalls: number;
+    /** Calls that need to be migrated. */
+    callsToMigrate: ts.CallExpression[];
+}
+/** Finds the `initTestEnvironment` calls that need to be migrated. */
+export declare function findInitTestEnvironmentCalls(typeChecker: ts.TypeChecker, allSourceFiles: ts.SourceFile[]): InitTestEnvironmentAnalysis;
+/** Finds the `configureTestingModule` and `withModule` calls that need to be migrated. */
+export declare function findTestModuleMetadataNodes(typeChecker: ts.TypeChecker, sourceFile: ts.SourceFile): ts.ObjectLiteralExpression[];
+/**
+ * Gets data that can be used to migrate a call to `TestBed.initTestEnvironment`.
+ * The returned `span` is used to mark the text that should be replaced while the `text`
+ * is the code that should be inserted instead.
+ */
+export declare function getInitTestEnvironmentLiteralReplacement(node: ts.CallExpression, printer: ts.Printer): {
+    span: {
+        start: number;
+        end: number;
+        length: number;
+    };
+    text: string;
+};
+/** Migrates an object literal that is passed into `configureTestingModule` or `withModule`. */
+export declare function migrateTestModuleMetadataLiteral(node: ts.ObjectLiteralExpression): ts.ObjectLiteralExpression;

package/schematics/migrations/testbed-teardown/util.js

@@ -0,0 +1,188 @@
+/**
+ * @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/testbed-teardown/util", ["require", "exports", "typescript", "@angular/core/schematics/utils/typescript/imports", "@angular/core/schematics/utils/typescript/symbol"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.migrateTestModuleMetadataLiteral = exports.getInitTestEnvironmentLiteralReplacement = exports.findTestModuleMetadataNodes = exports.findInitTestEnvironmentCalls = void 0;
+    const typescript_1 = __importDefault(require("typescript"));
+    const imports_1 = require("@angular/core/schematics/utils/typescript/imports");
+    const symbol_1 = require("@angular/core/schematics/utils/typescript/symbol");
+    /** Finds the `initTestEnvironment` calls that need to be migrated. */
+    function findInitTestEnvironmentCalls(typeChecker, allSourceFiles) {
+        const callsToMigrate = new Set();
+        let totalCalls = 0;
+        allSourceFiles.forEach(sourceFile => {
+            sourceFile.forEachChild(function walk(node) {
+                if (typescript_1.default.isCallExpression(node) && typescript_1.default.isPropertyAccessExpression(node.expression) &&
+                    typescript_1.default.isIdentifier(node.expression.name) &&
+                    node.expression.name.text === 'initTestEnvironment' &&
+                    isTestBedAccess(typeChecker, node.expression)) {
+                    totalCalls++;
+                    if (shouldMigrateInitTestEnvironment(node)) {
+                        callsToMigrate.add(node);
+                    }
+                }
+                node.forEachChild(walk);
+            });
+        });
+        return {
+            // Sort the nodes so that they will be migrated in reverse source order (nodes at the end of
+            // the file are migrated first). This avoids issues where a migrated node will offset the
+            // bounds of all nodes that come after it. Note that the nodes here are from all of the
+            // passed in source files, but that doesn't matter since the later nodes will still appear
+            // after the earlier ones.
+            callsToMigrate: sortInReverseSourceOrder(Array.from(callsToMigrate)),
+            totalCalls
+        };
+    }
+    exports.findInitTestEnvironmentCalls = findInitTestEnvironmentCalls;
+    /** Finds the `configureTestingModule` and `withModule` calls that need to be migrated. */
+    function findTestModuleMetadataNodes(typeChecker, sourceFile) {
+        const testModuleMetadataLiterals = new Set();
+        const withModuleImport = (0, imports_1.getImportSpecifier)(sourceFile, '@angular/core/testing', 'withModule');
+        sourceFile.forEachChild(function walk(node) {
+            if (typescript_1.default.isCallExpression(node)) {
+                const isConfigureTestingModuleCall = typescript_1.default.isPropertyAccessExpression(node.expression) &&
+                    typescript_1.default.isIdentifier(node.expression.name) &&
+                    node.expression.name.text === 'configureTestingModule' &&
+                    isTestBedAccess(typeChecker, node.expression) && shouldMigrateModuleConfigCall(node);
+                const isWithModuleCall = withModuleImport && typescript_1.default.isIdentifier(node.expression) &&
+                    (0, symbol_1.isReferenceToImport)(typeChecker, node.expression, withModuleImport) &&
+                    shouldMigrateModuleConfigCall(node);
+                if (isConfigureTestingModuleCall || isWithModuleCall) {
+                    testModuleMetadataLiterals.add(node.arguments[0]);
+                }
+            }
+            node.forEachChild(walk);
+        });
+        // Sort the nodes so that they will be migrated in reverse source order (nodes at the end of
+        // the file are migrated first). This avoids issues where a migrated node will offset the
+        // bounds of all nodes that come after it.
+        return sortInReverseSourceOrder(Array.from(testModuleMetadataLiterals));
+    }
+    exports.findTestModuleMetadataNodes = findTestModuleMetadataNodes;
+    /**
+     * Gets data that can be used to migrate a call to `TestBed.initTestEnvironment`.
+     * The returned `span` is used to mark the text that should be replaced while the `text`
+     * is the code that should be inserted instead.
+     */
+    function getInitTestEnvironmentLiteralReplacement(node, printer) {
+        const literalProperties = [];
+        const lastArg = node.arguments[node.arguments.length - 1];
+        let span;
+        let prefix;
+        if (node.arguments.length > 2) {
+            if (isFunction(lastArg)) {
+                // If the last argument is a function, add the function as the `aotSummaries` property.
+                literalProperties.push(typescript_1.default.createPropertyAssignment('aotSummaries', lastArg));
+            }
+            else if (typescript_1.default.isObjectLiteralExpression(lastArg)) {
+                // If the property is an object literal, copy over all the properties.
+                literalProperties.push(...lastArg.properties);
+            }
+            prefix = '';
+            span = { start: lastArg.getStart(), end: lastArg.getEnd(), length: lastArg.getWidth() };
+        }
+        else {
+            const start = lastArg.getEnd();
+            prefix = ', ';
+            span = { start, end: start, length: 0 };
+        }
+        // Finally push the teardown object so that it appears last.
+        literalProperties.push(createTeardownAssignment());
+        return {
+            span,
+            text: prefix +
+                printer.printNode(typescript_1.default.EmitHint.Unspecified, typescript_1.default.createObjectLiteral(literalProperties, true), node.getSourceFile())
+        };
+    }
+    exports.getInitTestEnvironmentLiteralReplacement = getInitTestEnvironmentLiteralReplacement;
+    /** Migrates an object literal that is passed into `configureTestingModule` or `withModule`. */
+    function migrateTestModuleMetadataLiteral(node) {
+        return typescript_1.default.createObjectLiteral([...node.properties, createTeardownAssignment()], node.properties.length > 0);
+    }
+    exports.migrateTestModuleMetadataLiteral = migrateTestModuleMetadataLiteral;
+    /** Returns whether a property access points to `TestBed`. */
+    function isTestBedAccess(typeChecker, node) {
+        var _a, _b;
+        const symbolName = (_b = (_a = typeChecker.getTypeAtLocation(node.expression)) === null || _a === void 0 ? void 0 : _a.getSymbol()) === null || _b === void 0 ? void 0 : _b.getName();
+        return symbolName === 'TestBed' || symbolName === 'TestBedStatic';
+    }
+    /** Whether a call to `initTestEnvironment` should be migrated. */
+    function shouldMigrateInitTestEnvironment(node) {
+        // If there is no third argument, we definitely have to migrate it.
+        if (node.arguments.length === 2) {
+            return true;
+        }
+        // This is technically a type error so we shouldn't mess with it.
+        if (node.arguments.length < 2) {
+            return false;
+        }
+        // Otherwise we need to figure out if the `teardown` flag is set on the last argument.
+        const lastArg = node.arguments[2];
+        // Note: the checks below will identify something like `initTestEnvironment(..., ..., {})`,
+        // but they'll ignore a variable being passed in as the last argument like `const config = {};
+        // initTestEnvironment(..., ..., config)`. While we can resolve the variable to its declaration
+        // using `typeChecker.getTypeAtLocation(lastArg).getSymbol()?.valueDeclaration`, we deliberately
+        // don't, because it introduces some complexity and we may end up breaking user code. E.g.
+        // the `config` from the example above may be passed in to other functions or the `teardown`
+        // flag could be added later on by a function call.
+        // If the argument is an object literal and there are no
+        // properties called `teardown`, we have to migrate it.
+        if (isObjectLiteralWithoutTeardown(lastArg)) {
+            return true;
+        }
+        // If the last argument is an `aotSummaries` function, we also have to migrate.
+        if (isFunction(lastArg)) {
+            return true;
+        }
+        // Otherwise don't migrate if we couldn't identify the last argument.
+        return false;
+    }
+    /**
+     * Whether a call to a module configuration function should be migrated. This covers
+     * `TestBed.configureTestingModule` and `withModule` since they both accept `TestModuleMetadata`
+     * as their first argument.
+     */
+    function shouldMigrateModuleConfigCall(node) {
+        return node.arguments.length > 0 && isObjectLiteralWithoutTeardown(node.arguments[0]);
+    }
+    /** Returns whether a node is a function literal. */
+    function isFunction(node) {
+        return typescript_1.default.isArrowFunction(node) || typescript_1.default.isFunctionExpression(node) ||
+            typescript_1.default.isFunctionDeclaration(node);
+    }
+    /** Checks whether a node is an object literal that doesn't contain a property called `teardown`. */
+    function isObjectLiteralWithoutTeardown(node) {
+        return typescript_1.default.isObjectLiteralExpression(node) && !node.properties.find(prop => {
+            var _a;
+            return ((_a = prop.name) === null || _a === void 0 ? void 0 : _a.getText()) === 'teardown';
+        });
+    }
+    /** Creates a teardown configuration property assignment. */
+    function createTeardownAssignment() {
+        // `teardown: {destroyAfterEach: false}`
+        return typescript_1.default.createPropertyAssignment('teardown', typescript_1.default.createObjectLiteral([typescript_1.default.createPropertyAssignment('destroyAfterEach', typescript_1.default.createFalse())]));
+    }
+    /** Sorts an array of AST nodes in reverse source order. */
+    function sortInReverseSourceOrder(nodes) {
+        return nodes.sort((a, b) => b.getEnd() - a.getEnd());
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/testbed-teardown/util.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 ts from 'typescript';\n\nimport {getImportSpecifier} from '../../utils/typescript/imports';\nimport {isReferenceToImport} from '../../utils/typescript/symbol';\n\n/** Result of a full-program analysis looking for `initTestEnvironment` calls. */\nexport interface InitTestEnvironmentAnalysis {\n  /** Total number of calls that were found. */\n  totalCalls: number;\n  /** Calls that need to be migrated. */\n  callsToMigrate: ts.CallExpression[];\n}\n\n/** Finds the `initTestEnvironment` calls that need to be migrated. */\nexport function findInitTestEnvironmentCalls(\n    typeChecker: ts.TypeChecker, allSourceFiles: ts.SourceFile[]): InitTestEnvironmentAnalysis {\n  const callsToMigrate = new Set<ts.CallExpression>();\n  let totalCalls = 0;\n\n  allSourceFiles.forEach(sourceFile => {\n    sourceFile.forEachChild(function walk(node: ts.Node) {\n      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) &&\n          ts.isIdentifier(node.expression.name) &&\n          node.expression.name.text === 'initTestEnvironment' &&\n          isTestBedAccess(typeChecker, node.expression)) {\n        totalCalls++;\n        if (shouldMigrateInitTestEnvironment(node)) {\n          callsToMigrate.add(node);\n        }\n      }\n\n      node.forEachChild(walk);\n    });\n  });\n\n  return {\n    // Sort the nodes so that they will be migrated in reverse source order (nodes at the end of\n    // the file are migrated first). This avoids issues where a migrated node will offset the\n    // bounds of all nodes that come after it. Note that the nodes here are from all of the\n    // passed in source files, but that doesn't matter since the later nodes will still appear\n    // after the earlier ones.\n    callsToMigrate: sortInReverseSourceOrder(Array.from(callsToMigrate)),\n    totalCalls\n  };\n}\n\n/** Finds the `configureTestingModule` and `withModule` calls that need to be migrated. */\nexport function findTestModuleMetadataNodes(\n    typeChecker: ts.TypeChecker, sourceFile: ts.SourceFile) {\n  const testModuleMetadataLiterals = new Set<ts.ObjectLiteralExpression>();\n  const withModuleImport = getImportSpecifier(sourceFile, '@angular/core/testing', 'withModule');\n\n  sourceFile.forEachChild(function walk(node: ts.Node) {\n    if (ts.isCallExpression(node)) {\n      const isConfigureTestingModuleCall = ts.isPropertyAccessExpression(node.expression) &&\n          ts.isIdentifier(node.expression.name) &&\n          node.expression.name.text === 'configureTestingModule' &&\n          isTestBedAccess(typeChecker, node.expression) && shouldMigrateModuleConfigCall(node);\n      const isWithModuleCall = withModuleImport && ts.isIdentifier(node.expression) &&\n          isReferenceToImport(typeChecker, node.expression, withModuleImport) &&\n          shouldMigrateModuleConfigCall(node);\n\n      if (isConfigureTestingModuleCall || isWithModuleCall) {\n        testModuleMetadataLiterals.add(node.arguments[0] as ts.ObjectLiteralExpression);\n      }\n    }\n\n    node.forEachChild(walk);\n  });\n\n  // Sort the nodes so that they will be migrated in reverse source order (nodes at the end of\n  // the file are migrated first). This avoids issues where a migrated node will offset the\n  // bounds of all nodes that come after it.\n  return sortInReverseSourceOrder(Array.from(testModuleMetadataLiterals));\n}\n\n/**\n * Gets data that can be used to migrate a call to `TestBed.initTestEnvironment`.\n * The returned `span` is used to mark the text that should be replaced while the `text`\n * is the code that should be inserted instead.\n */\nexport function getInitTestEnvironmentLiteralReplacement(\n    node: ts.CallExpression, printer: ts.Printer) {\n  const literalProperties: ts.ObjectLiteralElementLike[] = [];\n  const lastArg = node.arguments[node.arguments.length - 1];\n  let span: {start: number, end: number, length: number};\n  let prefix: string;\n\n  if (node.arguments.length > 2) {\n    if (isFunction(lastArg)) {\n      // If the last argument is a function, add the function as the `aotSummaries` property.\n      literalProperties.push(ts.createPropertyAssignment('aotSummaries', lastArg));\n    } else if (ts.isObjectLiteralExpression(lastArg)) {\n      // If the property is an object literal, copy over all the properties.\n      literalProperties.push(...lastArg.properties);\n    }\n\n    prefix = '';\n    span = {start: lastArg.getStart(), end: lastArg.getEnd(), length: lastArg.getWidth()};\n  } else {\n    const start = lastArg.getEnd();\n    prefix = ', ';\n    span = {start, end: start, length: 0};\n  }\n\n  // Finally push the teardown object so that it appears last.\n  literalProperties.push(createTeardownAssignment());\n\n  return {\n    span,\n    text: prefix +\n        printer.printNode(\n            ts.EmitHint.Unspecified, ts.createObjectLiteral(literalProperties, true),\n            node.getSourceFile())\n  };\n}\n\n/** Migrates an object literal that is passed into `configureTestingModule` or `withModule`. */\nexport function migrateTestModuleMetadataLiteral(node: ts.ObjectLiteralExpression):\n    ts.ObjectLiteralExpression {\n  return ts.createObjectLiteral(\n      [...node.properties, createTeardownAssignment()], node.properties.length > 0);\n}\n\n/** Returns whether a property access points to `TestBed`. */\nfunction isTestBedAccess(typeChecker: ts.TypeChecker, node: ts.PropertyAccessExpression): boolean {\n  const symbolName = typeChecker.getTypeAtLocation(node.expression)?.getSymbol()?.getName();\n  return symbolName === 'TestBed' || symbolName === 'TestBedStatic';\n}\n\n/** Whether a call to `initTestEnvironment` should be migrated. */\nfunction shouldMigrateInitTestEnvironment(node: ts.CallExpression): boolean {\n  // If there is no third argument, we definitely have to migrate it.\n  if (node.arguments.length === 2) {\n    return true;\n  }\n\n  // This is technically a type error so we shouldn't mess with it.\n  if (node.arguments.length < 2) {\n    return false;\n  }\n\n  // Otherwise we need to figure out if the `teardown` flag is set on the last argument.\n  const lastArg = node.arguments[2];\n\n  // Note: the checks below will identify something like `initTestEnvironment(..., ..., {})`,\n  // but they'll ignore a variable being passed in as the last argument like `const config = {};\n  // initTestEnvironment(..., ..., config)`. While we can resolve the variable to its declaration\n  // using `typeChecker.getTypeAtLocation(lastArg).getSymbol()?.valueDeclaration`, we deliberately\n  // don't, because it introduces some complexity and we may end up breaking user code. E.g.\n  // the `config` from the example above may be passed in to other functions or the `teardown`\n  // flag could be added later on by a function call.\n\n  // If the argument is an object literal and there are no\n  // properties called `teardown`, we have to migrate it.\n  if (isObjectLiteralWithoutTeardown(lastArg)) {\n    return true;\n  }\n\n  // If the last argument is an `aotSummaries` function, we also have to migrate.\n  if (isFunction(lastArg)) {\n    return true;\n  }\n\n  // Otherwise don't migrate if we couldn't identify the last argument.\n  return false;\n}\n\n/**\n * Whether a call to a module configuration function should be migrated. This covers\n * `TestBed.configureTestingModule` and `withModule` since they both accept `TestModuleMetadata`\n * as their first argument.\n */\nfunction shouldMigrateModuleConfigCall(node: ts.CallExpression): node is ts.CallExpression&\n    {arguments: [ts.ObjectLiteralExpression, ...ts.Expression[]]} {\n  return node.arguments.length > 0 && isObjectLiteralWithoutTeardown(node.arguments[0]);\n}\n\n/** Returns whether a node is a function literal. */\nfunction isFunction(node: ts.Node): node is ts.ArrowFunction|ts.FunctionExpression|\n    ts.FunctionDeclaration {\n  return ts.isArrowFunction(node) || ts.isFunctionExpression(node) ||\n      ts.isFunctionDeclaration(node);\n}\n\n/** Checks whether a node is an object literal that doesn't contain a property called `teardown`. */\nfunction isObjectLiteralWithoutTeardown(node: ts.Node): node is ts.ObjectLiteralExpression {\n  return ts.isObjectLiteralExpression(node) && !node.properties.find(prop => {\n    return prop.name?.getText() === 'teardown';\n  });\n}\n\n/** Creates a teardown configuration property assignment. */\nfunction createTeardownAssignment(): ts.PropertyAssignment {\n  // `teardown: {destroyAfterEach: false}`\n  return ts.createPropertyAssignment(\n      'teardown',\n      ts.createObjectLiteral([ts.createPropertyAssignment('destroyAfterEach', ts.createFalse())]));\n}\n\n/** Sorts an array of AST nodes in reverse source order. */\nfunction sortInReverseSourceOrder<T extends ts.Node>(nodes: T[]): T[] {\n  return nodes.sort((a, b) => b.getEnd() - a.getEnd());\n}\n"]}

package/schematics/migrations.json

@@ -1,109 +1,14 @@
 {
   "schematics": {
-    "migration-v8-move-document": {
-      "version": "8.0.0-beta",
-      "description": "@DOCUMENT migration. Migrates DOCUMENT Injection token from platform-browser imports to common import.",
-      "factory": "./migrations/move-document/index"
-    },
-    "migration-v8-static-queries": {
-      "version": "8.0.0-beta",
-      "description": "ViewChild and ContentChild to explicit query timing migration. In Angular version 8, developers need to explicitly specify the timing of ViewChild and ContentChild queries. Read more about this here: https://v8.angular.io/guide/static-query-migration",
-      "factory": "./migrations/static-queries/index"
-    },
-    "migration-v8-template-local-variables": {
-      "version": "8.0.0-beta",
-      "description": "Template Variable Assignment migration. Warns developers if values are assigned to template variables.",
-      "factory": "./migrations/template-var-assignment/index"
-    },
-    "migration-v9-renderer-to-renderer2": {
-      "version": "9.0.0-beta",
-      "description": "Renderer to Renderer2 migration. As of Angular 9, the Renderer class is no longer available. Renderer2 should be used instead. Read more about this here: https://v9.angular.io/guide/migration-renderer",
-      "factory": "./migrations/renderer-to-renderer2/index"
-    },
-    "migration-v9-undecorated-classes-with-di": {
-      "version": "9.0.0-beta",
-      "description": "Undecorated classes with DI migration. As of Angular 9, it is no longer supported to use Angular DI on a class that does not have an Angular decorator. Read more about this here: https://v9.angular.io/guide/migration-undecorated-classes",
-      "factory": "./migrations/undecorated-classes-with-di/index"
-    },
-    "migration-v9-dynamic-queries": {
-      "version": "9-beta",
-      "description": "Static flag migration. Removes the `static` flag from dynamic queries. As of Angular 9, the \"static\" flag defaults to false and is no longer required for your view and content queries. Read more about this here: https://v9.angular.io/guide/migration-dynamic-flag",
-      "factory": "./migrations/dynamic-queries/index"
-    },
-    "migration-v10-missing-injectable": {
-      "version": "10.0.0-beta",
-      "description": "Missing @Injectable and incomplete provider definition migration. As of Angular 9, enforcement of @Injectable decorators for DI is a bit stricter and incomplete provider definitions behave differently. Read more about this here: https://v9.angular.io/guide/migration-injectable",
-      "factory": "./migrations/missing-injectable/index"
-    },
-    "migration-v10-module-with-providers": {
-      "version": "10.0.0-beta",
-      "description": "ModuleWithProviders migration. As of Angular 10, the ModuleWithProviders type requires a generic. This migration adds the generic where it is missing. Read more about this here: https://v10.angular.io/guide/migration-module-with-providers",
-      "factory": "./migrations/module-with-providers/index"
-    },
-    "migration-v10-undecorated-classes-with-decorated-fields": {
-      "version": "10.0.0-beta",
-      "description": "Undecorated classes with Angular features migration. In version 10, classes that use Angular features and do not have an Angular decorator are no longer supported. Read more about this here: https://v10.angular.io/guide/migration-undecorated-classes",
-      "factory": "./migrations/undecorated-classes-with-decorated-fields/index"
-    },
-    "migration-v11-navigation-extras-omissions": {
-      "version": "11.0.0-beta",
-      "description": "NavigationExtras omissions migration. In version 11, some unsupported properties were omitted from the `extras` parameter of the `Router.navigateByUrl` and `Router.createUrlTree` methods.",
-      "factory": "./migrations/navigation-extras-omissions/index"
-    },
-    "migration-v11-router-relative-link-resolution-default": {
-      "version": "11.0.0-beta",
-      "description": "The default value for `relativeLinkResolution` is changing from 'legacy' to 'corrected'.\nThis migration updates `RouterModule` configurations that use the default value to \nnow specifically use 'legacy' to prevent breakages when updating.",
-      "factory": "./migrations/relative-link-resolution/index"
-    },
-    "migration-v11-abstract-control-parent": {
-      "version": "11.0.0-beta",
-      "description": "In Angular version 11, the type of `AbstractControl.parent` can be `null` to reflect the runtime value more accurately. This migration automatically adds non-null assertions to existing accesses of the `parent` property on types like `FormControl`, `FormArray` and `FormGroup`.",
-      "factory": "./migrations/abstract-control-parent/index"
-    },
-    "migration-v11-native-view-encapsulation": {
-      "version": "11.0.0-beta",
-      "description": "ViewEncapsulation.Native has been removed as of Angular version 11. This migration replaces any usages with ViewEncapsulation.ShadowDom.",
-      "factory": "./migrations/native-view-encapsulation/index"
-    },
-    "migration-v11-wait-for-async": {
-      "version": "11.0.0-beta",
-      "description": "`async` to `waitForAsync` migration. The `async` testing function has been renamed to `waitForAsync` to avoid confusion with the native `async` keyword.",
-      "factory": "./migrations/wait-for-async/index"
-    },
-    "migration-v11-router-preserve-query-params": {
-      "version": "11.0.0-beta",
-      "description": "NavigationExtras.preserveQueryParams has been removed as of Angular version 11.  This migration replaces any usages with the appropriate assignment of the queryParamsHandling key.",
-      "factory": "./migrations/router-preserve-query-params/index"
-    },
-    "migration-v11-router-initial-navigation-options": {
-      "version": "11.0.0-beta",
-      "description": "Updates the `initialNavigation` property for `RouterModule.forRoot`.",
-      "factory": "./migrations/initial-navigation/index"
-    },
-    "migration-v11.1-can-activate-with-redirect-to": {
-      "version": "11.1.0-beta",
-      "description": "Removes `canActivate` from a `Route` config when `redirectTo` is also present",
-      "factory": "./migrations/can-activate-with-redirect-to/index"
-    },
-    "migration-v12-activated-route-snapshot-fragment": {
-      "version": "12.0.0-beta",
-      "description": "In Angular version 12, the type of ActivatedRouteSnapshot.fragment is nullable. This migration automatically adds non-null assertions to it.",
-      "factory": "./migrations/activated-route-snapshot-fragment/index"
-    },
-    "migration-v12-xhr-factory": {
-      "version": "12.0.0-next.6",
-      "description": "`XhrFactory` has been moved from `@angular/common/http` to `@angular/common`.",
-      "factory": "./migrations/xhr-factory/index"
-    },
-    "migration-v12-deep-shadow-piercing-selector": {
-      "version": "12.0.2",
-      "description": "Automatically migrates shadow-piercing selector from `/deep/` to the recommended alternative `::ng-deep`.",
-      "factory": "./migrations/deep-shadow-piercing-selector/index"
-    },
     "migration-v13-router-link-empty-expression": {
       "version": "13.0.0-beta",
       "description": "Migrates `[routerLink]=\"\"` in templates to `[routerLink]=\"[]\"` because these links are likely intended to route to the current page with updated fragment/query params.",
       "factory": "./migrations/router-link-empty-expression/index"
+    },
+    "migration-v13-testbed-teardown": {
+      "version": "13.0.0-beta",
+      "description": "In Angular version 13, the `teardown` flag in `TestBed` will be enabled by default. This migration automatically opts out existing apps from the new teardown behavior.",
+      "factory": "./migrations/testbed-teardown/index"
     }
   }
-}
+}

package/schematics/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/schematics/utils/import_manager.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/core/schematics/utils/import_manager" />
-import * as ts from 'typescript';
+import ts from 'typescript';
 /** Update recorder for managing imports. */
 export interface ImportManagerUpdateRecorder {
     addNewImport(start: number, importText: string): void;