source: trip-planner-front/node_modules/@angular/material/schematics/ng-update/migrations/hammer-gestures-v9/import-manager.js

Last change on this file was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 58.6 KB
Line 
1"use strict";
2/**
3 * @license
4 * Copyright Google LLC All Rights Reserved.
5 *
6 * Use of this source code is governed by an MIT-style license that can be
7 * found in the LICENSE file at https://angular.io/license
8 */
9Object.defineProperty(exports, "__esModule", { value: true });
10exports.ImportManager = void 0;
11const path_1 = require("path");
12const ts = require("typescript");
13/** Checks whether an analyzed import has the given import flag set. */
14const hasFlag = (data, flag) => (data.state & flag) !== 0;
15/**
16 * Import manager that can be used to add or remove TypeScript imports within source
17 * files. The manager ensures that multiple transformations are applied properly
18 * without shifted offsets and that existing imports are re-used.
19 */
20class ImportManager {
21 constructor(_fileSystem, _printer) {
22 this._fileSystem = _fileSystem;
23 this._printer = _printer;
24 /** Map of source-files and their previously used identifier names. */
25 this._usedIdentifierNames = new Map();
26 /** Map of source files and their analyzed imports. */
27 this._importCache = new Map();
28 }
29 /**
30 * Analyzes the import of the specified source file if needed. In order to perform
31 * modifications to imports of a source file, we store all imports in memory and
32 * update the source file once all changes have been made. This is essential to
33 * ensure that we can re-use newly added imports and not break file offsets.
34 */
35 _analyzeImportsIfNeeded(sourceFile) {
36 if (this._importCache.has(sourceFile)) {
37 return this._importCache.get(sourceFile);
38 }
39 const result = [];
40 for (let node of sourceFile.statements) {
41 if (!ts.isImportDeclaration(node) || !ts.isStringLiteral(node.moduleSpecifier)) {
42 continue;
43 }
44 const moduleName = node.moduleSpecifier.text;
45 // Handles side-effect imports which do neither have a name or
46 // specifiers. e.g. `import "my-package";`
47 if (!node.importClause) {
48 result.push({ moduleName, node, state: 0 /* UNMODIFIED */ });
49 continue;
50 }
51 // Handles imports resolving to default exports of a module.
52 // e.g. `import moment from "moment";`
53 if (!node.importClause.namedBindings) {
54 result.push({ moduleName, node, name: node.importClause.name, state: 0 /* UNMODIFIED */ });
55 continue;
56 }
57 // Handles imports with individual symbol specifiers.
58 // e.g. `import {A, B, C} from "my-module";`
59 if (ts.isNamedImports(node.importClause.namedBindings)) {
60 result.push({
61 moduleName,
62 node,
63 specifiers: node.importClause.namedBindings.elements.map(el => ({ name: el.name, propertyName: el.propertyName })),
64 state: 0 /* UNMODIFIED */,
65 });
66 }
67 else {
68 // Handles namespaced imports. e.g. `import * as core from "my-pkg";`
69 result.push({
70 moduleName,
71 node,
72 name: node.importClause.namedBindings.name,
73 namespace: true,
74 state: 0 /* UNMODIFIED */,
75 });
76 }
77 }
78 this._importCache.set(sourceFile, result);
79 return result;
80 }
81 /**
82 * Checks whether the given specifier, which can be relative to the base path,
83 * matches the passed module name.
84 */
85 _isModuleSpecifierMatching(basePath, specifier, moduleName) {
86 return specifier.startsWith('.') ?
87 path_1.resolve(basePath, specifier) === path_1.resolve(basePath, moduleName) :
88 specifier === moduleName;
89 }
90 /** Deletes a given named binding import from the specified source file. */
91 deleteNamedBindingImport(sourceFile, symbolName, moduleName) {
92 const sourceDir = path_1.dirname(sourceFile.fileName);
93 const fileImports = this._analyzeImportsIfNeeded(sourceFile);
94 for (let importData of fileImports) {
95 if (!this._isModuleSpecifierMatching(sourceDir, importData.moduleName, moduleName) ||
96 !importData.specifiers) {
97 continue;
98 }
99 const specifierIndex = importData.specifiers.findIndex(d => (d.propertyName || d.name).text === symbolName);
100 if (specifierIndex !== -1) {
101 importData.specifiers.splice(specifierIndex, 1);
102 // if the import does no longer contain any specifiers after the removal of the
103 // given symbol, we can just mark the whole import for deletion. Otherwise, we mark
104 // it as modified so that it will be re-printed.
105 if (importData.specifiers.length === 0) {
106 importData.state |= 8 /* DELETED */;
107 }
108 else {
109 importData.state |= 2 /* MODIFIED */;
110 }
111 }
112 }
113 }
114 /** Deletes the import that matches the given import declaration if found. */
115 deleteImportByDeclaration(declaration) {
116 const fileImports = this._analyzeImportsIfNeeded(declaration.getSourceFile());
117 for (let importData of fileImports) {
118 if (importData.node === declaration) {
119 importData.state |= 8 /* DELETED */;
120 }
121 }
122 }
123 /**
124 * Adds an import to the given source file and returns the TypeScript expression that
125 * can be used to access the newly imported symbol.
126 *
127 * Whenever an import is added to a source file, it's recommended that the returned
128 * expression is used to reference th symbol. This is necessary because the symbol
129 * could be aliased if it would collide with existing imports in source file.
130 *
131 * @param sourceFile Source file to which the import should be added.
132 * @param symbolName Name of the symbol that should be imported. Can be null if
133 * the default export is requested.
134 * @param moduleName Name of the module of which the symbol should be imported.
135 * @param typeImport Whether the symbol is a type.
136 * @param ignoreIdentifierCollisions List of identifiers which can be ignored when
137 * the import manager checks for import collisions.
138 */
139 addImportToSourceFile(sourceFile, symbolName, moduleName, typeImport = false, ignoreIdentifierCollisions = []) {
140 const sourceDir = path_1.dirname(sourceFile.fileName);
141 const fileImports = this._analyzeImportsIfNeeded(sourceFile);
142 let existingImport = null;
143 for (let importData of fileImports) {
144 if (!this._isModuleSpecifierMatching(sourceDir, importData.moduleName, moduleName)) {
145 continue;
146 }
147 // If no symbol name has been specified, the default import is requested. In that
148 // case we search for non-namespace and non-specifier imports.
149 if (!symbolName && !importData.namespace && !importData.specifiers) {
150 return ts.createIdentifier(importData.name.text);
151 }
152 // In case a "Type" symbol is imported, we can't use namespace imports
153 // because these only export symbols available at runtime (no types)
154 if (importData.namespace && !typeImport) {
155 return ts.createPropertyAccess(ts.createIdentifier(importData.name.text), ts.createIdentifier(symbolName || 'default'));
156 }
157 else if (importData.specifiers && symbolName) {
158 const existingSpecifier = importData.specifiers.find(s => s.propertyName ? s.propertyName.text === symbolName : s.name.text === symbolName);
159 if (existingSpecifier) {
160 return ts.createIdentifier(existingSpecifier.name.text);
161 }
162 // In case the symbol could not be found in an existing import, we
163 // keep track of the import declaration as it can be updated to include
164 // the specified symbol name without having to create a new import.
165 existingImport = importData;
166 }
167 }
168 // If there is an existing import that matches the specified module, we
169 // just update the import specifiers to also import the requested symbol.
170 if (existingImport) {
171 const propertyIdentifier = ts.createIdentifier(symbolName);
172 const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName, ignoreIdentifierCollisions);
173 const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;
174 const importName = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;
175 existingImport.specifiers.push({
176 name: importName,
177 propertyName: needsGeneratedUniqueName ? propertyIdentifier : undefined,
178 });
179 existingImport.state |= 2 /* MODIFIED */;
180 if (hasFlag(existingImport, 8 /* DELETED */)) {
181 // unset the deleted flag if the import is pending deletion, but
182 // can now be used for the new imported symbol.
183 existingImport.state &= ~8 /* DELETED */;
184 }
185 return importName;
186 }
187 let identifier = null;
188 let newImport = null;
189 if (symbolName) {
190 const propertyIdentifier = ts.createIdentifier(symbolName);
191 const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName, ignoreIdentifierCollisions);
192 const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;
193 identifier = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;
194 const newImportDecl = ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamedImports([])), ts.createStringLiteral(moduleName));
195 newImport = {
196 moduleName,
197 node: newImportDecl,
198 specifiers: [{
199 propertyName: needsGeneratedUniqueName ? propertyIdentifier : undefined,
200 name: identifier
201 }],
202 state: 4 /* ADDED */,
203 };
204 }
205 else {
206 identifier =
207 this._getUniqueIdentifier(sourceFile, 'defaultExport', ignoreIdentifierCollisions);
208 const newImportDecl = ts.createImportDeclaration(undefined, undefined, ts.createImportClause(identifier, undefined), ts.createStringLiteral(moduleName));
209 newImport = {
210 moduleName,
211 node: newImportDecl,
212 name: identifier,
213 state: 4 /* ADDED */,
214 };
215 }
216 fileImports.push(newImport);
217 return identifier;
218 }
219 /**
220 * Applies the recorded changes in the update recorders of the corresponding source files.
221 * The changes are applied separately after all changes have been recorded because otherwise
222 * file offsets will change and the source files would need to be re-parsed after each change.
223 */
224 recordChanges() {
225 this._importCache.forEach((fileImports, sourceFile) => {
226 const recorder = this._fileSystem.edit(this._fileSystem.resolve(sourceFile.fileName));
227 const lastUnmodifiedImport = fileImports.reverse().find(i => i.state === 0 /* UNMODIFIED */);
228 const importStartIndex = lastUnmodifiedImport ? this._getEndPositionOfNode(lastUnmodifiedImport.node) : 0;
229 fileImports.forEach(importData => {
230 if (importData.state === 0 /* UNMODIFIED */) {
231 return;
232 }
233 if (hasFlag(importData, 8 /* DELETED */)) {
234 // Imports which do not exist in source file, can be just skipped as
235 // we do not need any replacement to delete the import.
236 if (!hasFlag(importData, 4 /* ADDED */)) {
237 recorder.remove(importData.node.getFullStart(), importData.node.getFullWidth());
238 }
239 return;
240 }
241 if (importData.specifiers) {
242 const namedBindings = importData.node.importClause.namedBindings;
243 const importSpecifiers = importData.specifiers.map(s => ts.createImportSpecifier(s.propertyName, s.name));
244 const updatedBindings = ts.updateNamedImports(namedBindings, importSpecifiers);
245 // In case an import has been added newly, we need to print the whole import
246 // declaration and insert it at the import start index. Otherwise, we just
247 // update the named bindings to not re-print the whole import (which could
248 // cause unnecessary formatting changes)
249 if (hasFlag(importData, 4 /* ADDED */)) {
250 const updatedImport = ts.updateImportDeclaration(importData.node, undefined, undefined, ts.createImportClause(undefined, updatedBindings), ts.createStringLiteral(importData.moduleName));
251 const newImportText = this._printer.printNode(ts.EmitHint.Unspecified, updatedImport, sourceFile);
252 recorder.insertLeft(importStartIndex, importStartIndex === 0 ? `${newImportText}\n` : `\n${newImportText}`);
253 return;
254 }
255 else if (hasFlag(importData, 2 /* MODIFIED */)) {
256 const newNamedBindingsText = this._printer.printNode(ts.EmitHint.Unspecified, updatedBindings, sourceFile);
257 recorder.remove(namedBindings.getStart(), namedBindings.getWidth());
258 recorder.insertRight(namedBindings.getStart(), newNamedBindingsText);
259 return;
260 }
261 }
262 else if (hasFlag(importData, 4 /* ADDED */)) {
263 const newImportText = this._printer.printNode(ts.EmitHint.Unspecified, importData.node, sourceFile);
264 recorder.insertLeft(importStartIndex, importStartIndex === 0 ? `${newImportText}\n` : `\n${newImportText}`);
265 return;
266 }
267 // we should never hit this, but we rather want to print a custom exception
268 // instead of just skipping imports silently.
269 throw Error('Unexpected import modification.');
270 });
271 });
272 }
273 /**
274 * Corrects the line and character position of a given node. Since nodes of
275 * source files are immutable and we sometimes make changes to the containing
276 * source file, the node position might shift (e.g. if we add a new import before).
277 *
278 * This method can be used to retrieve a corrected position of the given node. This
279 * is helpful when printing out error messages which should reflect the new state of
280 * source files.
281 */
282 correctNodePosition(node, offset, position) {
283 const sourceFile = node.getSourceFile();
284 if (!this._importCache.has(sourceFile)) {
285 return position;
286 }
287 const newPosition = Object.assign({}, position);
288 const fileImports = this._importCache.get(sourceFile);
289 for (let importData of fileImports) {
290 const fullEnd = importData.node.getFullStart() + importData.node.getFullWidth();
291 // Subtract or add lines based on whether an import has been deleted or removed
292 // before the actual node offset.
293 if (offset > fullEnd && hasFlag(importData, 8 /* DELETED */)) {
294 newPosition.line--;
295 }
296 else if (offset > fullEnd && hasFlag(importData, 4 /* ADDED */)) {
297 newPosition.line++;
298 }
299 }
300 return newPosition;
301 }
302 /**
303 * Returns an unique identifier name for the specified symbol name.
304 * @param sourceFile Source file to check for identifier collisions.
305 * @param symbolName Name of the symbol for which we want to generate an unique name.
306 * @param ignoreIdentifierCollisions List of identifiers which should be ignored when
307 * checking for identifier collisions in the given source file.
308 */
309 _getUniqueIdentifier(sourceFile, symbolName, ignoreIdentifierCollisions) {
310 if (this._isUniqueIdentifierName(sourceFile, symbolName, ignoreIdentifierCollisions)) {
311 this._recordUsedIdentifier(sourceFile, symbolName);
312 return ts.createIdentifier(symbolName);
313 }
314 let name = null;
315 let counter = 1;
316 do {
317 name = `${symbolName}_${counter++}`;
318 } while (!this._isUniqueIdentifierName(sourceFile, name, ignoreIdentifierCollisions));
319 this._recordUsedIdentifier(sourceFile, name);
320 return ts.createIdentifier(name);
321 }
322 /**
323 * Checks whether the specified identifier name is used within the given source file.
324 * @param sourceFile Source file to check for identifier collisions.
325 * @param name Name of the identifier which is checked for its uniqueness.
326 * @param ignoreIdentifierCollisions List of identifiers which should be ignored when
327 * checking for identifier collisions in the given source file.
328 */
329 _isUniqueIdentifierName(sourceFile, name, ignoreIdentifierCollisions) {
330 if (this._usedIdentifierNames.has(sourceFile) &&
331 this._usedIdentifierNames.get(sourceFile).indexOf(name) !== -1) {
332 return false;
333 }
334 // Walk through the source file and search for an identifier matching
335 // the given name. In that case, it's not guaranteed that this name
336 // is unique in the given declaration scope and we just return false.
337 const nodeQueue = [sourceFile];
338 while (nodeQueue.length) {
339 const node = nodeQueue.shift();
340 if (ts.isIdentifier(node) && node.text === name &&
341 !ignoreIdentifierCollisions.includes(node)) {
342 return false;
343 }
344 nodeQueue.push(...node.getChildren());
345 }
346 return true;
347 }
348 /**
349 * Records that the given identifier is used within the specified source file. This
350 * is necessary since we do not apply changes to source files per change, but still
351 * want to avoid conflicts with newly imported symbols.
352 */
353 _recordUsedIdentifier(sourceFile, identifierName) {
354 this._usedIdentifierNames.set(sourceFile, (this._usedIdentifierNames.get(sourceFile) || []).concat(identifierName));
355 }
356 /**
357 * Determines the full end of a given node. By default the end position of a node is
358 * before all trailing comments. This could mean that generated imports shift comments.
359 */
360 _getEndPositionOfNode(node) {
361 const nodeEndPos = node.getEnd();
362 const commentRanges = ts.getTrailingCommentRanges(node.getSourceFile().text, nodeEndPos);
363 if (!commentRanges || !commentRanges.length) {
364 return nodeEndPos;
365 }
366 return commentRanges[commentRanges.length - 1].end;
367 }
368}
369exports.ImportManager = ImportManager;
370//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import-manager.js","sourceRoot":"","sources":["../../../../../../../../../src/material/schematics/ng-update/migrations/hammer-gestures-v9/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 {FileSystem} from '@angular/cdk/schematics';\nimport {dirname, resolve} from 'path';\nimport * as ts from 'typescript';\n\n// tslint:disable:no-bitwise\n\n/** Enum describing the possible states of an analyzed import. */\nconst enum ImportState {\n  UNMODIFIED = 0b0,\n  MODIFIED = 0b10,\n  ADDED = 0b100,\n  DELETED = 0b1000,\n}\n\n/** Interface describing an import specifier. */\ninterface ImportSpecifier {\n  name: ts.Identifier;\n  propertyName?: ts.Identifier;\n}\n\n/** Interface describing an analyzed import. */\ninterface AnalyzedImport {\n  node: ts.ImportDeclaration;\n  moduleName: string;\n  name?: ts.Identifier;\n  specifiers?: ImportSpecifier[];\n  namespace?: boolean;\n  state: ImportState;\n}\n\n/** Checks whether an analyzed import has the given import flag set. */\nconst hasFlag = (data: AnalyzedImport, flag: ImportState) => (data.state & flag) !== 0;\n\n/**\n * Import manager that can be used to add or remove TypeScript imports within source\n * files. The manager ensures that multiple transformations are applied properly\n * without shifted offsets and that existing imports are re-used.\n */\nexport class ImportManager {\n  /** Map of source-files and their previously used identifier names. */\n  private _usedIdentifierNames = new Map<ts.SourceFile, string[]>();\n\n  /** Map of source files and their analyzed imports. */\n  private _importCache = new Map<ts.SourceFile, AnalyzedImport[]>();\n\n  constructor(\n      private _fileSystem: FileSystem,\n      private _printer: ts.Printer) {}\n\n  /**\n   * Analyzes the import of the specified source file if needed. In order to perform\n   * modifications to imports of a source file, we store all imports in memory and\n   * update the source file once all changes have been made. This is essential to\n   * ensure that we can re-use newly added imports and not break file offsets.\n   */\n  private _analyzeImportsIfNeeded(sourceFile: ts.SourceFile): AnalyzedImport[] {\n    if (this._importCache.has(sourceFile)) {\n      return this._importCache.get(sourceFile)!;\n    }\n\n    const result: AnalyzedImport[] = [];\n    for (let node of sourceFile.statements) {\n      if (!ts.isImportDeclaration(node) || !ts.isStringLiteral(node.moduleSpecifier)) {\n        continue;\n      }\n\n      const moduleName = node.moduleSpecifier.text;\n\n      // Handles side-effect imports which do neither have a name or\n      // specifiers. e.g. `import \"my-package\";`\n      if (!node.importClause) {\n        result.push({moduleName, node, state: ImportState.UNMODIFIED});\n        continue;\n      }\n\n      // Handles imports resolving to default exports of a module.\n      // e.g. `import moment from \"moment\";`\n      if (!node.importClause.namedBindings) {\n        result.push(\n            {moduleName, node, name: node.importClause.name, state: ImportState.UNMODIFIED});\n        continue;\n      }\n\n      // Handles imports with individual symbol specifiers.\n      // e.g. `import {A, B, C} from \"my-module\";`\n      if (ts.isNamedImports(node.importClause.namedBindings)) {\n        result.push({\n          moduleName,\n          node,\n          specifiers: node.importClause.namedBindings.elements.map(\n              el => ({name: el.name, propertyName: el.propertyName})),\n          state: ImportState.UNMODIFIED,\n        });\n      } else {\n        // Handles namespaced imports. e.g. `import * as core from \"my-pkg\";`\n        result.push({\n          moduleName,\n          node,\n          name: node.importClause.namedBindings.name,\n          namespace: true,\n          state: ImportState.UNMODIFIED,\n        });\n      }\n    }\n    this._importCache.set(sourceFile, result);\n    return result;\n  }\n\n  /**\n   * Checks whether the given specifier, which can be relative to the base path,\n   * matches the passed module name.\n   */\n  private _isModuleSpecifierMatching(basePath: string, specifier: string, moduleName: string):\n      boolean {\n    return specifier.startsWith('.') ?\n        resolve(basePath, specifier) === resolve(basePath, moduleName) :\n        specifier === moduleName;\n  }\n\n  /** Deletes a given named binding import from the specified source file. */\n  deleteNamedBindingImport(sourceFile: ts.SourceFile, symbolName: string, moduleName: string) {\n    const sourceDir = dirname(sourceFile.fileName);\n    const fileImports = this._analyzeImportsIfNeeded(sourceFile);\n\n    for (let importData of fileImports) {\n      if (!this._isModuleSpecifierMatching(sourceDir, importData.moduleName, moduleName) ||\n          !importData.specifiers) {\n        continue;\n      }\n\n      const specifierIndex =\n          importData.specifiers.findIndex(d => (d.propertyName || d.name).text === symbolName);\n      if (specifierIndex !== -1) {\n        importData.specifiers.splice(specifierIndex, 1);\n        // if the import does no longer contain any specifiers after the removal of the\n        // given symbol, we can just mark the whole import for deletion. Otherwise, we mark\n        // it as modified so that it will be re-printed.\n        if (importData.specifiers.length === 0) {\n          importData.state |= ImportState.DELETED;\n        } else {\n          importData.state |= ImportState.MODIFIED;\n        }\n      }\n    }\n  }\n\n  /** Deletes the import that matches the given import declaration if found. */\n  deleteImportByDeclaration(declaration: ts.ImportDeclaration) {\n    const fileImports = this._analyzeImportsIfNeeded(declaration.getSourceFile());\n    for (let importData of fileImports) {\n      if (importData.node === declaration) {\n        importData.state |= ImportState.DELETED;\n      }\n    }\n  }\n\n  /**\n   * Adds an import to the given source file and returns the TypeScript expression that\n   * can be used to access the newly imported symbol.\n   *\n   * Whenever an import is added to a source file, it's recommended that the returned\n   * expression is used to reference th symbol. This is necessary because the symbol\n   * could be aliased if it would collide with existing imports in source file.\n   *\n   * @param sourceFile Source file to which the import should be added.\n   * @param symbolName Name of the symbol that should be imported. Can be null if\n   *    the default export is requested.\n   * @param moduleName Name of the module of which the symbol should be imported.\n   * @param typeImport Whether the symbol is a type.\n   * @param ignoreIdentifierCollisions List of identifiers which can be ignored when\n   *    the import manager checks for import collisions.\n   */\n  addImportToSourceFile(\n      sourceFile: ts.SourceFile, symbolName: string|null, moduleName: string, typeImport = false,\n      ignoreIdentifierCollisions: ts.Identifier[] = []): ts.Expression {\n    const sourceDir = dirname(sourceFile.fileName);\n    const fileImports = this._analyzeImportsIfNeeded(sourceFile);\n\n    let existingImport: AnalyzedImport|null = null;\n    for (let importData of fileImports) {\n      if (!this._isModuleSpecifierMatching(sourceDir, importData.moduleName, moduleName)) {\n        continue;\n      }\n\n      // If no symbol name has been specified, the default import is requested. In that\n      // case we search for non-namespace and non-specifier imports.\n      if (!symbolName && !importData.namespace && !importData.specifiers) {\n        return ts.createIdentifier(importData.name!.text);\n      }\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 (importData.namespace && !typeImport) {\n        return ts.createPropertyAccess(\n            ts.createIdentifier(importData.name!.text),\n            ts.createIdentifier(symbolName || 'default'));\n      } else if (importData.specifiers && symbolName) {\n        const existingSpecifier = importData.specifiers.find(\n            s => s.propertyName ? s.propertyName.text === symbolName : s.name.text === symbolName);\n\n        if (existingSpecifier) {\n          return ts.createIdentifier(existingSpecifier.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 = importData;\n      }\n    }\n\n    // If there is an existing import that matches the specified module, we\n    // just update the import specifiers to also import the requested symbol.\n    if (existingImport) {\n      const propertyIdentifier = ts.createIdentifier(symbolName!);\n      const generatedUniqueIdentifier =\n          this._getUniqueIdentifier(sourceFile, symbolName!, ignoreIdentifierCollisions);\n      const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;\n      const importName = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;\n\n      existingImport.specifiers!.push({\n        name: importName,\n        propertyName: needsGeneratedUniqueName ? propertyIdentifier : undefined,\n      });\n      existingImport.state |= ImportState.MODIFIED;\n\n      if (hasFlag(existingImport, ImportState.DELETED)) {\n        // unset the deleted flag if the import is pending deletion, but\n        // can now be used for the new imported symbol.\n        existingImport.state &= ~ImportState.DELETED;\n      }\n\n      return importName;\n    }\n\n    let identifier: ts.Identifier|null = null;\n    let newImport: AnalyzedImport|null = null;\n\n    if (symbolName) {\n      const propertyIdentifier = ts.createIdentifier(symbolName);\n      const generatedUniqueIdentifier =\n          this._getUniqueIdentifier(sourceFile, symbolName, ignoreIdentifierCollisions);\n      const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;\n      identifier = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;\n\n      const newImportDecl = ts.createImportDeclaration(\n          undefined, undefined, ts.createImportClause(undefined, ts.createNamedImports([])),\n          ts.createStringLiteral(moduleName));\n\n      newImport = {\n        moduleName,\n        node: newImportDecl,\n        specifiers: [{\n          propertyName: needsGeneratedUniqueName ? propertyIdentifier : undefined,\n          name: identifier\n        }],\n        state: ImportState.ADDED,\n      };\n    } else {\n      identifier =\n          this._getUniqueIdentifier(sourceFile, 'defaultExport', ignoreIdentifierCollisions);\n      const newImportDecl = ts.createImportDeclaration(\n          undefined, undefined, ts.createImportClause(identifier, undefined),\n          ts.createStringLiteral(moduleName));\n      newImport = {\n        moduleName,\n        node: newImportDecl,\n        name: identifier,\n        state: ImportState.ADDED,\n      };\n    }\n    fileImports.push(newImport);\n    return identifier;\n  }\n\n  /**\n   * Applies the recorded changes in the update recorders of the corresponding source files.\n   * The changes are applied separately after all changes have been recorded because otherwise\n   * file offsets will change and the source files would need to be re-parsed after each change.\n   */\n  recordChanges() {\n    this._importCache.forEach((fileImports, sourceFile) => {\n      const recorder = this._fileSystem.edit(this._fileSystem.resolve(sourceFile.fileName));\n      const lastUnmodifiedImport =\n          fileImports.reverse().find(i => i.state === ImportState.UNMODIFIED);\n      const importStartIndex =\n          lastUnmodifiedImport ? this._getEndPositionOfNode(lastUnmodifiedImport.node) : 0;\n\n      fileImports.forEach(importData => {\n        if (importData.state === ImportState.UNMODIFIED) {\n          return;\n        }\n\n        if (hasFlag(importData, ImportState.DELETED)) {\n          // Imports which do not exist in source file, can be just skipped as\n          // we do not need any replacement to delete the import.\n          if (!hasFlag(importData, ImportState.ADDED)) {\n            recorder.remove(importData.node.getFullStart(), importData.node.getFullWidth());\n          }\n          return;\n        }\n\n        if (importData.specifiers) {\n          const namedBindings = importData.node.importClause!.namedBindings as ts.NamedImports;\n          const importSpecifiers =\n              importData.specifiers.map(s => ts.createImportSpecifier(s.propertyName, s.name));\n          const updatedBindings = ts.updateNamedImports(namedBindings, importSpecifiers);\n\n          // In case an import has been added newly, we need to print the whole import\n          // declaration and insert it at the import start index. Otherwise, we just\n          // update the named bindings to not re-print the whole import (which could\n          // cause unnecessary formatting changes)\n          if (hasFlag(importData, ImportState.ADDED)) {\n            const updatedImport = ts.updateImportDeclaration(\n                importData.node, undefined, undefined,\n                ts.createImportClause(undefined, updatedBindings),\n                ts.createStringLiteral(importData.moduleName));\n            const newImportText =\n                this._printer.printNode(ts.EmitHint.Unspecified, updatedImport, sourceFile);\n            recorder.insertLeft(\n                importStartIndex,\n                importStartIndex === 0 ? `${newImportText}\\n` : `\\n${newImportText}`);\n            return;\n          } else if (hasFlag(importData, ImportState.MODIFIED)) {\n            const newNamedBindingsText =\n                this._printer.printNode(ts.EmitHint.Unspecified, updatedBindings, sourceFile);\n            recorder.remove(namedBindings.getStart(), namedBindings.getWidth());\n            recorder.insertRight(namedBindings.getStart(), newNamedBindingsText);\n            return;\n          }\n        } else if (hasFlag(importData, ImportState.ADDED)) {\n          const newImportText =\n              this._printer.printNode(ts.EmitHint.Unspecified, importData.node, sourceFile);\n          recorder.insertLeft(\n              importStartIndex,\n              importStartIndex === 0 ? `${newImportText}\\n` : `\\n${newImportText}`);\n          return;\n        }\n\n        // we should never hit this, but we rather want to print a custom exception\n        // instead of just skipping imports silently.\n        throw Error('Unexpected import modification.');\n      });\n    });\n  }\n\n  /**\n   * Corrects the line and character position of a given node. Since nodes of\n   * source files are immutable and we sometimes make changes to the containing\n   * source file, the node position might shift (e.g. if we add a new import before).\n   *\n   * This method can be used to retrieve a corrected position of the given node. This\n   * is helpful when printing out error messages which should reflect the new state of\n   * source files.\n   */\n  correctNodePosition(node: ts.Node, offset: number, position: ts.LineAndCharacter) {\n    const sourceFile = node.getSourceFile();\n\n    if (!this._importCache.has(sourceFile)) {\n      return position;\n    }\n\n    const newPosition: ts.LineAndCharacter = {...position};\n    const fileImports = this._importCache.get(sourceFile)!;\n\n    for (let importData of fileImports) {\n      const fullEnd = importData.node.getFullStart() + importData.node.getFullWidth();\n      // Subtract or add lines based on whether an import has been deleted or removed\n      // before the actual node offset.\n      if (offset > fullEnd && hasFlag(importData, ImportState.DELETED)) {\n        newPosition.line--;\n      } else if (offset > fullEnd && hasFlag(importData, ImportState.ADDED)) {\n        newPosition.line++;\n      }\n    }\n    return newPosition;\n  }\n\n  /**\n   * Returns an unique identifier name for the specified symbol name.\n   * @param sourceFile Source file to check for identifier collisions.\n   * @param symbolName Name of the symbol for which we want to generate an unique name.\n   * @param ignoreIdentifierCollisions List of identifiers which should be ignored when\n   *    checking for identifier collisions in the given source file.\n   */\n  private _getUniqueIdentifier(\n      sourceFile: ts.SourceFile, symbolName: string,\n      ignoreIdentifierCollisions: ts.Identifier[]): ts.Identifier {\n    if (this._isUniqueIdentifierName(sourceFile, symbolName, ignoreIdentifierCollisions)) {\n      this._recordUsedIdentifier(sourceFile, symbolName);\n      return ts.createIdentifier(symbolName);\n    }\n\n    let name: string|null = null;\n    let counter = 1;\n    do {\n      name = `${symbolName}_${counter++}`;\n    } while (!this._isUniqueIdentifierName(sourceFile, name, ignoreIdentifierCollisions));\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 source file.\n   * @param sourceFile Source file to check for identifier collisions.\n   * @param name Name of the identifier which is checked for its uniqueness.\n   * @param ignoreIdentifierCollisions List of identifiers which should be ignored when\n   *    checking for identifier collisions in the given source file.\n   */\n  private _isUniqueIdentifierName(\n      sourceFile: ts.SourceFile, name: string, ignoreIdentifierCollisions: ts.Identifier[]) {\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          !ignoreIdentifierCollisions.includes(node)) {\n        return false;\n      }\n      nodeQueue.push(...node.getChildren());\n    }\n    return true;\n  }\n\n  /**\n   * Records that the given identifier is used within the specified source file. This\n   * is necessary since we do not apply changes to source files per change, but still\n   * want to avoid conflicts with newly imported symbols.\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"]}
Note: See TracBrowser for help on using the repository browser.