@angular/cdk
Version:
Angular Material Component Development Kit
134 lines • 23.1 kB
JavaScript
/**
* @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", ["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);
}
})(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 parse_tsconfig_1 = require("@angular/cdk/schematics/update-tool/utils/parse-tsconfig");
function runMigrationRules(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);
// 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(program, typeChecker, targetVersion, upgradeData, tree, getUpdateRecorder, basePath, logger, isTestTarget, tsconfigPath);
rule.init();
if (rule.ruleEnabled) {
rules.push(rule);
}
}
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(devversion): double-check if we can solve this in a more elegant way.
glob_1.sync('!(node_modules|dist)/**/*.+(css|scss)', { absolute: true, cwd: basePath })
.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}`);
});
}
return {
hasFailures: !!ruleFailures.length,
};
function getUpdateRecorder(filePath) {
const treeFilePath = getProjectRelativePath(filePath);
if (updateRecorderCache.has(treeFilePath)) {
return updateRecorderCache.get(treeFilePath);
}
const treeRecorder = tree.beginUpdate(treeFilePath);
updateRecorderCache.set(treeFilePath, treeRecorder);
return treeRecorder;
}
function _visitTypeScriptNode(node) {
rules.forEach(r => r.visitNode(node));
ts.forEachChild(node, _visitTypeScriptNode);
resourceCollector.visitNode(node);
}
/** Gets the specified path relative to the project root in POSIX format. */
function getProjectRelativePath(filePath) {
return path_1.relative(basePath, filePath).replace(/\\/g, '/');
}
}
exports.runMigrationRules = runMigrationRules;
});
//# 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 {sync as globSync} from 'glob';\nimport {dirname, 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> = Constructor<MigrationRule<T>>\n    & {[m in keyof typeof MigrationRule]: (typeof MigrationRule)[m]};\n\n\nexport function runMigrationRules<T>(\n    tree: Tree, logger: logging.LoggerApi, tsconfigPath: string, isTestTarget: boolean,\n    targetVersion: TargetVersion, ruleTypes: MigrationRuleType<T>[], upgradeData: T,\n    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\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        program, typeChecker, targetVersion, upgradeData, tree, getUpdateRecorder, basePath, logger,\n        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(devversion): double-check if we can solve this in a more elegant way.\n  globSync('!(node_modules|dist)/**/*.+(css|scss)', {absolute: true, cwd: basePath})\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"]}