@angular/core
Version:
Angular - the core framework
117 lines • 18.9 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/core/schematics/migrations/renderer-to-renderer2", ["require", "exports", "@angular-devkit/schematics", "path", "typescript", "@angular/core/schematics/utils/project_tsconfig_paths", "@angular/core/schematics/utils/typescript/compiler_host", "@angular/core/schematics/migrations/renderer-to-renderer2/helpers", "@angular/core/schematics/migrations/renderer-to-renderer2/migration", "@angular/core/schematics/migrations/renderer-to-renderer2/util"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const schematics_1 = require("@angular-devkit/schematics");
const path_1 = require("path");
const ts = require("typescript");
const project_tsconfig_paths_1 = require("@angular/core/schematics/utils/project_tsconfig_paths");
const compiler_host_1 = require("@angular/core/schematics/utils/typescript/compiler_host");
const helpers_1 = require("@angular/core/schematics/migrations/renderer-to-renderer2/helpers");
const migration_1 = require("@angular/core/schematics/migrations/renderer-to-renderer2/migration");
const util_1 = require("@angular/core/schematics/migrations/renderer-to-renderer2/util");
const MODULE_AUGMENTATION_FILENAME = 'ɵɵRENDERER_MIGRATION_CORE_AUGMENTATION.d.ts';
/**
* Migration that switches from `Renderer` to `Renderer2`. More information on how it works:
* https://hackmd.angular.io/UTzUZTnPRA-cSa_4mHyfYw
*/
function default_1() {
return (tree) => {
const { buildPaths, testPaths } = project_tsconfig_paths_1.getProjectTsConfigPaths(tree);
const basePath = process.cwd();
const allPaths = [...buildPaths, ...testPaths];
if (!allPaths.length) {
throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot migrate Renderer usages to Renderer2.');
}
for (const tsconfigPath of allPaths) {
runRendererToRenderer2Migration(tree, tsconfigPath, basePath);
}
};
}
exports.default = default_1;
function runRendererToRenderer2Migration(tree, tsconfigPath, basePath) {
const { program } = compiler_host_1.createMigrationProgram(tree, tsconfigPath, basePath, fileName => {
// In case the module augmentation file has been requested, we return a source file that
// augments "@angular/core" to include a named export called "Renderer". This ensures that
// we can rely on the type checker for this migration in v9 where "Renderer" has been removed.
if (fileName === MODULE_AUGMENTATION_FILENAME) {
return `
import '@angular/core';
declare module "@angular/core" {
class Renderer {}
}
`;
}
return null;
}, [MODULE_AUGMENTATION_FILENAME]);
const typeChecker = program.getTypeChecker();
const printer = ts.createPrinter();
const sourceFiles = program.getSourceFiles().filter(f => !f.isDeclarationFile && !program.isSourceFileFromExternalLibrary(f));
sourceFiles.forEach(sourceFile => {
const rendererImport = util_1.findCoreImport(sourceFile, 'Renderer');
// If there are no imports for the `Renderer`, we can exit early.
if (!rendererImport) {
return;
}
const { typedNodes, methodCalls, forwardRefs } = util_1.findRendererReferences(sourceFile, typeChecker, rendererImport);
const update = tree.beginUpdate(path_1.relative(basePath, sourceFile.fileName));
const helpersToAdd = new Set();
// Change the `Renderer` import to `Renderer2`.
update.remove(rendererImport.getStart(), rendererImport.getWidth());
update.insertRight(rendererImport.getStart(), printer.printNode(ts.EmitHint.Unspecified, migration_1.replaceImport(rendererImport, 'Renderer', 'Renderer2'), sourceFile));
// Change the method parameter and property types to `Renderer2`.
typedNodes.forEach(node => {
const type = node.type;
if (type) {
update.remove(type.getStart(), type.getWidth());
update.insertRight(type.getStart(), 'Renderer2');
}
});
// Change all identifiers inside `forwardRef` referring to the `Renderer`.
forwardRefs.forEach(identifier => {
update.remove(identifier.getStart(), identifier.getWidth());
update.insertRight(identifier.getStart(), 'Renderer2');
});
// Migrate all of the method calls.
methodCalls.forEach(call => {
const { node, requiredHelpers } = migration_1.migrateExpression(call, typeChecker);
if (node) {
// If we migrated the node to a new expression, replace only the call expression.
update.remove(call.getStart(), call.getWidth());
update.insertRight(call.getStart(), printer.printNode(ts.EmitHint.Unspecified, node, sourceFile));
}
else if (call.parent && ts.isExpressionStatement(call.parent)) {
// Otherwise if the call is inside an expression statement, drop the entire statement.
// This takes care of any trailing semicolons. We only need to drop nodes for cases like
// `setBindingDebugInfo` which have been noop for a while so they can be removed safely.
update.remove(call.parent.getStart(), call.parent.getWidth());
}
if (requiredHelpers) {
requiredHelpers.forEach(helperName => helpersToAdd.add(helperName));
}
});
// Some of the methods can't be mapped directly to `Renderer2` and need extra logic around them.
// The safest way to do so is to declare helper functions similar to the ones emitted by TS
// which encapsulate the extra "glue" logic. We should only emit these functions once per file.
helpersToAdd.forEach(helperName => {
update.insertLeft(sourceFile.endOfFileToken.getStart(), helpers_1.getHelper(helperName, sourceFile, printer));
});
tree.commitUpdate(update);
});
}
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/renderer-to-renderer2/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Rule, SchematicsException, Tree} from '@angular-devkit/schematics';\nimport {relative} from 'path';\nimport * as ts from 'typescript';\n\nimport {getProjectTsConfigPaths} from '../../utils/project_tsconfig_paths';\nimport {createMigrationProgram} from '../../utils/typescript/compiler_host';\n\nimport {getHelper, HelperFunction} from './helpers';\nimport {migrateExpression, replaceImport} from './migration';\nimport {findCoreImport, findRendererReferences} from './util';\n\nconst MODULE_AUGMENTATION_FILENAME = 'ɵɵRENDERER_MIGRATION_CORE_AUGMENTATION.d.ts';\n\n/**\n * Migration that switches from `Renderer` to `Renderer2`. More information on how it works:\n * https://hackmd.angular.io/UTzUZTnPRA-cSa_4mHyfYw\n */\nexport default function(): Rule {\n  return (tree: Tree) => {\n    const {buildPaths, testPaths} = getProjectTsConfigPaths(tree);\n    const basePath = process.cwd();\n    const allPaths = [...buildPaths, ...testPaths];\n\n    if (!allPaths.length) {\n      throw new SchematicsException(\n          'Could not find any tsconfig file. Cannot migrate Renderer usages to Renderer2.');\n    }\n\n    for (const tsconfigPath of allPaths) {\n      runRendererToRenderer2Migration(tree, tsconfigPath, basePath);\n    }\n  };\n}\n\nfunction runRendererToRenderer2Migration(tree: Tree, tsconfigPath: string, basePath: string) {\n  const {program} = createMigrationProgram(tree, tsconfigPath, basePath, fileName => {\n    // In case the module augmentation file has been requested, we return a source file that\n    // augments \"@angular/core\" to include a named export called \"Renderer\". This ensures that\n    // we can rely on the type checker for this migration in v9 where \"Renderer\" has been removed.\n    if (fileName === MODULE_AUGMENTATION_FILENAME) {\n      return `\n        import '@angular/core';\n        declare module \"@angular/core\" {\n          class Renderer {}\n        }\n      `;\n    }\n    return null;\n  }, [MODULE_AUGMENTATION_FILENAME]);\n  const typeChecker = program.getTypeChecker();\n  const printer = ts.createPrinter();\n  const sourceFiles = program.getSourceFiles().filter(\n      f => !f.isDeclarationFile && !program.isSourceFileFromExternalLibrary(f));\n\n  sourceFiles.forEach(sourceFile => {\n    const rendererImport = findCoreImport(sourceFile, 'Renderer');\n\n    // If there are no imports for the `Renderer`, we can exit early.\n    if (!rendererImport) {\n      return;\n    }\n\n    const {typedNodes, methodCalls, forwardRefs} =\n        findRendererReferences(sourceFile, typeChecker, rendererImport);\n    const update = tree.beginUpdate(relative(basePath, sourceFile.fileName));\n    const helpersToAdd = new Set<HelperFunction>();\n\n    // Change the `Renderer` import to `Renderer2`.\n    update.remove(rendererImport.getStart(), rendererImport.getWidth());\n    update.insertRight(\n        rendererImport.getStart(),\n        printer.printNode(\n            ts.EmitHint.Unspecified, replaceImport(rendererImport, 'Renderer', 'Renderer2'),\n            sourceFile));\n\n    // Change the method parameter and property types to `Renderer2`.\n    typedNodes.forEach(node => {\n      const type = node.type;\n\n      if (type) {\n        update.remove(type.getStart(), type.getWidth());\n        update.insertRight(type.getStart(), 'Renderer2');\n      }\n    });\n\n    // Change all identifiers inside `forwardRef` referring to the `Renderer`.\n    forwardRefs.forEach(identifier => {\n      update.remove(identifier.getStart(), identifier.getWidth());\n      update.insertRight(identifier.getStart(), 'Renderer2');\n    });\n\n    // Migrate all of the method calls.\n    methodCalls.forEach(call => {\n      const {node, requiredHelpers} = migrateExpression(call, typeChecker);\n\n      if (node) {\n        // If we migrated the node to a new expression, replace only the call expression.\n        update.remove(call.getStart(), call.getWidth());\n        update.insertRight(\n            call.getStart(), printer.printNode(ts.EmitHint.Unspecified, node, sourceFile));\n      } else if (call.parent && ts.isExpressionStatement(call.parent)) {\n        // Otherwise if the call is inside an expression statement, drop the entire statement.\n        // This takes care of any trailing semicolons. We only need to drop nodes for cases like\n        // `setBindingDebugInfo` which have been noop for a while so they can be removed safely.\n        update.remove(call.parent.getStart(), call.parent.getWidth());\n      }\n\n      if (requiredHelpers) {\n        requiredHelpers.forEach(helperName => helpersToAdd.add(helperName));\n      }\n    });\n\n    // Some of the methods can't be mapped directly to `Renderer2` and need extra logic around them.\n    // The safest way to do so is to declare helper functions similar to the ones emitted by TS\n    // which encapsulate the extra \"glue\" logic. We should only emit these functions once per file.\n    helpersToAdd.forEach(helperName => {\n      update.insertLeft(\n          sourceFile.endOfFileToken.getStart(), getHelper(helperName, sourceFile, printer));\n    });\n\n    tree.commitUpdate(update);\n  });\n}\n"]}