@angular/cdk 9.2.1 → 9.2.2

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":"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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 {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;

package/schematics/update-tool/logger.js

@@ -0,0 +1,27 @@
+/**
+ * @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/logger", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay9zY2hlbWF0aWNzL3VwZGF0ZS10b29sL2xvZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7OztJQVVVLFFBQUEsYUFBYSxHQUFpQjtRQUN6QyxLQUFLLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztRQUM1QixLQUFLLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztRQUM1QixLQUFLLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztRQUM1QixJQUFJLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUMxQixJQUFJLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztLQUMzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgVXBkYXRlTG9nZ2VyIHtcbiAgZGVidWcobWVzc2FnZTogc3RyaW5nKTogdm9pZDtcbiAgZXJyb3IobWVzc2FnZTogc3RyaW5nKTogdm9pZDtcbiAgZmF0YWwobWVzc2FnZTogc3RyaW5nKTogdm9pZDtcbiAgaW5mbyhtZXNzYWdlOiBzdHJpbmcpOiB2b2lkO1xuICB3YXJuKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG59XG5cbmV4cG9ydCBjb25zdCBkZWZhdWx0TG9nZ2VyOiBVcGRhdGVMb2dnZXIgPSB7XG4gIGRlYnVnOiBtID0+IGNvbnNvbGUuZGVidWcobSksXG4gIGVycm9yOiBtID0+IGNvbnNvbGUuZXJyb3IobSksXG4gIGZhdGFsOiBtID0+IGNvbnNvbGUuZXJyb3IobSksXG4gIGluZm86IG0gPT4gY29uc29sZS5pbmZvKG0pLFxuICB3YXJuOiBtID0+IGNvbnNvbGUud2FybihtKSxcbn07XG4iXX0=

package/schematics/update-tool/{migration-rule.d.ts → migration.d.ts}

@@ -5,12 +5,11 @@
  * 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/migration-rule" />
-import { logging } from '@angular-devkit/core';
-import { SchematicContext, Tree, UpdateRecorder } from '@angular-devkit/schematics';
-import { WorkspaceProject } from '@schematics/angular/utility/workspace-models';
+/// <amd-module name="@angular/cdk/schematics/update-tool/migration" />
 import * as ts from 'typescript';
 import { ResolvedResource } from './component-resource-collector';
+import { FileSystem } from './file-system';
+import { UpdateLogger } from './logger';
 import { TargetVersion } from './target-version';
 import { LineAndCharacter } from './utils/line-mappings';
 export interface MigrationFailure {
@@ -22,56 +21,44 @@ export declare type PostMigrationAction = void | {
     /** Whether the package manager should run upon migration completion. */
     runPackageManager: boolean;
 };
-export declare class MigrationRule<T> {
-    /** Workspace project the migration rule runs against. */
-    project: WorkspaceProject;
+/** Creates a constructor type for the specified type. */
+export declare type Constructor<T> = (new (...args: any[]) => T);
+/** Gets a constructor type for the passed migration data. */
+export declare type MigrationCtor<Data, Context = never> = Constructor<Migration<Data, Context>>;
+export declare abstract class Migration<Data, Context = never> {
     /** TypeScript program for the migration. */
     program: ts.Program;
     /** TypeChecker instance for the analysis program. */
     typeChecker: ts.TypeChecker;
     /** Version for which the migration rule should run. */
     targetVersion: TargetVersion;
+    /** Context data for the migration. */
+    context: Context;
     /** Upgrade data passed to the migration. */
-    upgradeData: T;
-    /** Devkit tree for the current migration. Can be used to insert/remove files. */
-    tree: Tree;
-    /** Gets the update recorder for a given source file or resolved template. */
-    getUpdateRecorder: (filePath: string) => UpdateRecorder;
-    /** Base directory of the virtual file system tree. */
-    basePath: string;
+    upgradeData: Data;
+    /** File system that can be used for modifying files. */
+    fileSystem: FileSystem;
     /** Logger that can be used to print messages as part of the migration. */
-    logger: logging.LoggerApi;
-    /** Whether the migration runs for a test target. */
-    isTestTarget: boolean;
-    /** Path to the tsconfig that is migrated. */
-    tsconfigPath: string;
+    logger: UpdateLogger;
     /** List of migration failures that need to be reported. */
     failures: MigrationFailure[];
-    /** Whether the migration rule is enabled or not. */
-    ruleEnabled: boolean;
+    /** Whether the migration is enabled or not. */
+    abstract enabled: boolean;
     constructor(
-    /** Workspace project the migration rule runs against. */
-    project: WorkspaceProject, 
     /** TypeScript program for the migration. */
     program: ts.Program, 
     /** TypeChecker instance for the analysis program. */
     typeChecker: ts.TypeChecker, 
     /** Version for which the migration rule should run. */
     targetVersion: TargetVersion, 
+    /** Context data for the migration. */
+    context: Context, 
     /** Upgrade data passed to the migration. */
-    upgradeData: T, 
-    /** Devkit tree for the current migration. Can be used to insert/remove files. */
-    tree: Tree, 
-    /** Gets the update recorder for a given source file or resolved template. */
-    getUpdateRecorder: (filePath: string) => UpdateRecorder, 
-    /** Base directory of the virtual file system tree. */
-    basePath: string, 
+    upgradeData: Data, 
+    /** File system that can be used for modifying files. */
+    fileSystem: FileSystem, 
     /** Logger that can be used to print messages as part of the migration. */
-    logger: logging.LoggerApi, 
-    /** Whether the migration runs for a test target. */
-    isTestTarget: boolean, 
-    /** Path to the tsconfig that is migrated. */
-    tsconfigPath: string);
+    logger: UpdateLogger);
     /** Method can be used to perform global analysis of the program. */
     init(): void;
     /**
@@ -91,14 +78,5 @@ export declare class MigrationRule<T> {
     /** Method that will be called for each stylesheet in the program. */
     visitStylesheet(stylesheet: ResolvedResource): void;
     /** Creates a failure with a specified message at the given node location. */
-    createFailureAtNode(node: ts.Node, message: string): void;
-    /** Prints the specified message with "info" loglevel. */
-    printInfo(text: string): void;
-    /**
-     * Static method that will be called once the migration of all project targets
-     * has been performed. This method can be used to make changes respecting the
-     * migration result of all individual targets. e.g. removing HammerJS if it
-     * is not needed in any project target.
-     */
-    static globalPostMigration(tree: Tree, context: SchematicContext): PostMigrationAction;
+    protected createFailureAtNode(node: ts.Node, message: string): void;
 }

package/schematics/update-tool/migration.js

@@ -0,0 +1,76 @@
+/**
+ * @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/migration", ["require", "exports", "typescript"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const ts = require("typescript");
+    class Migration {
+        constructor(
+        /** TypeScript program for the migration. */
+        program, 
+        /** TypeChecker instance for the analysis program. */
+        typeChecker, 
+        /** Version for which the migration rule should run. */
+        targetVersion, 
+        /** Context data for the migration. */
+        context, 
+        /** Upgrade data passed to the migration. */
+        upgradeData, 
+        /** File system that can be used for modifying files. */
+        fileSystem, 
+        /** Logger that can be used to print messages as part of the migration. */
+        logger) {
+            this.program = program;
+            this.typeChecker = typeChecker;
+            this.targetVersion = targetVersion;
+            this.context = context;
+            this.upgradeData = upgradeData;
+            this.fileSystem = fileSystem;
+            this.logger = logger;
+            /** List of migration failures that need to be reported. */
+            this.failures = [];
+        }
+        /** Method can be used to perform global analysis of the program. */
+        init() { }
+        /**
+         * Method that will be called once all nodes, templates and stylesheets
+         * have been visited.
+         */
+        postAnalysis() { }
+        /**
+         * Method that will be called for each node in a given source file. Unlike tslint, this
+         * function will only retrieve TypeScript nodes that need to be casted manually. This
+         * allows us to only walk the program source files once per program and not per
+         * migration rule (significant performance boost).
+         */
+        visitNode(node) { }
+        /** Method that will be called for each Angular template in the program. */
+        visitTemplate(template) { }
+        /** Method that will be called for each stylesheet in the program. */
+        visitStylesheet(stylesheet) { }
+        /** Creates a failure with a specified message at the given node location. */
+        createFailureAtNode(node, message) {
+            const sourceFile = node.getSourceFile();
+            this.failures.push({
+                filePath: sourceFile.fileName,
+                position: ts.getLineAndCharacterOfPosition(sourceFile, node.getStart()),
+                message: message,
+            });
+        }
+    }
+    exports.Migration = Migration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/update-tool/public-api.d.ts

@@ -6,10 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/cdk/schematics/update-tool/public-api" />
+export * from './component-resource-collector';
+export * from './file-system';
 export * from './index';
+export * from './migration';
 export * from './target-version';
-export * from './version-changes';
-export * from './migration-rule';
-export * from './component-resource-collector';
-export * from './utils/imports';
 export * from './utils/decorators';
+export * from './utils/imports';
+export * from './version-changes';