@angular/cdk 12.0.0-rc.2 → 12.0.2

package/schematics/ng-update/typescript/literal.mjs

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStringLiteralLike = exports.findAllSubstringIndices = void 0;
+const ts = require("typescript");
+/** Finds all start indices of the given search string in the input string. */
+function findAllSubstringIndices(input, search) {
+    const result = [];
+    let i = -1;
+    while ((i = input.indexOf(search, i + 1)) !== -1) {
+        result.push(i);
+    }
+    return result;
+}
+exports.findAllSubstringIndices = findAllSubstringIndices;
+/**
+ * Checks whether the given node is either a string literal or a no-substitution template
+ * literal. Note that we cannot use `ts.isStringLiteralLike()` because if developers update
+ * an outdated project, their TypeScript version is not automatically being updated
+ * and therefore could throw because the function is not available yet.
+ * https://github.com/Microsoft/TypeScript/commit/8518343dc8762475a5e92c9f80b5c5725bd81796
+ */
+function isStringLiteralLike(node) {
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node);
+}
+exports.isStringLiteralLike = isStringLiteralLike;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/typescript/module-specifiers.mjs

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMaterialExportDeclaration = exports.isMaterialImportDeclaration = exports.cdkModuleSpecifier = exports.materialModuleSpecifier = void 0;
+const imports_1 = require("../typescript/imports");
+/** Name of the Angular Material module specifier. */
+exports.materialModuleSpecifier = '@angular/material';
+/** Name of the Angular CDK module specifier. */
+exports.cdkModuleSpecifier = '@angular/cdk';
+/** Whether the specified node is part of an Angular Material or CDK import declaration. */
+function isMaterialImportDeclaration(node) {
+    return isMaterialDeclaration(imports_1.getImportDeclaration(node));
+}
+exports.isMaterialImportDeclaration = isMaterialImportDeclaration;
+/** Whether the specified node is part of an Angular Material or CDK import declaration. */
+function isMaterialExportDeclaration(node) {
+    return isMaterialDeclaration(imports_1.getExportDeclaration(node));
+}
+exports.isMaterialExportDeclaration = isMaterialExportDeclaration;
+/** Whether the declaration is part of Angular Material. */
+function isMaterialDeclaration(declaration) {
+    if (!declaration.moduleSpecifier) {
+        return false;
+    }
+    const moduleSpecifier = declaration.moduleSpecifier.getText();
+    return moduleSpecifier.indexOf(exports.materialModuleSpecifier) !== -1 ||
+        moduleSpecifier.indexOf(exports.cdkModuleSpecifier) !== -1;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/upgrade-data.mjs

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersionUpgradeData = exports.cdkUpgradeData = void 0;
+const version_changes_1 = require("../update-tool/version-changes");
+const data_1 = require("./data");
+/** Upgrade data for the Angular CDK. */
+exports.cdkUpgradeData = {
+    attributeSelectors: data_1.attributeSelectors,
+    classNames: data_1.classNames,
+    constructorChecks: data_1.constructorChecks,
+    cssSelectors: data_1.cssSelectors,
+    elementSelectors: data_1.elementSelectors,
+    inputNames: data_1.inputNames,
+    methodCallChecks: data_1.methodCallChecks,
+    outputNames: data_1.outputNames,
+    propertyNames: data_1.propertyNames,
+};
+/**
+ * Gets the reduced upgrade data for the specified data key. The function reads out the
+ * target version and upgrade data object from the migration and resolves the specified
+ * data portion that is specifically tied to the target version.
+ */
+function getVersionUpgradeData(migration, dataName) {
+    // Note that below we need to cast to `unknown` first TS doesn't infer the type of T correctly.
+    return version_changes_1.getChangesForTarget(migration.targetVersion, migration.upgradeData[dataName]);
+}
+exports.getVersionUpgradeData = getVersionUpgradeData;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/paths.mjs

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATION_PATH = exports.COLLECTION_PATH = void 0;
+const path_1 = require("path");
+/** Path to the schematic collection for non-migration schematics. */
+exports.COLLECTION_PATH = path_1.join(__dirname, 'collection.json');
+/** Path to the schematic collection that includes the migrations. */
+exports.MIGRATION_PATH = path_1.join(__dirname, 'migration.json');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3NjaGVtYXRpY3MvcGF0aHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7O0FBRUgsK0JBQTBCO0FBRTFCLHFFQUFxRTtBQUN4RCxRQUFBLGVBQWUsR0FBRyxXQUFJLENBQUMsU0FBUyxFQUFFLGlCQUFpQixDQUFDLENBQUM7QUFFbEUscUVBQXFFO0FBQ3hELFFBQUEsY0FBYyxHQUFHLFdBQUksQ0FBQyxTQUFTLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge2pvaW59IGZyb20gJ3BhdGgnO1xuXG4vKiogUGF0aCB0byB0aGUgc2NoZW1hdGljIGNvbGxlY3Rpb24gZm9yIG5vbi1taWdyYXRpb24gc2NoZW1hdGljcy4gKi9cbmV4cG9ydCBjb25zdCBDT0xMRUNUSU9OX1BBVEggPSBqb2luKF9fZGlybmFtZSwgJ2NvbGxlY3Rpb24uanNvbicpO1xuXG4vKiogUGF0aCB0byB0aGUgc2NoZW1hdGljIGNvbGxlY3Rpb24gdGhhdCBpbmNsdWRlcyB0aGUgbWlncmF0aW9ucy4gKi9cbmV4cG9ydCBjb25zdCBNSUdSQVRJT05fUEFUSCA9IGpvaW4oX19kaXJuYW1lLCAnbWlncmF0aW9uLmpzb24nKTtcbiJdfQ==

package/schematics/update-tool/component-resource-collector.mjs

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentResourceCollector = void 0;
+const path_1 = require("path");
+const ts = require("typescript");
+const decorators_1 = require("./utils/decorators");
+const functions_1 = require("./utils/functions");
+const line_mappings_1 = require("./utils/line-mappings");
+const property_name_1 = require("./utils/property-name");
+/**
+ * Collector that can be used to find Angular templates and stylesheets referenced within
+ * given TypeScript source files (inline or external referenced files)
+ */
+class ComponentResourceCollector {
+    constructor(typeChecker, _fileSystem) {
+        this.typeChecker = typeChecker;
+        this._fileSystem = _fileSystem;
+        this.resolvedTemplates = [];
+        this.resolvedStylesheets = [];
+    }
+    visitNode(node) {
+        if (node.kind === ts.SyntaxKind.ClassDeclaration) {
+            this._visitClassDeclaration(node);
+        }
+    }
+    _visitClassDeclaration(node) {
+        if (!node.decorators || !node.decorators.length) {
+            return;
+        }
+        const ngDecorators = decorators_1.getAngularDecorators(this.typeChecker, node.decorators);
+        const componentDecorator = ngDecorators.find(dec => dec.name === 'Component');
+        // In case no "@Component" decorator could be found on the current class, skip.
+        if (!componentDecorator) {
+            return;
+        }
+        const decoratorCall = componentDecorator.node.expression;
+        // In case the component decorator call is not valid, skip this class declaration.
+        if (decoratorCall.arguments.length !== 1) {
+            return;
+        }
+        const componentMetadata = functions_1.unwrapExpression(decoratorCall.arguments[0]);
+        // Ensure that the component metadata is an object literal expression.
+        if (!ts.isObjectLiteralExpression(componentMetadata)) {
+            return;
+        }
+        const sourceFile = node.getSourceFile();
+        const filePath = this._fileSystem.resolve(sourceFile.fileName);
+        const sourceFileDirPath = path_1.dirname(sourceFile.fileName);
+        // Walk through all component metadata properties and determine the referenced
+        // HTML templates (either external or inline)
+        componentMetadata.properties.forEach(property => {
+            if (!ts.isPropertyAssignment(property)) {
+                return;
+            }
+            const propertyName = property_name_1.getPropertyNameText(property.name);
+            if (propertyName === 'styles' && ts.isArrayLiteralExpression(property.initializer)) {
+                property.initializer.elements.forEach(el => {
+                    if (ts.isStringLiteralLike(el)) {
+                        // Need to add an offset of one to the start because the template quotes are
+                        // not part of the template content.
+                        const templateStartIdx = el.getStart() + 1;
+                        this.resolvedStylesheets.push({
+                            filePath,
+                            container: node,
+                            content: el.text,
+                            inline: true,
+                            start: templateStartIdx,
+                            getCharacterAndLineOfPosition: pos => ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx),
+                        });
+                    }
+                });
+            }
+            // 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)) {
+                // 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;
+                this.resolvedTemplates.push({
+                    filePath,
+                    container: node,
+                    content: property.initializer.text,
+                    inline: true,
+                    start: templateStartIdx,
+                    getCharacterAndLineOfPosition: pos => ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx)
+                });
+            }
+            if (propertyName === 'styleUrls' && ts.isArrayLiteralExpression(property.initializer)) {
+                property.initializer.elements.forEach(el => {
+                    if (ts.isStringLiteralLike(el)) {
+                        const stylesheetPath = this._fileSystem.resolve(sourceFileDirPath, el.text);
+                        const stylesheet = this.resolveExternalStylesheet(stylesheetPath, node);
+                        if (stylesheet) {
+                            this.resolvedStylesheets.push(stylesheet);
+                        }
+                    }
+                });
+            }
+            if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {
+                const templateUrl = property.initializer.text;
+                const templatePath = this._fileSystem.resolve(sourceFileDirPath, templateUrl);
+                // In case the template does not exist in the file system, skip this
+                // external template.
+                if (!this._fileSystem.exists(templatePath)) {
+                    return;
+                }
+                const fileContent = this._fileSystem.read(templatePath);
+                if (fileContent) {
+                    const lineStartsMap = line_mappings_1.computeLineStartsMap(fileContent);
+                    this.resolvedTemplates.push({
+                        filePath: templatePath,
+                        container: node,
+                        content: fileContent,
+                        inline: false,
+                        start: 0,
+                        getCharacterAndLineOfPosition: p => line_mappings_1.getLineAndCharacterFromPosition(lineStartsMap, p),
+                    });
+                }
+            }
+        });
+    }
+    /** Resolves an external stylesheet by reading its content and computing line mappings. */
+    resolveExternalStylesheet(filePath, container) {
+        const fileContent = this._fileSystem.read(filePath);
+        if (!fileContent) {
+            return null;
+        }
+        const lineStartsMap = line_mappings_1.computeLineStartsMap(fileContent);
+        return {
+            filePath: filePath,
+            container: container,
+            content: fileContent,
+            inline: false,
+            start: 0,
+            getCharacterAndLineOfPosition: pos => line_mappings_1.getLineAndCharacterFromPosition(lineStartsMap, pos),
+        };
+    }
+}
+exports.ComponentResourceCollector = ComponentResourceCollector;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-resource-collector.js","sourceRoot":"","sources":["../../../../../../../src/cdk/schematics/update-tool/component-resource-collector.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 {dirname} from 'path';\nimport * as ts from 'typescript';\nimport {FileSystem, WorkspacePath} from './file-system';\nimport {getAngularDecorators} from './utils/decorators';\nimport {unwrapExpression} from './utils/functions';\nimport {\n  computeLineStartsMap,\n  getLineAndCharacterFromPosition,\n  LineAndCharacter\n} from './utils/line-mappings';\nimport {getPropertyNameText} from './utils/property-name';\n\nexport interface ResolvedResource {\n  /** Class declaration that contains this resource. */\n  container: ts.ClassDeclaration|null;\n  /** File content of the given template. */\n  content: string;\n  /** Start offset of the resource content (e.g. in the inline source file) */\n  start: number;\n  /** Whether the given resource is inline or not. */\n  inline: boolean;\n  /** Path to the file that contains this resource. */\n  filePath: WorkspacePath;\n  /**\n   * Gets the character and line of a given position index in the resource.\n   * If the resource 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) => LineAndCharacter;\n}\n\n/**\n * Collector that can be used to find Angular templates and stylesheets referenced within\n * given TypeScript source files (inline or external referenced files)\n */\nexport class ComponentResourceCollector {\n  resolvedTemplates: ResolvedResource[] = [];\n  resolvedStylesheets: ResolvedResource[] = [];\n\n  constructor(public typeChecker: ts.TypeChecker, private _fileSystem: FileSystem) {}\n\n  visitNode(node: ts.Node) {\n    if (node.kind === ts.SyntaxKind.ClassDeclaration) {\n      this._visitClassDeclaration(node as ts.ClassDeclaration);\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 filePath = this._fileSystem.resolve(sourceFile.fileName);\n    const sourceFileDirPath = dirname(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      if (propertyName === 'styles' && ts.isArrayLiteralExpression(property.initializer)) {\n        property.initializer.elements.forEach(el => {\n          if (ts.isStringLiteralLike(el)) {\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 = el.getStart() + 1;\n            this.resolvedStylesheets.push({\n              filePath,\n              container: node,\n              content: el.text,\n              inline: true,\n              start: templateStartIdx,\n              getCharacterAndLineOfPosition: pos =>\n                  ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx),\n            });\n          }\n        });\n      }\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        this.resolvedTemplates.push({\n          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\n      if (propertyName === 'styleUrls' && ts.isArrayLiteralExpression(property.initializer)) {\n        property.initializer.elements.forEach(el => {\n          if (ts.isStringLiteralLike(el)) {\n            const stylesheetPath = this._fileSystem.resolve(sourceFileDirPath, el.text);\n            const stylesheet = this.resolveExternalStylesheet(stylesheetPath, node);\n\n            if (stylesheet) {\n              this.resolvedStylesheets.push(stylesheet);\n            }\n          }\n        });\n      }\n\n      if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {\n        const templateUrl = property.initializer.text;\n        const templatePath = this._fileSystem.resolve(sourceFileDirPath, templateUrl);\n\n        // In case the template does not exist in the file system, skip this\n        // external template.\n        if (!this._fileSystem.exists(templatePath)) {\n          return;\n        }\n\n        const fileContent = this._fileSystem.read(templatePath);\n\n        if (fileContent) {\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: p => getLineAndCharacterFromPosition(lineStartsMap, p),\n          });\n        }\n      }\n    });\n  }\n\n  /** Resolves an external stylesheet by reading its content and computing line mappings. */\n  resolveExternalStylesheet(filePath: WorkspacePath, container: ts.ClassDeclaration|null):\n      ResolvedResource|null {\n    const fileContent = this._fileSystem.read(filePath);\n\n    if (!fileContent) {\n      return null;\n    }\n\n    const lineStartsMap = computeLineStartsMap(fileContent);\n\n    return {\n      filePath: filePath,\n      container: container,\n      content: fileContent,\n      inline: false,\n      start: 0,\n      getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),\n    };\n  }\n}\n"]}

package/schematics/update-tool/file-system.mjs

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystem = void 0;
+/**
+ * Abstraction of the file system that migrations can use to record and apply
+ * changes. This is necessary to support virtual file systems as used in the CLI devkit.
+ */
+class FileSystem {
+}
+exports.FileSystem = FileSystem;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/update-tool/index.mjs

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateProject = void 0;
+const ts = require("typescript");
+const component_resource_collector_1 = require("./component-resource-collector");
+const logger_1 = require("./logger");
+const parse_tsconfig_1 = require("./utils/parse-tsconfig");
+const virtual_host_1 = require("./utils/virtual-host");
+/**
+ * An update project that can be run against individual migrations. An update project
+ * accepts a TypeScript program and a context that is provided to all migrations. The
+ * context is usually not used by migrations, but in some cases migrations rely on
+ * specifics from the tool that performs the update (e.g. the Angular CLI). In those cases,
+ * the context can provide the necessary specifics to the migrations in a type-safe way.
+ */
+class UpdateProject {
+    constructor(/** Context provided to all migrations. */ _context, 
+    /** TypeScript program using workspace paths. */
+    _program, 
+    /** File system used for reading, writing and editing files. */
+    _fileSystem, 
+    /**
+     * Set of analyzed files. Used for avoiding multiple migration runs if
+     * files overlap between targets.
+     */
+    _analyzedFiles = new Set(), 
+    /** Logger used for printing messages. */
+    _logger = logger_1.defaultLogger) {
+        this._context = _context;
+        this._program = _program;
+        this._fileSystem = _fileSystem;
+        this._analyzedFiles = _analyzedFiles;
+        this._logger = _logger;
+        this._typeChecker = this._program.getTypeChecker();
+    }
+    /**
+     * Migrates the project to the specified target version.
+     * @param migrationTypes Migrations that should be run.
+     * @param target Version the project should be updated to.
+     * @param data Upgrade data that is passed to all migration rules.
+     * @param additionalStylesheetPaths Additional stylesheets that should be migrated, if not
+     *   referenced in an Angular component. This is helpful for global stylesheets in a project.
+     */
+    migrate(migrationTypes, target, data, additionalStylesheetPaths) {
+        // Create instances of the specified migrations.
+        const migrations = this._createMigrations(migrationTypes, target, data);
+        // Creates the component resource collector. The collector can visit arbitrary
+        // TypeScript nodes and will find Angular component resources. Resources include
+        // templates and stylesheets. It also captures inline stylesheets and templates.
+        const resourceCollector = new component_resource_collector_1.ComponentResourceCollector(this._typeChecker, this._fileSystem);
+        // Collect all of the TypeScript source files we want to migrate. We don't
+        // migrate type definition files, or source files from external libraries.
+        const sourceFiles = this._program.getSourceFiles().filter(f => !f.isDeclarationFile && !this._program.isSourceFileFromExternalLibrary(f));
+        // Helper function that visits a given TypeScript node and collects all referenced
+        // component resources (i.e. stylesheets or templates). Additionally, the helper
+        // visits the node in each instantiated migration.
+        const visitNodeAndCollectResources = (node) => {
+            migrations.forEach(r => r.visitNode(node));
+            ts.forEachChild(node, visitNodeAndCollectResources);
+            resourceCollector.visitNode(node);
+        };
+        // Walk through all source file, if it has not been visited before, and
+        // visit found nodes while collecting potential resources.
+        sourceFiles.forEach(sourceFile => {
+            const resolvedPath = this._fileSystem.resolve(sourceFile.fileName);
+            // Do not visit source files which have been checked as part of a
+            // previously migrated TypeScript project.
+            if (!this._analyzedFiles.has(resolvedPath)) {
+                visitNodeAndCollectResources(sourceFile);
+                this._analyzedFiles.add(resolvedPath);
+            }
+        });
+        // Walk through all resolved templates and visit them in each instantiated
+        // migration. Note that this can only happen after source files have been
+        // visited because we find templates through the TypeScript source files.
+        resourceCollector.resolvedTemplates.forEach(template => {
+            // Do not visit the template if it has been checked before. Inline
+            // templates cannot be referenced multiple times.
+            if (template.inline || !this._analyzedFiles.has(template.filePath)) {
+                migrations.forEach(m => m.visitTemplate(template));
+                this._analyzedFiles.add(template.filePath);
+            }
+        });
+        // Walk through all resolved stylesheets and visit them in each instantiated
+        // migration. Note that this can only happen after source files have been
+        // visited because we find stylesheets through the TypeScript source files.
+        resourceCollector.resolvedStylesheets.forEach(stylesheet => {
+            // Do not visit the stylesheet if it has been checked before. Inline
+            // stylesheets cannot be referenced multiple times.
+            if (stylesheet.inline || !this._analyzedFiles.has(stylesheet.filePath)) {
+                migrations.forEach(r => r.visitStylesheet(stylesheet));
+                this._analyzedFiles.add(stylesheet.filePath);
+            }
+        });
+        // In some applications, developers will have global stylesheets which are not
+        // specified in any Angular component. Therefore we allow for additional stylesheets
+        // being specified. We visit them in each migration unless they have been already
+        // discovered before as actual component resource.
+        if (additionalStylesheetPaths) {
+            additionalStylesheetPaths.forEach(filePath => {
+                const resolvedPath = this._fileSystem.resolve(filePath);
+                const stylesheet = resourceCollector.resolveExternalStylesheet(resolvedPath, null);
+                // Do not visit stylesheets which have been referenced from a component.
+                if (!this._analyzedFiles.has(resolvedPath) && stylesheet) {
+                    migrations.forEach(r => r.visitStylesheet(stylesheet));
+                    this._analyzedFiles.add(resolvedPath);
+                }
+            });
+        }
+        // Call the "postAnalysis" method for each migration.
+        migrations.forEach(r => r.postAnalysis());
+        // Collect all failures reported by individual migrations.
+        const failures = migrations.reduce((res, m) => res.concat(m.failures), []);
+        // In case there are failures, print these to the CLI logger as warnings.
+        if (failures.length) {
+            failures.forEach(({ filePath, message, position }) => {
+                const lineAndCharacter = position ? `@${position.line + 1}:${position.character + 1}` : '';
+                this._logger.warn(`${filePath}${lineAndCharacter} - ${message}`);
+            });
+        }
+        return {
+            hasFailures: !!failures.length,
+        };
+    }
+    /**
+     * Creates instances of the given migrations with the specified target
+     * version and data.
+     */
+    _createMigrations(types, target, data) {
+        const result = [];
+        for (const ctor of types) {
+            const instance = new ctor(this._program, this._typeChecker, target, this._context, data, this._fileSystem, this._logger);
+            instance.init();
+            if (instance.enabled) {
+                result.push(instance);
+            }
+        }
+        return result;
+    }
+    /**
+     * Creates a program form the specified tsconfig and patches the host
+     * to read files and directories through the given file system.
+     */
+    static createProgramFromTsconfig(tsconfigPath, fs) {
+        const parsed = parse_tsconfig_1.parseTsconfigFile(fs.resolve(tsconfigPath), fs);
+        const host = virtual_host_1.createFileSystemCompilerHost(parsed.options, fs);
+        return ts.createProgram(parsed.fileNames, parsed.options, host);
+    }
+}
+exports.UpdateProject = UpdateProject;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../src/cdk/schematics/update-tool/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 * as ts from 'typescript';\n\nimport {ComponentResourceCollector} from './component-resource-collector';\nimport {FileSystem, WorkspacePath} from './file-system';\nimport {defaultLogger, UpdateLogger} from './logger';\nimport {Migration, MigrationCtor, MigrationFailure} from './migration';\nimport {TargetVersion} from './target-version';\nimport {parseTsconfigFile} from './utils/parse-tsconfig';\nimport {createFileSystemCompilerHost} from './utils/virtual-host';\n\n/**\n * An update project that can be run against individual migrations. An update project\n * accepts a TypeScript program and a context that is provided to all migrations. The\n * context is usually not used by migrations, but in some cases migrations rely on\n * specifics from the tool that performs the update (e.g. the Angular CLI). In those cases,\n * the context can provide the necessary specifics to the migrations in a type-safe way.\n */\nexport class UpdateProject<Context> {\n  private readonly _typeChecker: ts.TypeChecker = this._program.getTypeChecker();\n\n  constructor(/** Context provided to all migrations. */\n              private _context: Context,\n              /** TypeScript program using workspace paths. */\n              private _program: ts.Program,\n              /** File system used for reading, writing and editing files. */\n              private _fileSystem: FileSystem,\n              /**\n               * Set of analyzed files. Used for avoiding multiple migration runs if\n               * files overlap between targets.\n               */\n              private _analyzedFiles: Set<WorkspacePath> = new Set(),\n              /** Logger used for printing messages. */\n              private _logger: UpdateLogger = defaultLogger) {}\n\n  /**\n   * Migrates the project to the specified target version.\n   * @param migrationTypes Migrations that should be run.\n   * @param target Version the project should be updated to.\n   * @param data Upgrade data that is passed to all migration rules.\n   * @param additionalStylesheetPaths Additional stylesheets that should be migrated, if not\n   *   referenced in an Angular component. This is helpful for global stylesheets in a project.\n   */\n  migrate<Data>(migrationTypes: MigrationCtor<Data, Context>[], target: TargetVersion, data: Data,\n      additionalStylesheetPaths?: string[]): {hasFailures: boolean} {\n    // Create instances of the specified migrations.\n    const migrations = this._createMigrations(migrationTypes, target, data);\n    // Creates the component resource collector. The collector can visit arbitrary\n    // TypeScript nodes and will find Angular component resources. Resources include\n    // templates and stylesheets. It also captures inline stylesheets and templates.\n    const resourceCollector = new ComponentResourceCollector(this._typeChecker, this._fileSystem);\n    // Collect all of the TypeScript source files we want to migrate. We don't\n    // migrate type definition files, or source files from external libraries.\n    const sourceFiles = this._program.getSourceFiles().filter(\n      f => !f.isDeclarationFile && !this._program.isSourceFileFromExternalLibrary(f));\n\n    // Helper function that visits a given TypeScript node and collects all referenced\n    // component resources (i.e. stylesheets or templates). Additionally, the helper\n    // visits the node in each instantiated migration.\n    const visitNodeAndCollectResources = (node: ts.Node) => {\n      migrations.forEach(r => r.visitNode(node));\n      ts.forEachChild(node, visitNodeAndCollectResources);\n      resourceCollector.visitNode(node);\n    };\n\n    // Walk through all source file, if it has not been visited before, and\n    // visit found nodes while collecting potential resources.\n    sourceFiles.forEach(sourceFile => {\n      const resolvedPath = this._fileSystem.resolve(sourceFile.fileName);\n      // Do not visit source files which have been checked as part of a\n      // previously migrated TypeScript project.\n      if (!this._analyzedFiles.has(resolvedPath)) {\n        visitNodeAndCollectResources(sourceFile);\n        this._analyzedFiles.add(resolvedPath);\n      }\n    });\n\n    // Walk through all resolved templates and visit them in each instantiated\n    // migration. Note that this can only happen after source files have been\n    // visited because we find templates through the TypeScript source files.\n    resourceCollector.resolvedTemplates.forEach(template => {\n      // Do not visit the template if it has been checked before. Inline\n      // templates cannot be referenced multiple times.\n      if (template.inline || !this._analyzedFiles.has(template.filePath)) {\n        migrations.forEach(m => m.visitTemplate(template));\n        this._analyzedFiles.add(template.filePath);\n      }\n    });\n\n    // Walk through all resolved stylesheets and visit them in each instantiated\n    // migration. Note that this can only happen after source files have been\n    // visited because we find stylesheets through the TypeScript source files.\n    resourceCollector.resolvedStylesheets.forEach(stylesheet => {\n      // Do not visit the stylesheet if it has been checked before. Inline\n      // stylesheets cannot be referenced multiple times.\n      if (stylesheet.inline || !this._analyzedFiles.has(stylesheet.filePath)) {\n        migrations.forEach(r => r.visitStylesheet(stylesheet));\n        this._analyzedFiles.add(stylesheet.filePath);\n      }\n    });\n\n    // In some applications, developers will have global stylesheets which are not\n    // specified in any Angular component. Therefore we allow for additional stylesheets\n    // being specified. We visit them in each migration unless they have been already\n    // discovered before as actual component resource.\n    if (additionalStylesheetPaths) {\n      additionalStylesheetPaths.forEach(filePath => {\n        const resolvedPath = this._fileSystem.resolve(filePath);\n        const stylesheet = resourceCollector.resolveExternalStylesheet(resolvedPath, null);\n        // Do not visit stylesheets which have been referenced from a component.\n        if (!this._analyzedFiles.has(resolvedPath) && stylesheet) {\n          migrations.forEach(r => r.visitStylesheet(stylesheet));\n          this._analyzedFiles.add(resolvedPath);\n        }\n      });\n    }\n\n    // Call the \"postAnalysis\" method for each migration.\n    migrations.forEach(r => r.postAnalysis());\n\n    // Collect all failures reported by individual migrations.\n    const failures = migrations.reduce((res, m) =>\n        res.concat(m.failures), [] as MigrationFailure[]);\n\n    // In case there are failures, print these to the CLI logger as warnings.\n    if (failures.length) {\n      failures.forEach(({filePath, message, position}) => {\n        const lineAndCharacter = position ? `@${position.line + 1}:${position.character + 1}` : '';\n        this._logger.warn(`${filePath}${lineAndCharacter} - ${message}`);\n      });\n    }\n\n    return {\n      hasFailures: !!failures.length,\n    };\n  }\n\n  /**\n   * Creates instances of the given migrations with the specified target\n   * version and data.\n   */\n  private _createMigrations<Data>(types: MigrationCtor<Data, Context>[], target: TargetVersion,\n                                  data: Data): Migration<Data, Context>[] {\n    const result: Migration<Data, Context>[] = [];\n    for (const ctor of types) {\n      const instance = new ctor(this._program, this._typeChecker, target, this._context,\n        data, this._fileSystem, this._logger);\n      instance.init();\n      if (instance.enabled) {\n        result.push(instance);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Creates a program form the specified tsconfig and patches the host\n   * to read files and directories through the given file system.\n   */\n  static createProgramFromTsconfig(tsconfigPath: WorkspacePath, fs: FileSystem): ts.Program {\n    const parsed = parseTsconfigFile(fs.resolve(tsconfigPath), fs);\n    const host = createFileSystemCompilerHost(parsed.options, fs);\n    return ts.createProgram(parsed.fileNames, parsed.options, host);\n  }\n}\n"]}

package/schematics/update-tool/logger.mjs

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLogger = void 0;
+exports.defaultLogger = {
+    debug: m => console.debug(m),
+    error: m => console.error(m),
+    fatal: m => console.error(m),
+    info: m => console.info(m),
+    warn: m => console.warn(m),
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay9zY2hlbWF0aWNzL3VwZGF0ZS10b29sL2xvZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFVVSxRQUFBLGFBQWEsR0FBaUI7SUFDekMsS0FBSyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDNUIsS0FBSyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDNUIsS0FBSyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDNUIsSUFBSSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDMUIsSUFBSSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7Q0FDM0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIFVwZGF0ZUxvZ2dlciB7XG4gIGRlYnVnKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gIGVycm9yKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gIGZhdGFsKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gIGluZm8obWVzc2FnZTogc3RyaW5nKTogdm9pZDtcbiAgd2FybihtZXNzYWdlOiBzdHJpbmcpOiB2b2lkO1xufVxuXG5leHBvcnQgY29uc3QgZGVmYXVsdExvZ2dlcjogVXBkYXRlTG9nZ2VyID0ge1xuICBkZWJ1ZzogbSA9PiBjb25zb2xlLmRlYnVnKG0pLFxuICBlcnJvcjogbSA9PiBjb25zb2xlLmVycm9yKG0pLFxuICBmYXRhbDogbSA9PiBjb25zb2xlLmVycm9yKG0pLFxuICBpbmZvOiBtID0+IGNvbnNvbGUuaW5mbyhtKSxcbiAgd2FybjogbSA9PiBjb25zb2xlLndhcm4obSksXG59O1xuIl19