@angular/core
Version:
Angular - the core framework
225 lines • 39.6 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
*/
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
(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/utils/import_manager", ["require", "exports", "path", "typescript"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ImportManager = void 0;
const path_1 = require("path");
const typescript_1 = __importDefault(require("typescript"));
const PARSED_TS_VERSION = parseFloat(typescript_1.default.versionMajorMinor);
/**
* Import manager that can be used to add TypeScript imports to given source
* files. The manager ensures that multiple transformations are applied properly
* without shifted offsets and that similar existing import declarations are re-used.
*/
class ImportManager {
constructor(getUpdateRecorder, printer) {
this.getUpdateRecorder = getUpdateRecorder;
this.printer = printer;
/** Map of import declarations that need to be updated to include the given symbols. */
this.updatedImports = new Map();
/** Map of source-files and their previously used identifier names. */
this.usedIdentifierNames = new Map();
/**
* Array of previously resolved symbol imports. Cache can be re-used to return
* the same identifier without checking the source-file again.
*/
this.importCache = [];
}
/**
* Adds an import to the given source-file and returns the TypeScript
* identifier that can be used to access the newly imported symbol.
*/
addImportToSourceFile(sourceFile, symbolName, moduleName, typeImport = false) {
const sourceDir = (0, path_1.dirname)(sourceFile.fileName);
let importStartIndex = 0;
let existingImport = null;
// In case the given import has been already generated previously, we just return
// the previous generated identifier in order to avoid duplicate generated imports.
const cachedImport = this.importCache.find(c => c.sourceFile === sourceFile && c.symbolName === symbolName &&
c.moduleName === moduleName);
if (cachedImport) {
return cachedImport.identifier;
}
// Walk through all source-file top-level statements and search for import declarations
// that already match the specified "moduleName" and can be updated to import the
// given symbol. If no matching import can be found, the last import in the source-file
// will be used as starting point for a new import that will be generated.
for (let i = sourceFile.statements.length - 1; i >= 0; i--) {
const statement = sourceFile.statements[i];
if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteral(statement.moduleSpecifier) ||
!statement.importClause) {
continue;
}
if (importStartIndex === 0) {
importStartIndex = this._getEndPositionOfNode(statement);
}
const moduleSpecifier = statement.moduleSpecifier.text;
if (moduleSpecifier.startsWith('.') &&
(0, path_1.resolve)(sourceDir, moduleSpecifier) !== (0, path_1.resolve)(sourceDir, moduleName) ||
moduleSpecifier !== moduleName) {
continue;
}
if (statement.importClause.namedBindings) {
const namedBindings = statement.importClause.namedBindings;
// In case a "Type" symbol is imported, we can't use namespace imports
// because these only export symbols available at runtime (no types)
if (typescript_1.default.isNamespaceImport(namedBindings) && !typeImport) {
return typescript_1.default.createPropertyAccess(typescript_1.default.createIdentifier(namedBindings.name.text), typescript_1.default.createIdentifier(symbolName || 'default'));
}
else if (typescript_1.default.isNamedImports(namedBindings) && symbolName) {
const existingElement = namedBindings.elements.find(e => e.propertyName ? e.propertyName.text === symbolName : e.name.text === symbolName);
if (existingElement) {
return typescript_1.default.createIdentifier(existingElement.name.text);
}
// In case the symbol could not be found in an existing import, we
// keep track of the import declaration as it can be updated to include
// the specified symbol name without having to create a new import.
existingImport = statement;
}
}
else if (statement.importClause.name && !symbolName) {
return typescript_1.default.createIdentifier(statement.importClause.name.text);
}
}
if (existingImport) {
const propertyIdentifier = typescript_1.default.createIdentifier(symbolName);
const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName);
const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;
const importName = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;
// Since it can happen that multiple classes need to be imported within the
// specified source file and we want to add the identifiers to the existing
// import declaration, we need to keep track of the updated import declarations.
// We can't directly update the import declaration for each identifier as this
// would throw off the recorder offsets. We need to keep track of the new identifiers
// for the import and perform the import transformation as batches per source-file.
this.updatedImports.set(existingImport, (this.updatedImports.get(existingImport) || []).concat({
propertyName: needsGeneratedUniqueName ? propertyIdentifier : undefined,
importName: importName,
}));
// Keep track of all updated imports so that we don't generate duplicate
// similar imports as these can't be statically analyzed in the source-file yet.
this.importCache.push({ sourceFile, moduleName, symbolName, identifier: importName });
return importName;
}
let identifier = null;
let newImport = null;
if (symbolName) {
const propertyIdentifier = typescript_1.default.createIdentifier(symbolName);
const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName);
const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;
identifier = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;
newImport = typescript_1.default.createImportDeclaration(undefined, undefined, typescript_1.default.createImportClause(undefined, typescript_1.default.createNamedImports([createImportSpecifier(needsGeneratedUniqueName ? propertyIdentifier : undefined, identifier)])), typescript_1.default.createStringLiteral(moduleName));
}
else {
identifier = this._getUniqueIdentifier(sourceFile, 'defaultExport');
newImport = typescript_1.default.createImportDeclaration(undefined, undefined, typescript_1.default.createImportClause(identifier, undefined), typescript_1.default.createStringLiteral(moduleName));
}
const newImportText = this.printer.printNode(typescript_1.default.EmitHint.Unspecified, newImport, sourceFile);
// If the import is generated at the start of the source file, we want to add
// a new-line after the import. Otherwise if the import is generated after an
// existing import, we need to prepend a new-line so that the import is not on
// the same line as the existing import anchor.
this.getUpdateRecorder(sourceFile)
.addNewImport(importStartIndex, importStartIndex === 0 ? `${newImportText}\n` : `\n${newImportText}`);
// Keep track of all generated imports so that we don't generate duplicate
// similar imports as these can't be statically analyzed in the source-file yet.
this.importCache.push({ sourceFile, symbolName, moduleName, identifier });
return identifier;
}
/**
* Stores the collected import changes within the appropriate update recorders. The
* updated imports can only be updated *once* per source-file because previous updates
* could otherwise shift the source-file offsets.
*/
recordChanges() {
this.updatedImports.forEach((expressions, importDecl) => {
const sourceFile = importDecl.getSourceFile();
const recorder = this.getUpdateRecorder(sourceFile);
const namedBindings = importDecl.importClause.namedBindings;
const newNamedBindings = typescript_1.default.updateNamedImports(namedBindings, namedBindings.elements.concat(expressions.map(({ propertyName, importName }) => createImportSpecifier(propertyName, importName))));
const newNamedBindingsText = this.printer.printNode(typescript_1.default.EmitHint.Unspecified, newNamedBindings, sourceFile);
recorder.updateExistingImport(namedBindings, newNamedBindingsText);
});
}
/** Gets an unique identifier with a base name for the given source file. */
_getUniqueIdentifier(sourceFile, baseName) {
if (this.isUniqueIdentifierName(sourceFile, baseName)) {
this._recordUsedIdentifier(sourceFile, baseName);
return typescript_1.default.createIdentifier(baseName);
}
let name = null;
let counter = 1;
do {
name = `${baseName}_${counter++}`;
} while (!this.isUniqueIdentifierName(sourceFile, name));
this._recordUsedIdentifier(sourceFile, name);
return typescript_1.default.createIdentifier(name);
}
/**
* Checks whether the specified identifier name is used within the given
* source file.
*/
isUniqueIdentifierName(sourceFile, name) {
if (this.usedIdentifierNames.has(sourceFile) &&
this.usedIdentifierNames.get(sourceFile).indexOf(name) !== -1) {
return false;
}
// Walk through the source file and search for an identifier matching
// the given name. In that case, it's not guaranteed that this name
// is unique in the given declaration scope and we just return false.
const nodeQueue = [sourceFile];
while (nodeQueue.length) {
const node = nodeQueue.shift();
if (typescript_1.default.isIdentifier(node) && node.text === name) {
return false;
}
nodeQueue.push(...node.getChildren());
}
return true;
}
_recordUsedIdentifier(sourceFile, identifierName) {
this.usedIdentifierNames.set(sourceFile, (this.usedIdentifierNames.get(sourceFile) || []).concat(identifierName));
}
/**
* Determines the full end of a given node. By default the end position of a node is
* before all trailing comments. This could mean that generated imports shift comments.
*/
_getEndPositionOfNode(node) {
const nodeEndPos = node.getEnd();
const commentRanges = typescript_1.default.getTrailingCommentRanges(node.getSourceFile().text, nodeEndPos);
if (!commentRanges || !commentRanges.length) {
return nodeEndPos;
}
return commentRanges[commentRanges.length - 1].end;
}
}
exports.ImportManager = ImportManager;
/**
* Backwards-compatible version of `ts.createImportSpecifier`
* to handle a breaking change between 4.4 and 4.5.
*/
function createImportSpecifier(propertyName, name, isTypeOnly = false) {
return PARSED_TS_VERSION > 4.4 ? typescript_1.default.createImportSpecifier(isTypeOnly, propertyName, name) :
// TODO(crisbeto): backwards-compatibility layer for TS 4.4.
// Should be cleaned up when we drop support for it.
typescript_1.default.createImportSpecifier(propertyName, name);
}
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import_manager.js","sourceRoot":"","sources":["../../../../../../../packages/core/schematics/utils/import_manager.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 ts from 'typescript';\n\nconst PARSED_TS_VERSION = parseFloat(ts.versionMajorMinor);\n\n/** Update recorder for managing imports. */\nexport interface ImportManagerUpdateRecorder {\n  addNewImport(start: number, importText: string): void;\n  updateExistingImport(namedBindings: ts.NamedImports, newNamedBindings: string): void;\n}\n\n/**\n * Import manager that can be used to add TypeScript imports to given source\n * files. The manager ensures that multiple transformations are applied properly\n * without shifted offsets and that similar existing import declarations are re-used.\n */\nexport class ImportManager {\n  /** Map of import declarations that need to be updated to include the given symbols. */\n  private updatedImports =\n      new Map<ts.ImportDeclaration, {propertyName?: ts.Identifier, importName: ts.Identifier}[]>();\n  /** Map of source-files and their previously used identifier names. */\n  private usedIdentifierNames = new Map<ts.SourceFile, string[]>();\n  /**\n   * Array of previously resolved symbol imports. Cache can be re-used to return\n   * the same identifier without checking the source-file again.\n   */\n  private importCache: {\n    sourceFile: ts.SourceFile,\n    symbolName: string|null,\n    moduleName: string,\n    identifier: ts.Identifier\n  }[] = [];\n\n  constructor(\n      private getUpdateRecorder: (sf: ts.SourceFile) => ImportManagerUpdateRecorder,\n      private printer: ts.Printer) {}\n\n  /**\n   * Adds an import to the given source-file and returns the TypeScript\n   * identifier that can be used to access the newly imported symbol.\n   */\n  addImportToSourceFile(\n      sourceFile: ts.SourceFile, symbolName: string|null, moduleName: string,\n      typeImport = false): ts.Expression {\n    const sourceDir = dirname(sourceFile.fileName);\n    let importStartIndex = 0;\n    let existingImport: ts.ImportDeclaration|null = null;\n\n    // In case the given import has been already generated previously, we just return\n    // the previous generated identifier in order to avoid duplicate generated imports.\n    const cachedImport = this.importCache.find(\n        c => c.sourceFile === sourceFile && c.symbolName === symbolName &&\n            c.moduleName === moduleName);\n    if (cachedImport) {\n      return cachedImport.identifier;\n    }\n\n    // Walk through all source-file top-level statements and search for import declarations\n    // that already match the specified \"moduleName\" and can be updated to import the\n    // given symbol. If no matching import can be found, the last import in the source-file\n    // will be used as starting point for a new import that will be generated.\n    for (let i = sourceFile.statements.length - 1; i >= 0; i--) {\n      const statement = sourceFile.statements[i];\n\n      if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) ||\n          !statement.importClause) {\n        continue;\n      }\n\n      if (importStartIndex === 0) {\n        importStartIndex = this._getEndPositionOfNode(statement);\n      }\n\n      const moduleSpecifier = statement.moduleSpecifier.text;\n\n      if (moduleSpecifier.startsWith('.') &&\n              resolve(sourceDir, moduleSpecifier) !== resolve(sourceDir, moduleName) ||\n          moduleSpecifier !== moduleName) {\n        continue;\n      }\n\n      if (statement.importClause.namedBindings) {\n        const namedBindings = statement.importClause.namedBindings;\n\n        // In case a \"Type\" symbol is imported, we can't use namespace imports\n        // because these only export symbols available at runtime (no types)\n        if (ts.isNamespaceImport(namedBindings) && !typeImport) {\n          return ts.createPropertyAccess(\n              ts.createIdentifier(namedBindings.name.text),\n              ts.createIdentifier(symbolName || 'default'));\n        } else if (ts.isNamedImports(namedBindings) && symbolName) {\n          const existingElement = namedBindings.elements.find(\n              e =>\n                  e.propertyName ? e.propertyName.text === symbolName : e.name.text === symbolName);\n\n          if (existingElement) {\n            return ts.createIdentifier(existingElement.name.text);\n          }\n\n          // In case the symbol could not be found in an existing import, we\n          // keep track of the import declaration as it can be updated to include\n          // the specified symbol name without having to create a new import.\n          existingImport = statement;\n        }\n      } else if (statement.importClause.name && !symbolName) {\n        return ts.createIdentifier(statement.importClause.name.text);\n      }\n    }\n\n    if (existingImport) {\n      const propertyIdentifier = ts.createIdentifier(symbolName!);\n      const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName!);\n      const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;\n      const importName = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;\n\n      // Since it can happen that multiple classes need to be imported within the\n      // specified source file and we want to add the identifiers to the existing\n      // import declaration, we need to keep track of the updated import declarations.\n      // We can't directly update the import declaration for each identifier as this\n      // would throw off the recorder offsets. We need to keep track of the new identifiers\n      // for the import and perform the import transformation as batches per source-file.\n      this.updatedImports.set(\n          existingImport, (this.updatedImports.get(existingImport) || []).concat({\n            propertyName: needsGeneratedUniqueName ? propertyIdentifier : undefined,\n            importName: importName,\n          }));\n\n      // Keep track of all updated imports so that we don't generate duplicate\n      // similar imports as these can't be statically analyzed in the source-file yet.\n      this.importCache.push({sourceFile, moduleName, symbolName, identifier: importName});\n\n      return importName;\n    }\n\n    let identifier: ts.Identifier|null = null;\n    let newImport: ts.ImportDeclaration|null = null;\n\n    if (symbolName) {\n      const propertyIdentifier = ts.createIdentifier(symbolName);\n      const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName);\n      const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;\n      identifier = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;\n\n      newImport = ts.createImportDeclaration(\n          undefined, undefined,\n          ts.createImportClause(\n              undefined,\n              ts.createNamedImports([createImportSpecifier(\n                  needsGeneratedUniqueName ? propertyIdentifier : undefined, identifier)])),\n          ts.createStringLiteral(moduleName));\n    } else {\n      identifier = this._getUniqueIdentifier(sourceFile, 'defaultExport');\n      newImport = ts.createImportDeclaration(\n          undefined, undefined, ts.createImportClause(identifier, undefined),\n          ts.createStringLiteral(moduleName));\n    }\n\n    const newImportText = this.printer.printNode(ts.EmitHint.Unspecified, newImport, sourceFile);\n    // If the import is generated at the start of the source file, we want to add\n    // a new-line after the import. Otherwise if the import is generated after an\n    // existing import, we need to prepend a new-line so that the import is not on\n    // the same line as the existing import anchor.\n    this.getUpdateRecorder(sourceFile)\n        .addNewImport(\n            importStartIndex, importStartIndex === 0 ? `${newImportText}\\n` : `\\n${newImportText}`);\n\n    // Keep track of all generated imports so that we don't generate duplicate\n    // similar imports as these can't be statically analyzed in the source-file yet.\n    this.importCache.push({sourceFile, symbolName, moduleName, identifier});\n\n    return identifier;\n  }\n\n  /**\n   * Stores the collected import changes within the appropriate update recorders. The\n   * updated imports can only be updated *once* per source-file because previous updates\n   * could otherwise shift the source-file offsets.\n   */\n  recordChanges() {\n    this.updatedImports.forEach((expressions, importDecl) => {\n      const sourceFile = importDecl.getSourceFile();\n      const recorder = this.getUpdateRecorder(sourceFile);\n      const namedBindings = importDecl.importClause!.namedBindings as ts.NamedImports;\n      const newNamedBindings = ts.updateNamedImports(\n          namedBindings,\n          namedBindings.elements.concat(expressions.map(\n              ({propertyName, importName}) => createImportSpecifier(propertyName, importName))));\n\n      const newNamedBindingsText =\n          this.printer.printNode(ts.EmitHint.Unspecified, newNamedBindings, sourceFile);\n      recorder.updateExistingImport(namedBindings, newNamedBindingsText);\n    });\n  }\n\n  /** Gets an unique identifier with a base name for the given source file. */\n  private _getUniqueIdentifier(sourceFile: ts.SourceFile, baseName: string): ts.Identifier {\n    if (this.isUniqueIdentifierName(sourceFile, baseName)) {\n      this._recordUsedIdentifier(sourceFile, baseName);\n      return ts.createIdentifier(baseName);\n    }\n\n    let name = null;\n    let counter = 1;\n    do {\n      name = `${baseName}_${counter++}`;\n    } while (!this.isUniqueIdentifierName(sourceFile, name));\n\n    this._recordUsedIdentifier(sourceFile, name!);\n    return ts.createIdentifier(name!);\n  }\n\n  /**\n   * Checks whether the specified identifier name is used within the given\n   * source file.\n   */\n  private isUniqueIdentifierName(sourceFile: ts.SourceFile, name: string) {\n    if (this.usedIdentifierNames.has(sourceFile) &&\n        this.usedIdentifierNames.get(sourceFile)!.indexOf(name) !== -1) {\n      return false;\n    }\n\n    // Walk through the source file and search for an identifier matching\n    // the given name. In that case, it's not guaranteed that this name\n    // is unique in the given declaration scope and we just return false.\n    const nodeQueue: ts.Node[] = [sourceFile];\n    while (nodeQueue.length) {\n      const node = nodeQueue.shift()!;\n      if (ts.isIdentifier(node) && node.text === name) {\n        return false;\n      }\n      nodeQueue.push(...node.getChildren());\n    }\n    return true;\n  }\n\n  private _recordUsedIdentifier(sourceFile: ts.SourceFile, identifierName: string) {\n    this.usedIdentifierNames.set(\n        sourceFile, (this.usedIdentifierNames.get(sourceFile) || []).concat(identifierName));\n  }\n\n  /**\n   * Determines the full end of a given node. By default the end position of a node is\n   * before all trailing comments. This could mean that generated imports shift comments.\n   */\n  private _getEndPositionOfNode(node: ts.Node) {\n    const nodeEndPos = node.getEnd();\n    const commentRanges = ts.getTrailingCommentRanges(node.getSourceFile().text, nodeEndPos);\n    if (!commentRanges || !commentRanges.length) {\n      return nodeEndPos;\n    }\n    return commentRanges[commentRanges.length - 1]!.end;\n  }\n}\n\n\n/**\n * Backwards-compatible version of `ts.createImportSpecifier`\n * to handle a breaking change between 4.4 and 4.5.\n */\nfunction createImportSpecifier(\n    propertyName: ts.Identifier|undefined, name: ts.Identifier,\n    isTypeOnly = false): ts.ImportSpecifier {\n  return PARSED_TS_VERSION > 4.4 ? ts.createImportSpecifier(isTypeOnly, propertyName, name) :\n                                   // TODO(crisbeto): backwards-compatibility layer for TS 4.4.\n                                   // Should be cleaned up when we drop support for it.\n                                   (ts.createImportSpecifier as any)(propertyName, name);\n}\n"]}