source: trip-planner-front/node_modules/@angular/compiler-cli/ngcc/src/dependencies/esm_dependency_host.js@ 59329aa

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

initial commit

  • Property mode set to 100644
File size: 38.6 KB
Line 
1(function (factory) {
2 if (typeof module === "object" && typeof module.exports === "object") {
3 var v = factory(require, exports);
4 if (v !== undefined) module.exports = v;
5 }
6 else if (typeof define === "function" && define.amd) {
7 define("@angular/compiler-cli/ngcc/src/dependencies/esm_dependency_host", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/ngcc/src/dependencies/dependency_host"], factory);
8 }
9})(function (require, exports) {
10 "use strict";
11 Object.defineProperty(exports, "__esModule", { value: true });
12 exports.isStringImportOrReexport = exports.hasImportOrReexportStatements = exports.EsmDependencyHost = void 0;
13 var tslib_1 = require("tslib");
14 /**
15 * @license
16 * Copyright Google LLC All Rights Reserved.
17 *
18 * Use of this source code is governed by an MIT-style license that can be
19 * found in the LICENSE file at https://angular.io/license
20 */
21 var ts = require("typescript");
22 var dependency_host_1 = require("@angular/compiler-cli/ngcc/src/dependencies/dependency_host");
23 /**
24 * Helper functions for computing dependencies.
25 */
26 var EsmDependencyHost = /** @class */ (function (_super) {
27 tslib_1.__extends(EsmDependencyHost, _super);
28 function EsmDependencyHost(fs, moduleResolver, scanImportExpressions) {
29 if (scanImportExpressions === void 0) { scanImportExpressions = true; }
30 var _this = _super.call(this, fs, moduleResolver) || this;
31 _this.scanImportExpressions = scanImportExpressions;
32 // By skipping trivia here we don't have to account for it in the processing below
33 // It has no relevance to capturing imports.
34 _this.scanner = ts.createScanner(ts.ScriptTarget.Latest, /* skipTrivia */ true);
35 return _this;
36 }
37 EsmDependencyHost.prototype.canSkipFile = function (fileContents) {
38 return !hasImportOrReexportStatements(fileContents);
39 };
40 /**
41 * Extract any import paths from imports found in the contents of this file.
42 *
43 * This implementation uses the TypeScript scanner, which tokenizes source code,
44 * to process the string. This is halfway between working with the string directly,
45 * which is too difficult due to corner cases, and parsing the string into a full
46 * TypeScript Abstract Syntax Tree (AST), which ends up doing more processing than
47 * is needed.
48 *
49 * The scanning is not trivial because we must hold state between each token since
50 * the context of the token affects how it should be scanned, and the scanner does
51 * not manage this for us.
52 *
53 * Specifically, backticked strings are particularly challenging since it is possible
54 * to recursively nest backticks and TypeScript expressions within each other.
55 */
56 EsmDependencyHost.prototype.extractImports = function (file, fileContents) {
57 var imports = new Set();
58 var templateStack = [];
59 var lastToken = ts.SyntaxKind.Unknown;
60 var currentToken = ts.SyntaxKind.Unknown;
61 var stopAtIndex = findLastPossibleImportOrReexport(fileContents);
62 this.scanner.setText(fileContents);
63 while ((currentToken = this.scanner.scan()) !== ts.SyntaxKind.EndOfFileToken) {
64 if (this.scanner.getTokenPos() > stopAtIndex) {
65 break;
66 }
67 switch (currentToken) {
68 case ts.SyntaxKind.TemplateHead:
69 // TemplateHead indicates the beginning of a backticked string
70 // Capture this in the `templateStack` to indicate we are currently processing
71 // within the static text part of a backticked string.
72 templateStack.push(currentToken);
73 break;
74 case ts.SyntaxKind.OpenBraceToken:
75 if (templateStack.length > 0) {
76 // We are processing a backticked string. This indicates that we are either
77 // entering an interpolation expression or entering an object literal expression.
78 // We add it to the `templateStack` so we can track when we leave the interpolation or
79 // object literal.
80 templateStack.push(currentToken);
81 }
82 break;
83 case ts.SyntaxKind.CloseBraceToken:
84 if (templateStack.length > 0) {
85 // We are processing a backticked string then this indicates that we are either
86 // leaving an interpolation expression or leaving an object literal expression.
87 var templateToken = templateStack[templateStack.length - 1];
88 if (templateToken === ts.SyntaxKind.TemplateHead) {
89 // We have hit a nested backticked string so we need to rescan it in that context
90 currentToken = this.scanner.reScanTemplateToken(/* isTaggedTemplate */ false);
91 if (currentToken === ts.SyntaxKind.TemplateTail) {
92 // We got to the end of the backticked string so pop the token that started it off
93 // the stack.
94 templateStack.pop();
95 }
96 }
97 else {
98 // We hit the end of an object-literal expression so pop the open-brace that started
99 // it off the stack.
100 templateStack.pop();
101 }
102 }
103 break;
104 case ts.SyntaxKind.SlashToken:
105 case ts.SyntaxKind.SlashEqualsToken:
106 if (canPrecedeARegex(lastToken)) {
107 // We have hit a slash (`/`) in a context where it could be the start of a regular
108 // expression so rescan it in that context
109 currentToken = this.scanner.reScanSlashToken();
110 }
111 break;
112 case ts.SyntaxKind.ImportKeyword:
113 var importPath = this.extractImportPath();
114 if (importPath !== null) {
115 imports.add(importPath);
116 }
117 break;
118 case ts.SyntaxKind.ExportKeyword:
119 var reexportPath = this.extractReexportPath();
120 if (reexportPath !== null) {
121 imports.add(reexportPath);
122 }
123 break;
124 }
125 lastToken = currentToken;
126 }
127 // Clear the text from the scanner to avoid holding on to potentially large strings of source
128 // content after the scanning has completed.
129 this.scanner.setText('');
130 return imports;
131 };
132 /**
133 * We have found an `import` token so now try to identify the import path.
134 *
135 * This method will use the current state of `this.scanner` to extract a string literal module
136 * specifier. It expects that the current state of the scanner is that an `import` token has just
137 * been scanned.
138 *
139 * The following forms of import are matched:
140 *
141 * * `import "module-specifier";`
142 * * `import("module-specifier")`
143 * * `import defaultBinding from "module-specifier";`
144 * * `import defaultBinding, * as identifier from "module-specifier";`
145 * * `import defaultBinding, {...} from "module-specifier";`
146 * * `import * as identifier from "module-specifier";`
147 * * `import {...} from "module-specifier";`
148 *
149 * @returns the import path or null if there is no import or it is not a string literal.
150 */
151 EsmDependencyHost.prototype.extractImportPath = function () {
152 // Check for side-effect import
153 var sideEffectImportPath = this.tryStringLiteral();
154 if (sideEffectImportPath !== null) {
155 return sideEffectImportPath;
156 }
157 var kind = this.scanner.getToken();
158 // Check for dynamic import expression
159 if (kind === ts.SyntaxKind.OpenParenToken) {
160 return this.scanImportExpressions ? this.tryStringLiteral() : null;
161 }
162 // Check for defaultBinding
163 if (kind === ts.SyntaxKind.Identifier) {
164 // Skip default binding
165 kind = this.scanner.scan();
166 if (kind === ts.SyntaxKind.CommaToken) {
167 // Skip comma that indicates additional import bindings
168 kind = this.scanner.scan();
169 }
170 }
171 // Check for namespace import clause
172 if (kind === ts.SyntaxKind.AsteriskToken) {
173 kind = this.skipNamespacedClause();
174 if (kind === null) {
175 return null;
176 }
177 }
178 // Check for named imports clause
179 else if (kind === ts.SyntaxKind.OpenBraceToken) {
180 kind = this.skipNamedClause();
181 }
182 // Expect a `from` clause, if not bail out
183 if (kind !== ts.SyntaxKind.FromKeyword) {
184 return null;
185 }
186 return this.tryStringLiteral();
187 };
188 /**
189 * We have found an `export` token so now try to identify a re-export path.
190 *
191 * This method will use the current state of `this.scanner` to extract a string literal module
192 * specifier. It expects that the current state of the scanner is that an `export` token has
193 * just been scanned.
194 *
195 * There are three forms of re-export that are matched:
196 *
197 * * `export * from '...';
198 * * `export * as alias from '...';
199 * * `export {...} from '...';
200 */
201 EsmDependencyHost.prototype.extractReexportPath = function () {
202 // Skip the `export` keyword
203 var token = this.scanner.scan();
204 if (token === ts.SyntaxKind.AsteriskToken) {
205 token = this.skipNamespacedClause();
206 if (token === null) {
207 return null;
208 }
209 }
210 else if (token === ts.SyntaxKind.OpenBraceToken) {
211 token = this.skipNamedClause();
212 }
213 // Expect a `from` clause, if not bail out
214 if (token !== ts.SyntaxKind.FromKeyword) {
215 return null;
216 }
217 return this.tryStringLiteral();
218 };
219 EsmDependencyHost.prototype.skipNamespacedClause = function () {
220 // Skip past the `*`
221 var token = this.scanner.scan();
222 // Check for a `* as identifier` alias clause
223 if (token === ts.SyntaxKind.AsKeyword) {
224 // Skip past the `as` keyword
225 token = this.scanner.scan();
226 // Expect an identifier, if not bail out
227 if (token !== ts.SyntaxKind.Identifier) {
228 return null;
229 }
230 // Skip past the identifier
231 token = this.scanner.scan();
232 }
233 return token;
234 };
235 EsmDependencyHost.prototype.skipNamedClause = function () {
236 var braceCount = 1;
237 // Skip past the initial opening brace `{`
238 var token = this.scanner.scan();
239 // Search for the matching closing brace `}`
240 while (braceCount > 0 && token !== ts.SyntaxKind.EndOfFileToken) {
241 if (token === ts.SyntaxKind.OpenBraceToken) {
242 braceCount++;
243 }
244 else if (token === ts.SyntaxKind.CloseBraceToken) {
245 braceCount--;
246 }
247 token = this.scanner.scan();
248 }
249 return token;
250 };
251 EsmDependencyHost.prototype.tryStringLiteral = function () {
252 return this.scanner.scan() === ts.SyntaxKind.StringLiteral ? this.scanner.getTokenValue() :
253 null;
254 };
255 return EsmDependencyHost;
256 }(dependency_host_1.DependencyHostBase));
257 exports.EsmDependencyHost = EsmDependencyHost;
258 /**
259 * Check whether a source file needs to be parsed for imports.
260 * This is a performance short-circuit, which saves us from creating
261 * a TypeScript AST unnecessarily.
262 *
263 * @param source The content of the source file to check.
264 *
265 * @returns false if there are definitely no import or re-export statements
266 * in this file, true otherwise.
267 */
268 function hasImportOrReexportStatements(source) {
269 return /(?:import|export)[\s\S]+?(["'])(?:\\\1|.)+?\1/.test(source);
270 }
271 exports.hasImportOrReexportStatements = hasImportOrReexportStatements;
272 function findLastPossibleImportOrReexport(source) {
273 return Math.max(source.lastIndexOf('import'), source.lastIndexOf(' from '));
274 }
275 /**
276 * Check whether the given statement is an import with a string literal module specifier.
277 * @param stmt the statement node to check.
278 * @returns true if the statement is an import with a string literal module specifier.
279 */
280 function isStringImportOrReexport(stmt) {
281 return ts.isImportDeclaration(stmt) ||
282 ts.isExportDeclaration(stmt) && !!stmt.moduleSpecifier &&
283 ts.isStringLiteral(stmt.moduleSpecifier);
284 }
285 exports.isStringImportOrReexport = isStringImportOrReexport;
286 function canPrecedeARegex(kind) {
287 switch (kind) {
288 case ts.SyntaxKind.Identifier:
289 case ts.SyntaxKind.StringLiteral:
290 case ts.SyntaxKind.NumericLiteral:
291 case ts.SyntaxKind.BigIntLiteral:
292 case ts.SyntaxKind.RegularExpressionLiteral:
293 case ts.SyntaxKind.ThisKeyword:
294 case ts.SyntaxKind.PlusPlusToken:
295 case ts.SyntaxKind.MinusMinusToken:
296 case ts.SyntaxKind.CloseParenToken:
297 case ts.SyntaxKind.CloseBracketToken:
298 case ts.SyntaxKind.CloseBraceToken:
299 case ts.SyntaxKind.TrueKeyword:
300 case ts.SyntaxKind.FalseKeyword:
301 return false;
302 default:
303 return true;
304 }
305 }
306});
307//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esm_dependency_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/dependencies/esm_dependency_host.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 */\nimport * as ts from 'typescript';\nimport {AbsoluteFsPath, ReadonlyFileSystem} from '../../../src/ngtsc/file_system';\nimport {DependencyHostBase} from './dependency_host';\nimport {ModuleResolver} from './module_resolver';\n\n/**\n * Helper functions for computing dependencies.\n */\nexport class EsmDependencyHost extends DependencyHostBase {\n  constructor(\n      fs: ReadonlyFileSystem, moduleResolver: ModuleResolver,\n      private scanImportExpressions = true) {\n    super(fs, moduleResolver);\n  }\n  // By skipping trivia here we don't have to account for it in the processing below\n  // It has no relevance to capturing imports.\n  private scanner = ts.createScanner(ts.ScriptTarget.Latest, /* skipTrivia */ true);\n\n  protected override canSkipFile(fileContents: string): boolean {\n    return !hasImportOrReexportStatements(fileContents);\n  }\n\n  /**\n   * Extract any import paths from imports found in the contents of this file.\n   *\n   * This implementation uses the TypeScript scanner, which tokenizes source code,\n   * to process the string. This is halfway between working with the string directly,\n   * which is too difficult due to corner cases, and parsing the string into a full\n   * TypeScript Abstract Syntax Tree (AST), which ends up doing more processing than\n   * is needed.\n   *\n   * The scanning is not trivial because we must hold state between each token since\n   * the context of the token affects how it should be scanned, and the scanner does\n   * not manage this for us.\n   *\n   * Specifically, backticked strings are particularly challenging since it is possible\n   * to recursively nest backticks and TypeScript expressions within each other.\n   */\n  protected override extractImports(file: AbsoluteFsPath, fileContents: string): Set<string> {\n    const imports = new Set<string>();\n    const templateStack: ts.SyntaxKind[] = [];\n    let lastToken: ts.SyntaxKind = ts.SyntaxKind.Unknown;\n    let currentToken: ts.SyntaxKind = ts.SyntaxKind.Unknown;\n    const stopAtIndex = findLastPossibleImportOrReexport(fileContents);\n\n    this.scanner.setText(fileContents);\n\n    while ((currentToken = this.scanner.scan()) !== ts.SyntaxKind.EndOfFileToken) {\n      if (this.scanner.getTokenPos() > stopAtIndex) {\n        break;\n      }\n      switch (currentToken) {\n        case ts.SyntaxKind.TemplateHead:\n          // TemplateHead indicates the beginning of a backticked string\n          // Capture this in the `templateStack` to indicate we are currently processing\n          // within the static text part of a backticked string.\n          templateStack.push(currentToken);\n          break;\n        case ts.SyntaxKind.OpenBraceToken:\n          if (templateStack.length > 0) {\n            // We are processing a backticked string. This indicates that we are either\n            // entering an interpolation expression or entering an object literal expression.\n            // We add it to the `templateStack` so we can track when we leave the interpolation or\n            // object literal.\n            templateStack.push(currentToken);\n          }\n          break;\n        case ts.SyntaxKind.CloseBraceToken:\n          if (templateStack.length > 0) {\n            // We are processing a backticked string then this indicates that we are either\n            // leaving an interpolation expression or leaving an object literal expression.\n            const templateToken = templateStack[templateStack.length - 1];\n            if (templateToken === ts.SyntaxKind.TemplateHead) {\n              // We have hit a nested backticked string so we need to rescan it in that context\n              currentToken = this.scanner.reScanTemplateToken(/* isTaggedTemplate */ false);\n              if (currentToken === ts.SyntaxKind.TemplateTail) {\n                // We got to the end of the backticked string so pop the token that started it off\n                // the stack.\n                templateStack.pop();\n              }\n            } else {\n              // We hit the end of an object-literal expression so pop the open-brace that started\n              // it off the stack.\n              templateStack.pop();\n            }\n          }\n          break;\n        case ts.SyntaxKind.SlashToken:\n        case ts.SyntaxKind.SlashEqualsToken:\n          if (canPrecedeARegex(lastToken)) {\n            // We have hit a slash (`/`) in a context where it could be the start of a regular\n            // expression so rescan it in that context\n            currentToken = this.scanner.reScanSlashToken();\n          }\n          break;\n        case ts.SyntaxKind.ImportKeyword:\n          const importPath = this.extractImportPath();\n          if (importPath !== null) {\n            imports.add(importPath);\n          }\n          break;\n        case ts.SyntaxKind.ExportKeyword:\n          const reexportPath = this.extractReexportPath();\n          if (reexportPath !== null) {\n            imports.add(reexportPath);\n          }\n          break;\n      }\n      lastToken = currentToken;\n    }\n\n    // Clear the text from the scanner to avoid holding on to potentially large strings of source\n    // content after the scanning has completed.\n    this.scanner.setText('');\n\n    return imports;\n  }\n\n\n  /**\n   * We have found an `import` token so now try to identify the import path.\n   *\n   * This method will use the current state of `this.scanner` to extract a string literal module\n   * specifier. It expects that the current state of the scanner is that an `import` token has just\n   * been scanned.\n   *\n   * The following forms of import are matched:\n   *\n   * * `import \"module-specifier\";`\n   * * `import(\"module-specifier\")`\n   * * `import defaultBinding from \"module-specifier\";`\n   * * `import defaultBinding, * as identifier from \"module-specifier\";`\n   * * `import defaultBinding, {...} from \"module-specifier\";`\n   * * `import * as identifier from \"module-specifier\";`\n   * * `import {...} from \"module-specifier\";`\n   *\n   * @returns the import path or null if there is no import or it is not a string literal.\n   */\n  protected extractImportPath(): string|null {\n    // Check for side-effect import\n    let sideEffectImportPath = this.tryStringLiteral();\n    if (sideEffectImportPath !== null) {\n      return sideEffectImportPath;\n    }\n\n    let kind: ts.SyntaxKind|null = this.scanner.getToken();\n\n    // Check for dynamic import expression\n    if (kind === ts.SyntaxKind.OpenParenToken) {\n      return this.scanImportExpressions ? this.tryStringLiteral() : null;\n    }\n\n    // Check for defaultBinding\n    if (kind === ts.SyntaxKind.Identifier) {\n      // Skip default binding\n      kind = this.scanner.scan();\n      if (kind === ts.SyntaxKind.CommaToken) {\n        // Skip comma that indicates additional import bindings\n        kind = this.scanner.scan();\n      }\n    }\n\n    // Check for namespace import clause\n    if (kind === ts.SyntaxKind.AsteriskToken) {\n      kind = this.skipNamespacedClause();\n      if (kind === null) {\n        return null;\n      }\n    }\n    // Check for named imports clause\n    else if (kind === ts.SyntaxKind.OpenBraceToken) {\n      kind = this.skipNamedClause();\n    }\n\n    // Expect a `from` clause, if not bail out\n    if (kind !== ts.SyntaxKind.FromKeyword) {\n      return null;\n    }\n\n    return this.tryStringLiteral();\n  }\n\n  /**\n   * We have found an `export` token so now try to identify a re-export path.\n   *\n   * This method will use the current state of `this.scanner` to extract a string literal module\n   * specifier. It expects that the current state of the scanner is that an `export` token has\n   * just been scanned.\n   *\n   * There are three forms of re-export that are matched:\n   *\n   * * `export * from '...';\n   * * `export * as alias from '...';\n   * * `export {...} from '...';\n   */\n  protected extractReexportPath(): string|null {\n    // Skip the `export` keyword\n    let token: ts.SyntaxKind|null = this.scanner.scan();\n    if (token === ts.SyntaxKind.AsteriskToken) {\n      token = this.skipNamespacedClause();\n      if (token === null) {\n        return null;\n      }\n    } else if (token === ts.SyntaxKind.OpenBraceToken) {\n      token = this.skipNamedClause();\n    }\n    // Expect a `from` clause, if not bail out\n    if (token !== ts.SyntaxKind.FromKeyword) {\n      return null;\n    }\n    return this.tryStringLiteral();\n  }\n\n  protected skipNamespacedClause(): ts.SyntaxKind|null {\n    // Skip past the `*`\n    let token = this.scanner.scan();\n    // Check for a `* as identifier` alias clause\n    if (token === ts.SyntaxKind.AsKeyword) {\n      // Skip past the `as` keyword\n      token = this.scanner.scan();\n      // Expect an identifier, if not bail out\n      if (token !== ts.SyntaxKind.Identifier) {\n        return null;\n      }\n      // Skip past the identifier\n      token = this.scanner.scan();\n    }\n    return token;\n  }\n\n  protected skipNamedClause(): ts.SyntaxKind {\n    let braceCount = 1;\n    // Skip past the initial opening brace `{`\n    let token = this.scanner.scan();\n    // Search for the matching closing brace `}`\n    while (braceCount > 0 && token !== ts.SyntaxKind.EndOfFileToken) {\n      if (token === ts.SyntaxKind.OpenBraceToken) {\n        braceCount++;\n      } else if (token === ts.SyntaxKind.CloseBraceToken) {\n        braceCount--;\n      }\n      token = this.scanner.scan();\n    }\n    return token;\n  }\n\n  protected tryStringLiteral(): string|null {\n    return this.scanner.scan() === ts.SyntaxKind.StringLiteral ? this.scanner.getTokenValue() :\n                                                                 null;\n  }\n}\n\n/**\n * Check whether a source file needs to be parsed for imports.\n * This is a performance short-circuit, which saves us from creating\n * a TypeScript AST unnecessarily.\n *\n * @param source The content of the source file to check.\n *\n * @returns false if there are definitely no import or re-export statements\n * in this file, true otherwise.\n */\nexport function hasImportOrReexportStatements(source: string): boolean {\n  return /(?:import|export)[\\s\\S]+?([\"'])(?:\\\\\\1|.)+?\\1/.test(source);\n}\n\nfunction findLastPossibleImportOrReexport(source: string): number {\n  return Math.max(source.lastIndexOf('import'), source.lastIndexOf(' from '));\n}\n\n/**\n * Check whether the given statement is an import with a string literal module specifier.\n * @param stmt the statement node to check.\n * @returns true if the statement is an import with a string literal module specifier.\n */\nexport function isStringImportOrReexport(stmt: ts.Statement): stmt is ts.ImportDeclaration&\n    {moduleSpecifier: ts.StringLiteral} {\n  return ts.isImportDeclaration(stmt) ||\n      ts.isExportDeclaration(stmt) && !!stmt.moduleSpecifier &&\n      ts.isStringLiteral(stmt.moduleSpecifier);\n}\n\n\nfunction canPrecedeARegex(kind: ts.SyntaxKind): boolean {\n  switch (kind) {\n    case ts.SyntaxKind.Identifier:\n    case ts.SyntaxKind.StringLiteral:\n    case ts.SyntaxKind.NumericLiteral:\n    case ts.SyntaxKind.BigIntLiteral:\n    case ts.SyntaxKind.RegularExpressionLiteral:\n    case ts.SyntaxKind.ThisKeyword:\n    case ts.SyntaxKind.PlusPlusToken:\n    case ts.SyntaxKind.MinusMinusToken:\n    case ts.SyntaxKind.CloseParenToken:\n    case ts.SyntaxKind.CloseBracketToken:\n    case ts.SyntaxKind.CloseBraceToken:\n    case ts.SyntaxKind.TrueKeyword:\n    case ts.SyntaxKind.FalseKeyword:\n      return false;\n    default:\n      return true;\n  }\n}\n"]}
Note: See TracBrowser for help on using the repository browser.