207 lines
26 KiB
JavaScript
Executable file
207 lines
26 KiB
JavaScript
Executable file
(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/compiler-cli/ngcc/src/packages/source_file_cache", ["require", "exports", "typescript"], factory);
|
|
}
|
|
})(function (require, exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.createModuleResolutionCache = exports.EntryPointFileCache = exports.isAngularDts = exports.isDefaultLibrary = exports.SharedFileCache = void 0;
|
|
/**
|
|
* @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 ts = require("typescript");
|
|
/**
|
|
* A cache that holds on to source files that can be shared for processing all entry-points in a
|
|
* single invocation of ngcc. In particular, the following files are shared across all entry-points
|
|
* through this cache:
|
|
*
|
|
* 1. Default library files such as `lib.dom.d.ts` and `lib.es5.d.ts`. These files don't change
|
|
* and some are very large, so parsing is expensive. Therefore, the parsed `ts.SourceFile`s for
|
|
* the default library files are cached.
|
|
* 2. The typings of @angular scoped packages. The typing files for @angular packages are typically
|
|
* used in the entry-points that ngcc processes, so benefit from a single source file cache.
|
|
* Especially `@angular/core/core.d.ts` is large and expensive to parse repeatedly. In contrast
|
|
* to default library files, we have to account for these files to be invalidated during a single
|
|
* invocation of ngcc, as ngcc will overwrite the .d.ts files during its processing.
|
|
*
|
|
* The lifecycle of this cache corresponds with a single invocation of ngcc. Separate invocations,
|
|
* e.g. the CLI's synchronous module resolution fallback will therefore all have their own cache.
|
|
* This allows for the source file cache to be garbage collected once ngcc processing has completed.
|
|
*/
|
|
var SharedFileCache = /** @class */ (function () {
|
|
function SharedFileCache(fs) {
|
|
this.fs = fs;
|
|
this.sfCache = new Map();
|
|
}
|
|
/**
|
|
* Loads a `ts.SourceFile` if the provided `fileName` is deemed appropriate to be cached. To
|
|
* optimize for memory usage, only files that are generally used in all entry-points are cached.
|
|
* If `fileName` is not considered to benefit from caching or the requested file does not exist,
|
|
* then `undefined` is returned.
|
|
*/
|
|
SharedFileCache.prototype.getCachedSourceFile = function (fileName) {
|
|
var absPath = this.fs.resolve(fileName);
|
|
if (isDefaultLibrary(absPath, this.fs)) {
|
|
return this.getStableCachedFile(absPath);
|
|
}
|
|
else if (isAngularDts(absPath, this.fs)) {
|
|
return this.getVolatileCachedFile(absPath);
|
|
}
|
|
else {
|
|
return undefined;
|
|
}
|
|
};
|
|
/**
|
|
* Attempts to load the source file from the cache, or parses the file into a `ts.SourceFile` if
|
|
* it's not yet cached. This method assumes that the file will not be modified for the duration
|
|
* that this cache is valid for. If that assumption does not hold, the `getVolatileCachedFile`
|
|
* method is to be used instead.
|
|
*/
|
|
SharedFileCache.prototype.getStableCachedFile = function (absPath) {
|
|
if (!this.sfCache.has(absPath)) {
|
|
var content = readFile(absPath, this.fs);
|
|
if (content === undefined) {
|
|
return undefined;
|
|
}
|
|
var sf = ts.createSourceFile(absPath, content, ts.ScriptTarget.ES2015);
|
|
this.sfCache.set(absPath, sf);
|
|
}
|
|
return this.sfCache.get(absPath);
|
|
};
|
|
/**
|
|
* In contrast to `getStableCachedFile`, this method always verifies that the cached source file
|
|
* is the same as what's stored on disk. This is done for files that are expected to change during
|
|
* ngcc's processing, such as @angular scoped packages for which the .d.ts files are overwritten
|
|
* by ngcc. If the contents on disk have changed compared to a previously cached source file, the
|
|
* content from disk is re-parsed and the cache entry is replaced.
|
|
*/
|
|
SharedFileCache.prototype.getVolatileCachedFile = function (absPath) {
|
|
var content = readFile(absPath, this.fs);
|
|
if (content === undefined) {
|
|
return undefined;
|
|
}
|
|
if (!this.sfCache.has(absPath) || this.sfCache.get(absPath).text !== content) {
|
|
var sf = ts.createSourceFile(absPath, content, ts.ScriptTarget.ES2015);
|
|
this.sfCache.set(absPath, sf);
|
|
}
|
|
return this.sfCache.get(absPath);
|
|
};
|
|
return SharedFileCache;
|
|
}());
|
|
exports.SharedFileCache = SharedFileCache;
|
|
var DEFAULT_LIB_PATTERN = ['node_modules', 'typescript', 'lib', /^lib\..+\.d\.ts$/];
|
|
/**
|
|
* Determines whether the provided path corresponds with a default library file inside of the
|
|
* typescript package.
|
|
*
|
|
* @param absPath The path for which to determine if it corresponds with a default library file.
|
|
* @param fs The filesystem to use for inspecting the path.
|
|
*/
|
|
function isDefaultLibrary(absPath, fs) {
|
|
return isFile(absPath, DEFAULT_LIB_PATTERN, fs);
|
|
}
|
|
exports.isDefaultLibrary = isDefaultLibrary;
|
|
var ANGULAR_DTS_PATTERN = ['node_modules', '@angular', /./, /\.d\.ts$/];
|
|
/**
|
|
* Determines whether the provided path corresponds with a .d.ts file inside of an @angular
|
|
* scoped package. This logic only accounts for the .d.ts files in the root, which is sufficient
|
|
* to find the large, flattened entry-point files that benefit from caching.
|
|
*
|
|
* @param absPath The path for which to determine if it corresponds with an @angular .d.ts file.
|
|
* @param fs The filesystem to use for inspecting the path.
|
|
*/
|
|
function isAngularDts(absPath, fs) {
|
|
return isFile(absPath, ANGULAR_DTS_PATTERN, fs);
|
|
}
|
|
exports.isAngularDts = isAngularDts;
|
|
/**
|
|
* Helper function to determine whether a file corresponds with a given pattern of segments.
|
|
*
|
|
* @param path The path for which to determine if it corresponds with the provided segments.
|
|
* @param segments Array of segments; the `path` must have ending segments that match the
|
|
* patterns in this array.
|
|
* @param fs The filesystem to use for inspecting the path.
|
|
*/
|
|
function isFile(path, segments, fs) {
|
|
for (var i = segments.length - 1; i >= 0; i--) {
|
|
var pattern = segments[i];
|
|
var segment = fs.basename(path);
|
|
if (typeof pattern === 'string') {
|
|
if (pattern !== segment) {
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
if (!pattern.test(segment)) {
|
|
return false;
|
|
}
|
|
}
|
|
path = fs.dirname(path);
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* A cache for processing a single entry-point. This exists to share `ts.SourceFile`s between the
|
|
* source and typing programs that are created for a single program.
|
|
*/
|
|
var EntryPointFileCache = /** @class */ (function () {
|
|
function EntryPointFileCache(fs, sharedFileCache) {
|
|
this.fs = fs;
|
|
this.sharedFileCache = sharedFileCache;
|
|
this.sfCache = new Map();
|
|
}
|
|
/**
|
|
* Returns and caches a parsed `ts.SourceFile` for the provided `fileName`. If the `fileName` is
|
|
* cached in the shared file cache, that result is used. Otherwise, the source file is cached
|
|
* internally. This method returns `undefined` if the requested file does not exist.
|
|
*
|
|
* @param fileName The path of the file to retrieve a source file for.
|
|
* @param languageVersion The language version to use for parsing the file.
|
|
*/
|
|
EntryPointFileCache.prototype.getCachedSourceFile = function (fileName, languageVersion) {
|
|
var staticSf = this.sharedFileCache.getCachedSourceFile(fileName);
|
|
if (staticSf !== undefined) {
|
|
return staticSf;
|
|
}
|
|
var absPath = this.fs.resolve(fileName);
|
|
if (this.sfCache.has(absPath)) {
|
|
return this.sfCache.get(absPath);
|
|
}
|
|
var content = readFile(absPath, this.fs);
|
|
if (content === undefined) {
|
|
return undefined;
|
|
}
|
|
var sf = ts.createSourceFile(fileName, content, languageVersion);
|
|
this.sfCache.set(absPath, sf);
|
|
return sf;
|
|
};
|
|
return EntryPointFileCache;
|
|
}());
|
|
exports.EntryPointFileCache = EntryPointFileCache;
|
|
function readFile(absPath, fs) {
|
|
if (!fs.exists(absPath) || !fs.stat(absPath).isFile()) {
|
|
return undefined;
|
|
}
|
|
return fs.readFile(absPath);
|
|
}
|
|
/**
|
|
* Creates a `ts.ModuleResolutionCache` that uses the provided filesystem for path operations.
|
|
*
|
|
* @param fs The filesystem to use for path operations.
|
|
*/
|
|
function createModuleResolutionCache(fs) {
|
|
return ts.createModuleResolutionCache(fs.pwd(), function (fileName) {
|
|
return fs.isCaseSensitive() ? fileName : fileName.toLowerCase();
|
|
});
|
|
}
|
|
exports.createModuleResolutionCache = createModuleResolutionCache;
|
|
});
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source_file_cache.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/packages/source_file_cache.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';\n\n/**\n * A cache that holds on to source files that can be shared for processing all entry-points in a\n * single invocation of ngcc. In particular, the following files are shared across all entry-points\n * through this cache:\n *\n * 1. Default library files such as `lib.dom.d.ts` and `lib.es5.d.ts`. These files don't change\n *    and some are very large, so parsing is expensive. Therefore, the parsed `ts.SourceFile`s for\n *    the default library files are cached.\n * 2. The typings of @angular scoped packages. The typing files for @angular packages are typically\n *    used in the entry-points that ngcc processes, so benefit from a single source file cache.\n *    Especially `@angular/core/core.d.ts` is large and expensive to parse repeatedly. In contrast\n *    to default library files, we have to account for these files to be invalidated during a single\n *    invocation of ngcc, as ngcc will overwrite the .d.ts files during its processing.\n *\n * The lifecycle of this cache corresponds with a single invocation of ngcc. Separate invocations,\n * e.g. the CLI's synchronous module resolution fallback will therefore all have their own cache.\n * This allows for the source file cache to be garbage collected once ngcc processing has completed.\n */\nexport class SharedFileCache {\n  private sfCache = new Map<AbsoluteFsPath, ts.SourceFile>();\n\n  constructor(private fs: ReadonlyFileSystem) {}\n\n  /**\n   * Loads a `ts.SourceFile` if the provided `fileName` is deemed appropriate to be cached. To\n   * optimize for memory usage, only files that are generally used in all entry-points are cached.\n   * If `fileName` is not considered to benefit from caching or the requested file does not exist,\n   * then `undefined` is returned.\n   */\n  getCachedSourceFile(fileName: string): ts.SourceFile|undefined {\n    const absPath = this.fs.resolve(fileName);\n    if (isDefaultLibrary(absPath, this.fs)) {\n      return this.getStableCachedFile(absPath);\n    } else if (isAngularDts(absPath, this.fs)) {\n      return this.getVolatileCachedFile(absPath);\n    } else {\n      return undefined;\n    }\n  }\n\n  /**\n   * Attempts to load the source file from the cache, or parses the file into a `ts.SourceFile` if\n   * it's not yet cached. This method assumes that the file will not be modified for the duration\n   * that this cache is valid for. If that assumption does not hold, the `getVolatileCachedFile`\n   * method is to be used instead.\n   */\n  private getStableCachedFile(absPath: AbsoluteFsPath): ts.SourceFile|undefined {\n    if (!this.sfCache.has(absPath)) {\n      const content = readFile(absPath, this.fs);\n      if (content === undefined) {\n        return undefined;\n      }\n      const sf = ts.createSourceFile(absPath, content, ts.ScriptTarget.ES2015);\n      this.sfCache.set(absPath, sf);\n    }\n    return this.sfCache.get(absPath)!;\n  }\n\n  /**\n   * In contrast to `getStableCachedFile`, this method always verifies that the cached source file\n   * is the same as what's stored on disk. This is done for files that are expected to change during\n   * ngcc's processing, such as @angular scoped packages for which the .d.ts files are overwritten\n   * by ngcc. If the contents on disk have changed compared to a previously cached source file, the\n   * content from disk is re-parsed and the cache entry is replaced.\n   */\n  private getVolatileCachedFile(absPath: AbsoluteFsPath): ts.SourceFile|undefined {\n    const content = readFile(absPath, this.fs);\n    if (content === undefined) {\n      return undefined;\n    }\n    if (!this.sfCache.has(absPath) || this.sfCache.get(absPath)!.text !== content) {\n      const sf = ts.createSourceFile(absPath, content, ts.ScriptTarget.ES2015);\n      this.sfCache.set(absPath, sf);\n    }\n    return this.sfCache.get(absPath)!;\n  }\n}\n\nconst DEFAULT_LIB_PATTERN = ['node_modules', 'typescript', 'lib', /^lib\\..+\\.d\\.ts$/];\n\n/**\n * Determines whether the provided path corresponds with a default library file inside of the\n * typescript package.\n *\n * @param absPath The path for which to determine if it corresponds with a default library file.\n * @param fs The filesystem to use for inspecting the path.\n */\nexport function isDefaultLibrary(absPath: AbsoluteFsPath, fs: ReadonlyFileSystem): boolean {\n  return isFile(absPath, DEFAULT_LIB_PATTERN, fs);\n}\n\nconst ANGULAR_DTS_PATTERN = ['node_modules', '@angular', /./, /\\.d\\.ts$/];\n\n/**\n * Determines whether the provided path corresponds with a .d.ts file inside of an @angular\n * scoped package. This logic only accounts for the .d.ts files in the root, which is sufficient\n * to find the large, flattened entry-point files that benefit from caching.\n *\n * @param absPath The path for which to determine if it corresponds with an @angular .d.ts file.\n * @param fs The filesystem to use for inspecting the path.\n */\nexport function isAngularDts(absPath: AbsoluteFsPath, fs: ReadonlyFileSystem): boolean {\n  return isFile(absPath, ANGULAR_DTS_PATTERN, fs);\n}\n\n/**\n * Helper function to determine whether a file corresponds with a given pattern of segments.\n *\n * @param path The path for which to determine if it corresponds with the provided segments.\n * @param segments Array of segments; the `path` must have ending segments that match the\n * patterns in this array.\n * @param fs The filesystem to use for inspecting the path.\n */\nfunction isFile(\n    path: AbsoluteFsPath, segments: ReadonlyArray<string|RegExp>, fs: ReadonlyFileSystem): boolean {\n  for (let i = segments.length - 1; i >= 0; i--) {\n    const pattern = segments[i];\n    const segment = fs.basename(path);\n    if (typeof pattern === 'string') {\n      if (pattern !== segment) {\n        return false;\n      }\n    } else {\n      if (!pattern.test(segment)) {\n        return false;\n      }\n    }\n    path = fs.dirname(path);\n  }\n  return true;\n}\n\n/**\n * A cache for processing a single entry-point. This exists to share `ts.SourceFile`s between the\n * source and typing programs that are created for a single program.\n */\nexport class EntryPointFileCache {\n  private readonly sfCache = new Map<AbsoluteFsPath, ts.SourceFile>();\n\n  constructor(private fs: ReadonlyFileSystem, private sharedFileCache: SharedFileCache) {}\n\n  /**\n   * Returns and caches a parsed `ts.SourceFile` for the provided `fileName`. If the `fileName` is\n   * cached in the shared file cache, that result is used. Otherwise, the source file is cached\n   * internally. This method returns `undefined` if the requested file does not exist.\n   *\n   * @param fileName The path of the file to retrieve a source file for.\n   * @param languageVersion The language version to use for parsing the file.\n   */\n  getCachedSourceFile(fileName: string, languageVersion: ts.ScriptTarget): ts.SourceFile|undefined {\n    const staticSf = this.sharedFileCache.getCachedSourceFile(fileName);\n    if (staticSf !== undefined) {\n      return staticSf;\n    }\n\n    const absPath = this.fs.resolve(fileName);\n    if (this.sfCache.has(absPath)) {\n      return this.sfCache.get(absPath);\n    }\n\n    const content = readFile(absPath, this.fs);\n    if (content === undefined) {\n      return undefined;\n    }\n    const sf = ts.createSourceFile(fileName, content, languageVersion);\n    this.sfCache.set(absPath, sf);\n    return sf;\n  }\n}\n\nfunction readFile(absPath: AbsoluteFsPath, fs: ReadonlyFileSystem): string|undefined {\n  if (!fs.exists(absPath) || !fs.stat(absPath).isFile()) {\n    return undefined;\n  }\n  return fs.readFile(absPath);\n}\n\n/**\n * Creates a `ts.ModuleResolutionCache` that uses the provided filesystem for path operations.\n *\n * @param fs The filesystem to use for path operations.\n */\nexport function createModuleResolutionCache(fs: ReadonlyFileSystem): ts.ModuleResolutionCache {\n  return ts.createModuleResolutionCache(fs.pwd(), fileName => {\n    return fs.isCaseSensitive() ? fileName : fileName.toLowerCase();\n  });\n}\n"]}
|