source: trip-planner-front/node_modules/@angular/compiler-cli/ngcc/src/packages/source_file_cache.js@ 6a3a178

(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"]}