@angular/cdk 9.1.3 → 9.2.2

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

@@ -11,12 +11,11 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/cdk/schematics/update-tool/component-resource-collector", ["require", "exports", "fs", "path", "typescript", "@angular/cdk/schematics/update-tool/utils/decorators", "@angular/cdk/schematics/update-tool/utils/functions", "@angular/cdk/schematics/update-tool/utils/line-mappings", "@angular/cdk/schematics/update-tool/utils/property-name"], factory);
+        define("@angular/cdk/schematics/update-tool/component-resource-collector", ["require", "exports", "path", "typescript", "@angular/cdk/schematics/update-tool/utils/decorators", "@angular/cdk/schematics/update-tool/utils/functions", "@angular/cdk/schematics/update-tool/utils/line-mappings", "@angular/cdk/schematics/update-tool/utils/property-name"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    const fs_1 = require("fs");
     const path_1 = require("path");
     const ts = require("typescript");
     const decorators_1 = require("@angular/cdk/schematics/update-tool/utils/decorators");
@@ -28,8 +27,9 @@
      * given TypeScript source files (inline or external referenced files)
      */
     class ComponentResourceCollector {
-        constructor(typeChecker) {
+        constructor(typeChecker, _fileSystem) {
             this.typeChecker = typeChecker;
+            this._fileSystem = _fileSystem;
             this.resolvedTemplates = [];
             this.resolvedStylesheets = [];
         }
@@ -105,7 +105,7 @@
                         if (ts.isStringLiteralLike(el)) {
                             const stylesheetPath = path_1.resolve(path_1.dirname(sourceFileName), el.text);
                             // In case the stylesheet does not exist in the file system, skip it gracefully.
-                            if (!fs_1.existsSync(stylesheetPath)) {
+                            if (!this._fileSystem.exists(stylesheetPath)) {
                                 return;
                             }
                             this.resolvedStylesheets.push(this.resolveExternalStylesheet(stylesheetPath, node));
@@ -116,10 +116,10 @@
                     const templatePath = path_1.resolve(path_1.dirname(sourceFileName), property.initializer.text);
                     // In case the template does not exist in the file system, skip this
                     // external template.
-                    if (!fs_1.existsSync(templatePath)) {
+                    if (!this._fileSystem.exists(templatePath)) {
                         return;
                     }
-                    const fileContent = fs_1.readFileSync(templatePath, 'utf8');
+                    const fileContent = this._fileSystem.read(templatePath);
                     const lineStartsMap = line_mappings_1.computeLineStartsMap(fileContent);
                     this.resolvedTemplates.push({
                         filePath: templatePath,
@@ -134,7 +134,7 @@
         }
         /** Resolves an external stylesheet by reading its content and computing line mappings. */
         resolveExternalStylesheet(filePath, container) {
-            const fileContent = fs_1.readFileSync(filePath, 'utf8');
+            const fileContent = this._fileSystem.read(filePath);
             const lineStartsMap = line_mappings_1.computeLineStartsMap(fileContent);
             return {
                 filePath: filePath,
@@ -148,4 +148,4 @@
     }
     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 {existsSync, readFileSync} from 'fs';\nimport {dirname, resolve} from 'path';\nimport * as ts from 'typescript';\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: string;\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) {}\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 sourceFileName = sourceFile.fileName;\n\n    // Walk through all component metadata properties and determine the referenced\n    // HTML templates (either external or inline)\n    componentMetadata.properties.forEach(property => {\n      if (!ts.isPropertyAssignment(property)) {\n        return;\n      }\n\n      const propertyName = getPropertyNameText(property.name);\n      const filePath = resolve(sourceFileName);\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: 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: 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 = resolve(dirname(sourceFileName), el.text);\n\n            // In case the stylesheet does not exist in the file system, skip it gracefully.\n            if (!existsSync(stylesheetPath)) {\n              return;\n            }\n\n            this.resolvedStylesheets.push(this.resolveExternalStylesheet(stylesheetPath, node));\n          }\n        });\n      }\n\n      if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {\n        const templatePath = resolve(dirname(sourceFileName), property.initializer.text);\n\n        // In case the template does not exist in the file system, skip this\n        // external template.\n        if (!existsSync(templatePath)) {\n          return;\n        }\n\n        const fileContent = readFileSync(templatePath, 'utf8');\n        const lineStartsMap = computeLineStartsMap(fileContent);\n\n        this.resolvedTemplates.push({\n          filePath: templatePath,\n          container: node,\n          content: fileContent,\n          inline: false,\n          start: 0,\n          getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),\n        });\n      }\n    });\n  }\n\n  /** Resolves an external stylesheet by reading its content and computing line mappings. */\n  resolveExternalStylesheet(filePath: string, container: ts.ClassDeclaration|null):\n      ResolvedResource {\n    const fileContent = readFileSync(filePath, 'utf8');\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"]}
+//# 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, resolve} from 'path';\nimport * as ts from 'typescript';\nimport {FileSystem} 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: string;\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 sourceFileName = sourceFile.fileName;\n\n    // Walk through all component metadata properties and determine the referenced\n    // HTML templates (either external or inline)\n    componentMetadata.properties.forEach(property => {\n      if (!ts.isPropertyAssignment(property)) {\n        return;\n      }\n\n      const propertyName = getPropertyNameText(property.name);\n      const filePath = resolve(sourceFileName);\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: 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: 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 = resolve(dirname(sourceFileName), el.text);\n\n            // In case the stylesheet does not exist in the file system, skip it gracefully.\n            if (!this._fileSystem.exists(stylesheetPath)) {\n              return;\n            }\n\n            this.resolvedStylesheets.push(this.resolveExternalStylesheet(stylesheetPath, node));\n          }\n        });\n      }\n\n      if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {\n        const templatePath = resolve(dirname(sourceFileName), property.initializer.text);\n\n        // In case the template does not exist in the file system, skip this\n        // external template.\n        if (!this._fileSystem.exists(templatePath)) {\n          return;\n        }\n\n        const fileContent = this._fileSystem.read(templatePath);\n        const lineStartsMap = computeLineStartsMap(fileContent);\n\n        this.resolvedTemplates.push({\n          filePath: templatePath,\n          container: node,\n          content: fileContent,\n          inline: false,\n          start: 0,\n          getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),\n        });\n      }\n    });\n  }\n\n  /** Resolves an external stylesheet by reading its content and computing line mappings. */\n  resolveExternalStylesheet(filePath: string, container: ts.ClassDeclaration|null):\n      ResolvedResource {\n    const fileContent = this._fileSystem.read(filePath);\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.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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/cdk/schematics/update-tool/file-system" />
+import { UpdateRecorder } from './update-recorder';
+/**
+ * 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.
+ */
+export interface FileSystem {
+    /**
+     * Resolves an absolute path to a unique path in the file system. For example,
+     * the devkit tree considers the workspace as disk root in paths.
+     */
+    resolve(fsFilePath: string): string;
+    /** Checks whether a given file exists. */
+    exists(fsFilePath: string): boolean;
+    /** Gets the contents of the given file. */
+    read(fsFilePath: string): string | null;
+    /**
+     * Creates an update recorder for the given file. Edits can be recorded and
+     * committed in batches. Changes are not applied automatically because otherwise
+     * migrations would need to re-read files, or account for shifted file contents.
+     */
+    edit(fsFilePath: string): UpdateRecorder;
+    /** Applies all changes which have been recorded in update recorders. */
+    commitEdits(): void;
+    /** Creates a new file with the given content. */
+    create(fsFilePath: string, content: string): any;
+    /** Overwrites an existing file with the given content. */
+    overwrite(fsFilePath: string, content: string): any;
+    /** Deletes the given file. */
+    delete(fsFilePath: string): any;
+}

package/schematics/update-tool/file-system.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/cdk/schematics/update-tool/file-system", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/update-tool/index.d.ts

@@ -6,15 +6,45 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/cdk/schematics/update-tool" />
-import { logging } from '@angular-devkit/core';
-import { Tree } from '@angular-devkit/schematics';
-import { WorkspaceProject } from '@schematics/angular/utility/workspace-models';
-import { MigrationRule } from './migration-rule';
+import * as ts from 'typescript';
+import { FileSystem } from './file-system';
+import { UpdateLogger } from './logger';
+import { MigrationCtor } from './migration';
 import { TargetVersion } from './target-version';
-export declare type Constructor<T> = (new (...args: any[]) => T);
-export declare type MigrationRuleType<T> = Constructor<MigrationRule<T>> & {
-    [m in keyof typeof MigrationRule]: (typeof MigrationRule)[m];
-};
-export declare function runMigrationRules<T>(project: WorkspaceProject, tree: Tree, logger: logging.LoggerApi, tsconfigPath: string, isTestTarget: boolean, targetVersion: TargetVersion, ruleTypes: MigrationRuleType<T>[], upgradeData: T, analyzedFiles: Set<string>): {
-    hasFailures: boolean;
-};
+/**
+ * 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.
+ */
+export declare class UpdateProject<Context> {
+    private _context;
+    private _program;
+    private _fileSystem;
+    private _analyzedFiles;
+    private _logger;
+    private readonly _typeChecker;
+    constructor(_context: Context, _program: ts.Program, _fileSystem: FileSystem, _analyzedFiles?: Set<string>, _logger?: UpdateLogger);
+    /**
+     * 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<Data>(migrationTypes: MigrationCtor<Data, Context>[], target: TargetVersion, data: Data, additionalStylesheetPaths?: string[]): {
+        hasFailures: boolean;
+    };
+    /**
+     * Creates instances of the given migrations with the specified target
+     * version and data.
+     */
+    private _createMigrations;
+    /**
+     * Creates a program form the specified tsconfig and patches the host
+     * to read files through the given file system.
+     */
+    static createProgramFromTsconfig(tsconfigFsPath: string, fs: FileSystem): ts.Program;
+}

package/schematics/update-tool/index.js

@@ -11,125 +11,154 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/cdk/schematics/update-tool", ["require", "exports", "@angular-devkit/core", "glob", "path", "typescript", "@angular/cdk/schematics/update-tool/component-resource-collector", "@angular/cdk/schematics/update-tool/utils/parse-tsconfig"], factory);
+        define("@angular/cdk/schematics/update-tool", ["require", "exports", "path", "typescript", "@angular/cdk/schematics/update-tool/component-resource-collector", "@angular/cdk/schematics/update-tool/logger", "@angular/cdk/schematics/update-tool/utils/parse-tsconfig"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    const core_1 = require("@angular-devkit/core");
-    const glob_1 = require("glob");
     const path_1 = require("path");
     const ts = require("typescript");
     const component_resource_collector_1 = require("@angular/cdk/schematics/update-tool/component-resource-collector");
+    const logger_1 = require("@angular/cdk/schematics/update-tool/logger");
     const parse_tsconfig_1 = require("@angular/cdk/schematics/update-tool/utils/parse-tsconfig");
-    function runMigrationRules(project, tree, logger, tsconfigPath, isTestTarget, targetVersion, ruleTypes, upgradeData, analyzedFiles) {
-        // The CLI uses the working directory as the base directory for the
-        // virtual file system tree.
-        const basePath = process.cwd();
-        const parsed = parse_tsconfig_1.parseTsconfigFile(tsconfigPath, path_1.dirname(tsconfigPath));
-        const host = ts.createCompilerHost(parsed.options, true);
-        const projectFsPath = path_1.join(basePath, project.root);
-        // We need to overwrite the host "readFile" method, as we want the TypeScript
-        // program to be based on the file contents in the virtual file tree.
-        host.readFile = fileName => {
-            const buffer = tree.read(getProjectRelativePath(fileName));
-            // Strip BOM as otherwise TSC methods (e.g. "getWidth") will return an offset which
-            // which breaks the CLI UpdateRecorder. https://github.com/angular/angular/pull/30719
-            return buffer ? buffer.toString().replace(/^\uFEFF/, '') : undefined;
-        };
-        const program = ts.createProgram(parsed.fileNames, parsed.options, host);
-        const typeChecker = program.getTypeChecker();
-        const rules = [];
-        // Create instances of all specified migration rules.
-        for (const ruleCtor of ruleTypes) {
-            const rule = new ruleCtor(project, program, typeChecker, targetVersion, upgradeData, tree, getUpdateRecorder, basePath, logger, isTestTarget, tsconfigPath);
-            rule.init();
-            if (rule.ruleEnabled) {
-                rules.push(rule);
-            }
+    /**
+     * 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, _program, _fileSystem, _analyzedFiles = new Set(), _logger = logger_1.defaultLogger) {
+            this._context = _context;
+            this._program = _program;
+            this._fileSystem = _fileSystem;
+            this._analyzedFiles = _analyzedFiles;
+            this._logger = _logger;
+            this._typeChecker = this._program.getTypeChecker();
         }
-        const sourceFiles = program.getSourceFiles().filter(f => !f.isDeclarationFile && !program.isSourceFileFromExternalLibrary(f));
-        const resourceCollector = new component_resource_collector_1.ComponentResourceCollector(typeChecker);
-        const updateRecorderCache = new Map();
-        sourceFiles.forEach(sourceFile => {
-            const relativePath = getProjectRelativePath(sourceFile.fileName);
-            // Do not visit source files which have been checked as part of a
-            // previously migrated TypeScript project.
-            if (!analyzedFiles.has(relativePath)) {
-                _visitTypeScriptNode(sourceFile);
-                analyzedFiles.add(relativePath);
-            }
-        });
-        resourceCollector.resolvedTemplates.forEach(template => {
-            const relativePath = getProjectRelativePath(template.filePath);
-            // Do not visit the template if it has been checked before. Inline
-            // templates cannot be referenced multiple times.
-            if (template.inline || !analyzedFiles.has(relativePath)) {
-                rules.forEach(r => r.visitTemplate(template));
-                analyzedFiles.add(relativePath);
-            }
-        });
-        resourceCollector.resolvedStylesheets.forEach(stylesheet => {
-            const relativePath = getProjectRelativePath(stylesheet.filePath);
-            // Do not visit the stylesheet if it has been checked before. Inline
-            // stylesheets cannot be referenced multiple times.
-            if (stylesheet.inline || !analyzedFiles.has(relativePath)) {
-                rules.forEach(r => r.visitStylesheet(stylesheet));
-                analyzedFiles.add(relativePath);
-            }
-        });
-        // In some applications, developers will have global stylesheets which are not specified in any
-        // Angular component. Therefore we glob up all CSS and SCSS files outside of node_modules and
-        // dist. The files will be read by the individual stylesheet rules and checked.
-        // TODO: rework this to collect external/global stylesheets from the workspace config. COMP-280.
-        glob_1.sync('!(node_modules|dist)/**/*.+(css|scss)', { absolute: true, cwd: projectFsPath, nodir: true })
-            .filter(filePath => !resourceCollector.resolvedStylesheets.some(s => s.filePath === filePath))
-            .forEach(filePath => {
-            const stylesheet = resourceCollector.resolveExternalStylesheet(filePath, null);
-            const relativePath = getProjectRelativePath(filePath);
-            // do not visit stylesheets which have been referenced from a component.
-            if (!analyzedFiles.has(relativePath)) {
-                rules.forEach(r => r.visitStylesheet(stylesheet));
-            }
-        });
-        // Call the "postAnalysis" method for each migration rule.
-        rules.forEach(r => r.postAnalysis());
-        // Commit all recorded updates in the update recorder. We need to perform the
-        // replacements per source file in order to ensure that offsets in the TypeScript
-        // program are not incorrectly shifted.
-        updateRecorderCache.forEach(recorder => tree.commitUpdate(recorder));
-        // Collect all failures reported by individual migration rules.
-        const ruleFailures = rules.reduce((res, rule) => res.concat(rule.failures), []);
-        // In case there are rule failures, print these to the CLI logger as warnings.
-        if (ruleFailures.length) {
-            ruleFailures.forEach(({ filePath, message, position }) => {
-                const normalizedFilePath = core_1.normalize(getProjectRelativePath(filePath));
-                const lineAndCharacter = position ? `@${position.line + 1}:${position.character + 1}` : '';
-                logger.warn(`${normalizedFilePath}${lineAndCharacter} - ${message}`);
+        /**
+         * 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);
+                }
             });
-        }
-        return {
-            hasFailures: !!ruleFailures.length,
-        };
-        function getUpdateRecorder(filePath) {
-            const treeFilePath = getProjectRelativePath(filePath);
-            if (updateRecorderCache.has(treeFilePath)) {
-                return updateRecorderCache.get(treeFilePath);
+            // 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 => {
+                const resolvedPath = this._fileSystem.resolve(template.filePath);
+                // Do not visit the template if it has been checked before. Inline
+                // templates cannot be referenced multiple times.
+                if (template.inline || !this._analyzedFiles.has(resolvedPath)) {
+                    migrations.forEach(m => m.visitTemplate(template));
+                    this._analyzedFiles.add(resolvedPath);
+                }
+            });
+            // 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 => {
+                const resolvedPath = this._fileSystem.resolve(stylesheet.filePath);
+                // Do not visit the stylesheet if it has been checked before. Inline
+                // stylesheets cannot be referenced multiple times.
+                if (stylesheet.inline || !this._analyzedFiles.has(resolvedPath)) {
+                    migrations.forEach(r => r.visitStylesheet(stylesheet));
+                    this._analyzedFiles.add(resolvedPath);
+                }
+            });
+            // 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.
+            additionalStylesheetPaths.forEach(filePath => {
+                const stylesheet = resourceCollector.resolveExternalStylesheet(filePath, null);
+                const resolvedPath = this._fileSystem.resolve(filePath);
+                // Do not visit stylesheets which have been referenced from a component.
+                if (!this._analyzedFiles.has(resolvedPath)) {
+                    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 posixFilePath = this._fileSystem.resolve(filePath).replace(/\\/g, '/');
+                    const lineAndCharacter = position ? `@${position.line + 1}:${position.character + 1}` : '';
+                    this._logger.warn(`${posixFilePath}${lineAndCharacter} - ${message}`);
+                });
             }
-            const treeRecorder = tree.beginUpdate(treeFilePath);
-            updateRecorderCache.set(treeFilePath, treeRecorder);
-            return treeRecorder;
+            return {
+                hasFailures: !!failures.length,
+            };
         }
-        function _visitTypeScriptNode(node) {
-            rules.forEach(r => r.visitNode(node));
-            ts.forEachChild(node, _visitTypeScriptNode);
-            resourceCollector.visitNode(node);
+        /**
+         * 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;
         }
-        /** Gets the specified path relative to the project root in POSIX format. */
-        function getProjectRelativePath(filePath) {
-            return path_1.relative(basePath, filePath).replace(/\\/g, '/');
+        /**
+         * Creates a program form the specified tsconfig and patches the host
+         * to read files through the given file system.
+         */
+        static createProgramFromTsconfig(tsconfigFsPath, fs) {
+            const parsed = parse_tsconfig_1.parseTsconfigFile(tsconfigFsPath, path_1.dirname(tsconfigFsPath));
+            const host = ts.createCompilerHost(parsed.options, true);
+            // Patch the host to read files through the specified file system.
+            host.readFile = fileName => {
+                const fileContent = fs.read(fileName);
+                // Strip BOM as otherwise TSC methods (e.g. "getWidth") will return an offset which
+                // which breaks the CLI UpdateRecorder. https://github.com/angular/angular/pull/30719
+                return fileContent !== null ? fileContent.replace(/^\uFEFF/, '') : undefined;
+            };
+            return ts.createProgram(parsed.fileNames, parsed.options, host);
         }
     }
-    exports.runMigrationRules = runMigrationRules;
+    exports.UpdateProject = UpdateProject;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../src/cdk/schematics/update-tool/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;IAEH,+CAAwD;IAGxD,+BAAsC;IACtC,+BAA6C;IAC7C,iCAAiC;IAEjC,mHAA0E;IAG1E,6FAAyD;IAOzD,SAAgB,iBAAiB,CAC7B,OAAyB,EAAE,IAAU,EAAE,MAAyB,EAAE,YAAoB,EACtF,YAAqB,EAAE,aAA4B,EAAE,SAAiC,EACtF,WAAc,EAAE,aAA0B;QAC5C,mEAAmE;QACnE,4BAA4B;QAC5B,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,kCAAiB,CAAC,YAAY,EAAE,cAAO,CAAC,YAAY,CAAC,CAAC,CAAC;QACtE,MAAM,IAAI,GAAG,EAAE,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACzD,MAAM,aAAa,GAAG,WAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QAEnD,6EAA6E;QAC7E,qEAAqE;QACrE,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,EAAE;YACzB,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC3D,mFAAmF;YACnF,qFAAqF;YACrF,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACvE,CAAC,CAAC;QAEF,MAAM,OAAO,GAAG,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACzE,MAAM,WAAW,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAuB,EAAE,CAAC;QAErC,qDAAqD;QACrD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE;YAChC,MAAM,IAAI,GAAG,IAAI,QAAQ,CACrB,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,IAAI,EAAE,iBAAiB,EAClF,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;YAClD,IAAI,CAAC,IAAI,EAAE,CAAC;YACZ,IAAI,IAAI,CAAC,WAAW,EAAE;gBACpB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAClB;SACF;QAED,MAAM,WAAW,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,MAAM,CAC/C,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,iBAAiB,IAAI,CAAC,OAAO,CAAC,+BAA+B,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9E,MAAM,iBAAiB,GAAG,IAAI,yDAA0B,CAAC,WAAW,CAAC,CAAC;QACtE,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAA0B,CAAC;QAE9D,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;YAC/B,MAAM,YAAY,GAAG,sBAAsB,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;YACjE,iEAAiE;YACjE,0CAA0C;YAC1C,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;gBACpC,oBAAoB,CAAC,UAAU,CAAC,CAAC;gBACjC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;aACjC;QACH,CAAC,CAAC,CAAC;QAEH,iBAAiB,CAAC,iBAAiB,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YACrD,MAAM,YAAY,GAAG,sBAAsB,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAC/D,kEAAkE;YAClE,iDAAiD;YACjD,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;gBACvD,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC9C,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;aACjC;QACH,CAAC,CAAC,CAAC;QAEH,iBAAiB,CAAC,mBAAmB,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;YACzD,MAAM,YAAY,GAAG,sBAAsB,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;YACjE,oEAAoE;YACpE,mDAAmD;YACnD,IAAI,UAAU,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;gBACzD,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;gBAClD,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;aACjC;QACH,CAAC,CAAC,CAAC;QAEH,+FAA+F;QAC/F,6FAA6F;QAC7F,+EAA+E;QAC/E,gGAAgG;QAChG,WAAQ,CACJ,uCAAuC,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC;aAC1F,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;aAC7F,OAAO,CAAC,QAAQ,CAAC,EAAE;YAClB,MAAM,UAAU,GAAG,iBAAiB,CAAC,yBAAyB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YAC/E,MAAM,YAAY,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;YACtD,wEAAwE;YACxE,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;gBACpC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;aACnD;QACH,CAAC,CAAC,CAAC;QAEP,0DAA0D;QAC1D,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC;QAErC,6EAA6E;QAC7E,iFAAiF;QACjF,uCAAuC;QACvC,mBAAmB,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;QAErE,+DAA+D;QAC/D,MAAM,YAAY,GACd,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAwB,CAAC,CAAC;QAErF,8EAA8E;QAC9E,IAAI,YAAY,CAAC,MAAM,EAAE;YACvB,YAAY,CAAC,OAAO,CAAC,CAAC,EAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAC,EAAE,EAAE;gBACrD,MAAM,kBAAkB,GAAG,gBAAS,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACvE,MAAM,gBAAgB,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,IAAI,GAAG,CAAC,IAAI,QAAQ,CAAC,SAAS,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC3F,MAAM,CAAC,IAAI,CAAC,GAAG,kBAAkB,GAAG,gBAAgB,MAAM,OAAO,EAAE,CAAC,CAAC;YACvE,CAAC,CAAC,CAAC;SACJ;QAED,OAAO;YACL,WAAW,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;SACnC,CAAC;QAEF,SAAS,iBAAiB,CAAC,QAAgB;YACzC,MAAM,YAAY,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;YACtD,IAAI,mBAAmB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;gBACzC,OAAO,mBAAmB,CAAC,GAAG,CAAC,YAAY,CAAE,CAAC;aAC/C;YACD,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;YACpD,mBAAmB,CAAC,GAAG,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;YACpD,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,SAAS,oBAAoB,CAAC,IAAa;YACzC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;YACtC,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC;YAC5C,iBAAiB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACpC,CAAC;QAED,4EAA4E;QAC5E,SAAS,sBAAsB,CAAC,QAAgB;YAC9C,OAAO,eAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;IAnID,8CAmIC","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 {logging, normalize} from '@angular-devkit/core';\nimport {Tree, UpdateRecorder} from '@angular-devkit/schematics';\nimport {WorkspaceProject} from '@schematics/angular/utility/workspace-models';\nimport {sync as globSync} from 'glob';\nimport {dirname, join, relative} from 'path';\nimport * as ts from 'typescript';\n\nimport {ComponentResourceCollector} from './component-resource-collector';\nimport {MigrationFailure, MigrationRule} from './migration-rule';\nimport {TargetVersion} from './target-version';\nimport {parseTsconfigFile} from './utils/parse-tsconfig';\n\nexport type Constructor<T> = (new (...args: any[]) => T);\nexport type MigrationRuleType<T> =\n    Constructor<MigrationRule<T>>&{[m in keyof typeof MigrationRule]: (typeof MigrationRule)[m]};\n\n\nexport function runMigrationRules<T>(\n    project: WorkspaceProject, tree: Tree, logger: logging.LoggerApi, tsconfigPath: string,\n    isTestTarget: boolean, targetVersion: TargetVersion, ruleTypes: MigrationRuleType<T>[],\n    upgradeData: T, analyzedFiles: Set<string>): {hasFailures: boolean} {\n  // The CLI uses the working directory as the base directory for the\n  // virtual file system tree.\n  const basePath = process.cwd();\n  const parsed = parseTsconfigFile(tsconfigPath, dirname(tsconfigPath));\n  const host = ts.createCompilerHost(parsed.options, true);\n  const projectFsPath = join(basePath, project.root);\n\n  // We need to overwrite the host \"readFile\" method, as we want the TypeScript\n  // program to be based on the file contents in the virtual file tree.\n  host.readFile = fileName => {\n    const buffer = tree.read(getProjectRelativePath(fileName));\n    // Strip BOM as otherwise TSC methods (e.g. \"getWidth\") will return an offset which\n    // which breaks the CLI UpdateRecorder. https://github.com/angular/angular/pull/30719\n    return buffer ? buffer.toString().replace(/^\\uFEFF/, '') : undefined;\n  };\n\n  const program = ts.createProgram(parsed.fileNames, parsed.options, host);\n  const typeChecker = program.getTypeChecker();\n  const rules: MigrationRule<T>[] = [];\n\n  // Create instances of all specified migration rules.\n  for (const ruleCtor of ruleTypes) {\n    const rule = new ruleCtor(\n        project, program, typeChecker, targetVersion, upgradeData, tree, getUpdateRecorder,\n        basePath, logger, isTestTarget, tsconfigPath);\n    rule.init();\n    if (rule.ruleEnabled) {\n      rules.push(rule);\n    }\n  }\n\n  const sourceFiles = program.getSourceFiles().filter(\n      f => !f.isDeclarationFile && !program.isSourceFileFromExternalLibrary(f));\n  const resourceCollector = new ComponentResourceCollector(typeChecker);\n  const updateRecorderCache = new Map<string, UpdateRecorder>();\n\n  sourceFiles.forEach(sourceFile => {\n    const relativePath = getProjectRelativePath(sourceFile.fileName);\n    // Do not visit source files which have been checked as part of a\n    // previously migrated TypeScript project.\n    if (!analyzedFiles.has(relativePath)) {\n      _visitTypeScriptNode(sourceFile);\n      analyzedFiles.add(relativePath);\n    }\n  });\n\n  resourceCollector.resolvedTemplates.forEach(template => {\n    const relativePath = getProjectRelativePath(template.filePath);\n    // Do not visit the template if it has been checked before. Inline\n    // templates cannot be referenced multiple times.\n    if (template.inline || !analyzedFiles.has(relativePath)) {\n      rules.forEach(r => r.visitTemplate(template));\n      analyzedFiles.add(relativePath);\n    }\n  });\n\n  resourceCollector.resolvedStylesheets.forEach(stylesheet => {\n    const relativePath = getProjectRelativePath(stylesheet.filePath);\n    // Do not visit the stylesheet if it has been checked before. Inline\n    // stylesheets cannot be referenced multiple times.\n    if (stylesheet.inline || !analyzedFiles.has(relativePath)) {\n      rules.forEach(r => r.visitStylesheet(stylesheet));\n      analyzedFiles.add(relativePath);\n    }\n  });\n\n  // In some applications, developers will have global stylesheets which are not specified in any\n  // Angular component. Therefore we glob up all CSS and SCSS files outside of node_modules and\n  // dist. The files will be read by the individual stylesheet rules and checked.\n  // TODO: rework this to collect external/global stylesheets from the workspace config. COMP-280.\n  globSync(\n      '!(node_modules|dist)/**/*.+(css|scss)', {absolute: true, cwd: projectFsPath, nodir: true})\n      .filter(filePath => !resourceCollector.resolvedStylesheets.some(s => s.filePath === filePath))\n      .forEach(filePath => {\n        const stylesheet = resourceCollector.resolveExternalStylesheet(filePath, null);\n        const relativePath = getProjectRelativePath(filePath);\n        // do not visit stylesheets which have been referenced from a component.\n        if (!analyzedFiles.has(relativePath)) {\n          rules.forEach(r => r.visitStylesheet(stylesheet));\n        }\n      });\n\n  // Call the \"postAnalysis\" method for each migration rule.\n  rules.forEach(r => r.postAnalysis());\n\n  // Commit all recorded updates in the update recorder. We need to perform the\n  // replacements per source file in order to ensure that offsets in the TypeScript\n  // program are not incorrectly shifted.\n  updateRecorderCache.forEach(recorder => tree.commitUpdate(recorder));\n\n  // Collect all failures reported by individual migration rules.\n  const ruleFailures =\n      rules.reduce((res, rule) => res.concat(rule.failures), [] as MigrationFailure[]);\n\n  // In case there are rule failures, print these to the CLI logger as warnings.\n  if (ruleFailures.length) {\n    ruleFailures.forEach(({filePath, message, position}) => {\n      const normalizedFilePath = normalize(getProjectRelativePath(filePath));\n      const lineAndCharacter = position ? `@${position.line + 1}:${position.character + 1}` : '';\n      logger.warn(`${normalizedFilePath}${lineAndCharacter} - ${message}`);\n    });\n  }\n\n  return {\n    hasFailures: !!ruleFailures.length,\n  };\n\n  function getUpdateRecorder(filePath: string): UpdateRecorder {\n    const treeFilePath = getProjectRelativePath(filePath);\n    if (updateRecorderCache.has(treeFilePath)) {\n      return updateRecorderCache.get(treeFilePath)!;\n    }\n    const treeRecorder = tree.beginUpdate(treeFilePath);\n    updateRecorderCache.set(treeFilePath, treeRecorder);\n    return treeRecorder;\n  }\n\n  function _visitTypeScriptNode(node: ts.Node) {\n    rules.forEach(r => r.visitNode(node));\n    ts.forEachChild(node, _visitTypeScriptNode);\n    resourceCollector.visitNode(node);\n  }\n\n  /** Gets the specified path relative to the project root in POSIX format. */\n  function getProjectRelativePath(filePath: string) {\n    return relative(basePath, filePath).replace(/\\\\/g, '/');\n  }\n}\n"]}
+//# 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 {dirname} from 'path';\nimport * as ts from 'typescript';\n\nimport {ComponentResourceCollector} from './component-resource-collector';\nimport {FileSystem} 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';\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(private _context: Context,\n              private _program: ts.Program,\n              private _fileSystem: FileSystem,\n              private _analyzedFiles: Set<string> = new Set(),\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      const resolvedPath = this._fileSystem.resolve(template.filePath);\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(resolvedPath)) {\n        migrations.forEach(m => m.visitTemplate(template));\n        this._analyzedFiles.add(resolvedPath);\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      const resolvedPath = this._fileSystem.resolve(stylesheet.filePath);\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(resolvedPath)) {\n        migrations.forEach(r => r.visitStylesheet(stylesheet));\n        this._analyzedFiles.add(resolvedPath);\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    additionalStylesheetPaths.forEach(filePath => {\n      const stylesheet = resourceCollector.resolveExternalStylesheet(filePath, null);\n      const resolvedPath = this._fileSystem.resolve(filePath);\n      // Do not visit stylesheets which have been referenced from a component.\n      if (!this._analyzedFiles.has(resolvedPath)) {\n        migrations.forEach(r => r.visitStylesheet(stylesheet));\n        this._analyzedFiles.add(resolvedPath);\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 posixFilePath = this._fileSystem.resolve(filePath).replace(/\\\\/g, '/');\n        const lineAndCharacter = position ? `@${position.line + 1}:${position.character + 1}` : '';\n        this._logger.warn(`${posixFilePath}${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 through the given file system.\n   */\n  static createProgramFromTsconfig(tsconfigFsPath: string, fs: FileSystem): ts.Program {\n    const parsed = parseTsconfigFile(tsconfigFsPath, dirname(tsconfigFsPath));\n    const host = ts.createCompilerHost(parsed.options, true);\n    // Patch the host to read files through the specified file system.\n    host.readFile = fileName => {\n      const fileContent = fs.read(fileName);\n      // Strip BOM as otherwise TSC methods (e.g. \"getWidth\") will return an offset which\n      // which breaks the CLI UpdateRecorder. https://github.com/angular/angular/pull/30719\n      return fileContent !== null ? fileContent.replace(/^\\uFEFF/, '') : undefined;\n    };\n    return ts.createProgram(parsed.fileNames, parsed.options, host);\n  }\n}\n"]}

package/schematics/update-tool/logger.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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/cdk/schematics/update-tool/logger" />
+export interface UpdateLogger {
+    debug(message: string): void;
+    error(message: string): void;
+    fatal(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+}
+export declare const defaultLogger: UpdateLogger;