source: trip-planner-front/node_modules/@angular/compiler-cli/ngcc/src/dependencies/module_resolver.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/dependencies/module_resolver", ["require", "exports", "tslib", "@angular/compiler-cli/ngcc/src/utils"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ResolvedDeepImport = exports.ResolvedRelativeModule = exports.ResolvedExternalModule = exports.ModuleResolver = void 0;
    var tslib_1 = require("tslib");
    var utils_1 = require("@angular/compiler-cli/ngcc/src/utils");
    /**
     * This is a very cut-down implementation of the TypeScript module resolution strategy.
     *
     * It is specific to the needs of ngcc and is not intended to be a drop-in replacement
     * for the TS module resolver. It is used to compute the dependencies between entry-points
     * that may be compiled by ngcc.
     *
     * The algorithm only finds `.js` files for internal/relative imports and paths to
     * the folder containing the `package.json` of the entry-point for external imports.
     *
     * It can cope with nested `node_modules` folders and also supports `paths`/`baseUrl`
     * configuration properties, as provided in a `ts.CompilerOptions` object.
     */
    var ModuleResolver = /** @class */ (function () {
        function ModuleResolver(fs, pathMappings, relativeExtensions) {
            if (relativeExtensions === void 0) { relativeExtensions = ['', '.js', '/index.js']; }
            this.fs = fs;
            this.relativeExtensions = relativeExtensions;
            this.pathMappings = pathMappings ? this.processPathMappings(pathMappings) : [];
        }
        /**
         * Resolve an absolute path for the `moduleName` imported into a file at `fromPath`.
         * @param moduleName The name of the import to resolve.
         * @param fromPath The path to the file containing the import.
         * @returns A path to the resolved module or null if missing.
         * Specifically:
         *  * the absolute path to the package.json of an external module
         *  * a JavaScript file of an internal module
         *  * null if none exists.
         */
        ModuleResolver.prototype.resolveModuleImport = function (moduleName, fromPath) {
            if (utils_1.isRelativePath(moduleName)) {
                return this.resolveAsRelativePath(moduleName, fromPath);
            }
            else {
                return this.pathMappings.length && this.resolveByPathMappings(moduleName, fromPath) ||
                    this.resolveAsEntryPoint(moduleName, fromPath);
            }
        };
        /**
         * Convert the `pathMappings` into a collection of `PathMapper` functions.
         */
        ModuleResolver.prototype.processPathMappings = function (pathMappings) {
            var baseUrl = this.fs.resolve(pathMappings.baseUrl);
            return Object.keys(pathMappings.paths).map(function (pathPattern) {
                var matcher = splitOnStar(pathPattern);
                var templates = pathMappings.paths[pathPattern].map(splitOnStar);
                return { matcher: matcher, templates: templates, baseUrl: baseUrl };
            });
        };
        /**
         * Try to resolve a module name, as a relative path, from the `fromPath`.
         *
         * As it is relative, it only looks for files that end in one of the `relativeExtensions`.
         * For example: `${moduleName}.js` or `${moduleName}/index.js`.
         * If neither of these files exist then the method returns `null`.
         */
        ModuleResolver.prototype.resolveAsRelativePath = function (moduleName, fromPath) {
            var resolvedPath = utils_1.resolveFileWithPostfixes(this.fs, this.fs.resolve(this.fs.dirname(fromPath), moduleName), this.relativeExtensions);
            return resolvedPath && new ResolvedRelativeModule(resolvedPath);
        };
        /**
         * Try to resolve the `moduleName`, by applying the computed `pathMappings` and
         * then trying to resolve the mapped path as a relative or external import.
         *
         * Whether the mapped path is relative is defined as it being "below the `fromPath`" and not
         * containing `node_modules`.
         *
         * If the mapped path is not relative but does not resolve to an external entry-point, then we
         * check whether it would have resolved to a relative path, in which case it is marked as a
         * "deep-import".
         */
        ModuleResolver.prototype.resolveByPathMappings = function (moduleName, fromPath) {
            var e_1, _a;
            var mappedPaths = this.findMappedPaths(moduleName);
            if (mappedPaths.length > 0) {
                var packagePath = this.findPackagePath(fromPath);
                if (packagePath !== null) {
                    try {
                        for (var mappedPaths_1 = tslib_1.__values(mappedPaths), mappedPaths_1_1 = mappedPaths_1.next(); !mappedPaths_1_1.done; mappedPaths_1_1 = mappedPaths_1.next()) {
                            var mappedPath = mappedPaths_1_1.value;
                            if (this.isEntryPoint(mappedPath)) {
                                return new ResolvedExternalModule(mappedPath);
                            }
                            var nonEntryPointImport = this.resolveAsRelativePath(mappedPath, fromPath);
                            if (nonEntryPointImport !== null) {
                                return isRelativeImport(packagePath, mappedPath) ? nonEntryPointImport :
                                    new ResolvedDeepImport(mappedPath);
                            }
                        }
                    }
                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
                    finally {
                        try {
                            if (mappedPaths_1_1 && !mappedPaths_1_1.done && (_a = mappedPaths_1.return)) _a.call(mappedPaths_1);
                        }
                        finally { if (e_1) throw e_1.error; }
                    }
                }
            }
            return null;
        };
        /**
         * Try to resolve the `moduleName` as an external entry-point by searching the `node_modules`
         * folders up the tree for a matching `.../node_modules/${moduleName}`.
         *
         * If a folder is found but the path does not contain a `package.json` then it is marked as a
         * "deep-import".
         */
        ModuleResolver.prototype.resolveAsEntryPoint = function (moduleName, fromPath) {
            var folder = fromPath;
            while (!this.fs.isRoot(folder)) {
                folder = this.fs.dirname(folder);
                if (folder.endsWith('node_modules')) {
                    // Skip up if the folder already ends in node_modules
                    folder = this.fs.dirname(folder);
                }
                var modulePath = this.fs.resolve(folder, 'node_modules', moduleName);
                if (this.isEntryPoint(modulePath)) {
                    return new ResolvedExternalModule(modulePath);
                }
                else if (this.resolveAsRelativePath(modulePath, fromPath)) {
                    return new ResolvedDeepImport(modulePath);
                }
            }
            return null;
        };
        /**
         * Can we consider the given path as an entry-point to a package?
         *
         * This is achieved by checking for the existence of `${modulePath}/package.json`.
         */
        ModuleResolver.prototype.isEntryPoint = function (modulePath) {
            return this.fs.exists(this.fs.join(modulePath, 'package.json'));
        };
        /**
         * Apply the `pathMappers` to the `moduleName` and return all the possible
         * paths that match.
         *
         * The mapped path is computed for each template in `mapping.templates` by
         * replacing the `matcher.prefix` and `matcher.postfix` strings in `path with the
         * `template.prefix` and `template.postfix` strings.
         */
        ModuleResolver.prototype.findMappedPaths = function (moduleName) {
            var _this = this;
            var matches = this.pathMappings.map(function (mapping) { return _this.matchMapping(moduleName, mapping); });
            var bestMapping;
            var bestMatch;
            for (var index = 0; index < this.pathMappings.length; index++) {
                var mapping = this.pathMappings[index];
                var match = matches[index];
                if (match !== null) {
                    // If this mapping had no wildcard then this must be a complete match.
                    if (!mapping.matcher.hasWildcard) {
                        bestMatch = match;
                        bestMapping = mapping;
                        break;
                    }
                    // The best matched mapping is the one with the longest prefix.
                    if (!bestMapping || mapping.matcher.prefix > bestMapping.matcher.prefix) {
                        bestMatch = match;
                        bestMapping = mapping;
                    }
                }
            }
            return (bestMapping !== undefined && bestMatch !== undefined) ?
                this.computeMappedTemplates(bestMapping, bestMatch) :
                [];
        };
        /**
         * Attempt to find a mapped path for the given `path` and a `mapping`.
         *
         * The `path` matches the `mapping` if if it starts with `matcher.prefix` and ends with
         * `matcher.postfix`.
         *
         * @returns the wildcard segment of a matched `path`, or `null` if no match.
         */
        ModuleResolver.prototype.matchMapping = function (path, mapping) {
            var _a = mapping.matcher, prefix = _a.prefix, postfix = _a.postfix, hasWildcard = _a.hasWildcard;
            if (hasWildcard) {
                return (path.startsWith(prefix) && path.endsWith(postfix)) ?
                    path.substring(prefix.length, path.length - postfix.length) :
                    null;
            }
            else {
                return (path === prefix) ? '' : null;
            }
        };
        /**
         * Compute the candidate paths from the given mapping's templates using the matched
         * string.
         */
        ModuleResolver.prototype.computeMappedTemplates = function (mapping, match) {
            var _this = this;
            return mapping.templates.map(function (template) { return _this.fs.resolve(mapping.baseUrl, template.prefix + match + template.postfix); });
        };
        /**
         * Search up the folder tree for the first folder that contains `package.json`
         * or `null` if none is found.
         */
        ModuleResolver.prototype.findPackagePath = function (path) {
            var folder = path;
            while (!this.fs.isRoot(folder)) {
                folder = this.fs.dirname(folder);
                if (this.fs.exists(this.fs.join(folder, 'package.json'))) {
                    return folder;
                }
            }
            return null;
        };
        return ModuleResolver;
    }());
    exports.ModuleResolver = ModuleResolver;
    /**
     * A module that is external to the package doing the importing.
     * In this case we capture the folder containing the entry-point.
     */
    var ResolvedExternalModule = /** @class */ (function () {
        function ResolvedExternalModule(entryPointPath) {
            this.entryPointPath = entryPointPath;
        }
        return ResolvedExternalModule;
    }());
    exports.ResolvedExternalModule = ResolvedExternalModule;
    /**
     * A module that is relative to the module doing the importing, and so internal to the
     * source module's package.
     */
    var ResolvedRelativeModule = /** @class */ (function () {
        function ResolvedRelativeModule(modulePath) {
            this.modulePath = modulePath;
        }
        return ResolvedRelativeModule;
    }());
    exports.ResolvedRelativeModule = ResolvedRelativeModule;
    /**
     * A module that is external to the package doing the importing but pointing to a
     * module that is deep inside a package, rather than to an entry-point of the package.
     */
    var ResolvedDeepImport = /** @class */ (function () {
        function ResolvedDeepImport(importPath) {
            this.importPath = importPath;
        }
        return ResolvedDeepImport;
    }());
    exports.ResolvedDeepImport = ResolvedDeepImport;
    function splitOnStar(str) {
        var _a = tslib_1.__read(str.split('*', 2), 2), prefix = _a[0], postfix = _a[1];
        return { prefix: prefix, postfix: postfix || '', hasWildcard: postfix !== undefined };
    }
    function isRelativeImport(from, to) {
        return to.startsWith(from) && !to.includes('node_modules');
    }
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module_resolver.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/dependencies/module_resolver.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 {AbsoluteFsPath, ReadonlyFileSystem} from '../../../src/ngtsc/file_system';\nimport {PathMappings} from '../path_mappings';\nimport {isRelativePath, resolveFileWithPostfixes} from '../utils';\n\n/**\n * This is a very cut-down implementation of the TypeScript module resolution strategy.\n *\n * It is specific to the needs of ngcc and is not intended to be a drop-in replacement\n * for the TS module resolver. It is used to compute the dependencies between entry-points\n * that may be compiled by ngcc.\n *\n * The algorithm only finds `.js` files for internal/relative imports and paths to\n * the folder containing the `package.json` of the entry-point for external imports.\n *\n * It can cope with nested `node_modules` folders and also supports `paths`/`baseUrl`\n * configuration properties, as provided in a `ts.CompilerOptions` object.\n */\nexport class ModuleResolver {\n  private pathMappings: ProcessedPathMapping[];\n\n  constructor(\n      private fs: ReadonlyFileSystem, pathMappings?: PathMappings,\n      readonly relativeExtensions = ['', '.js', '/index.js']) {\n    this.pathMappings = pathMappings ? this.processPathMappings(pathMappings) : [];\n  }\n\n  /**\n   * Resolve an absolute path for the `moduleName` imported into a file at `fromPath`.\n   * @param moduleName The name of the import to resolve.\n   * @param fromPath The path to the file containing the import.\n   * @returns A path to the resolved module or null if missing.\n   * Specifically:\n   *  * the absolute path to the package.json of an external module\n   *  * a JavaScript file of an internal module\n   *  * null if none exists.\n   */\n  resolveModuleImport(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    if (isRelativePath(moduleName)) {\n      return this.resolveAsRelativePath(moduleName, fromPath);\n    } else {\n      return this.pathMappings.length && this.resolveByPathMappings(moduleName, fromPath) ||\n          this.resolveAsEntryPoint(moduleName, fromPath);\n    }\n  }\n\n  /**\n   * Convert the `pathMappings` into a collection of `PathMapper` functions.\n   */\n  private processPathMappings(pathMappings: PathMappings): ProcessedPathMapping[] {\n    const baseUrl = this.fs.resolve(pathMappings.baseUrl);\n    return Object.keys(pathMappings.paths).map(pathPattern => {\n      const matcher = splitOnStar(pathPattern);\n      const templates = pathMappings.paths[pathPattern].map(splitOnStar);\n      return {matcher, templates, baseUrl};\n    });\n  }\n\n  /**\n   * Try to resolve a module name, as a relative path, from the `fromPath`.\n   *\n   * As it is relative, it only looks for files that end in one of the `relativeExtensions`.\n   * For example: `${moduleName}.js` or `${moduleName}/index.js`.\n   * If neither of these files exist then the method returns `null`.\n   */\n  private resolveAsRelativePath(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    const resolvedPath = resolveFileWithPostfixes(\n        this.fs, this.fs.resolve(this.fs.dirname(fromPath), moduleName), this.relativeExtensions);\n    return resolvedPath && new ResolvedRelativeModule(resolvedPath);\n  }\n\n  /**\n   * Try to resolve the `moduleName`, by applying the computed `pathMappings` and\n   * then trying to resolve the mapped path as a relative or external import.\n   *\n   * Whether the mapped path is relative is defined as it being \"below the `fromPath`\" and not\n   * containing `node_modules`.\n   *\n   * If the mapped path is not relative but does not resolve to an external entry-point, then we\n   * check whether it would have resolved to a relative path, in which case it is marked as a\n   * \"deep-import\".\n   */\n  private resolveByPathMappings(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    const mappedPaths = this.findMappedPaths(moduleName);\n    if (mappedPaths.length > 0) {\n      const packagePath = this.findPackagePath(fromPath);\n      if (packagePath !== null) {\n        for (const mappedPath of mappedPaths) {\n          if (this.isEntryPoint(mappedPath)) {\n            return new ResolvedExternalModule(mappedPath);\n          }\n          const nonEntryPointImport = this.resolveAsRelativePath(mappedPath, fromPath);\n          if (nonEntryPointImport !== null) {\n            return isRelativeImport(packagePath, mappedPath) ? nonEntryPointImport :\n                                                               new ResolvedDeepImport(mappedPath);\n          }\n        }\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Try to resolve the `moduleName` as an external entry-point by searching the `node_modules`\n   * folders up the tree for a matching `.../node_modules/${moduleName}`.\n   *\n   * If a folder is found but the path does not contain a `package.json` then it is marked as a\n   * \"deep-import\".\n   */\n  private resolveAsEntryPoint(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    let folder = fromPath;\n    while (!this.fs.isRoot(folder)) {\n      folder = this.fs.dirname(folder);\n      if (folder.endsWith('node_modules')) {\n        // Skip up if the folder already ends in node_modules\n        folder = this.fs.dirname(folder);\n      }\n      const modulePath = this.fs.resolve(folder, 'node_modules', moduleName);\n      if (this.isEntryPoint(modulePath)) {\n        return new ResolvedExternalModule(modulePath);\n      } else if (this.resolveAsRelativePath(modulePath, fromPath)) {\n        return new ResolvedDeepImport(modulePath);\n      }\n    }\n    return null;\n  }\n\n\n  /**\n   * Can we consider the given path as an entry-point to a package?\n   *\n   * This is achieved by checking for the existence of `${modulePath}/package.json`.\n   */\n  private isEntryPoint(modulePath: AbsoluteFsPath): boolean {\n    return this.fs.exists(this.fs.join(modulePath, 'package.json'));\n  }\n\n  /**\n   * Apply the `pathMappers` to the `moduleName` and return all the possible\n   * paths that match.\n   *\n   * The mapped path is computed for each template in `mapping.templates` by\n   * replacing the `matcher.prefix` and `matcher.postfix` strings in `path with the\n   * `template.prefix` and `template.postfix` strings.\n   */\n  private findMappedPaths(moduleName: string): AbsoluteFsPath[] {\n    const matches = this.pathMappings.map(mapping => this.matchMapping(moduleName, mapping));\n\n    let bestMapping: ProcessedPathMapping|undefined;\n    let bestMatch: string|undefined;\n\n    for (let index = 0; index < this.pathMappings.length; index++) {\n      const mapping = this.pathMappings[index];\n      const match = matches[index];\n      if (match !== null) {\n        // If this mapping had no wildcard then this must be a complete match.\n        if (!mapping.matcher.hasWildcard) {\n          bestMatch = match;\n          bestMapping = mapping;\n          break;\n        }\n        // The best matched mapping is the one with the longest prefix.\n        if (!bestMapping || mapping.matcher.prefix > bestMapping.matcher.prefix) {\n          bestMatch = match;\n          bestMapping = mapping;\n        }\n      }\n    }\n\n    return (bestMapping !== undefined && bestMatch !== undefined) ?\n        this.computeMappedTemplates(bestMapping, bestMatch) :\n        [];\n  }\n\n  /**\n   * Attempt to find a mapped path for the given `path` and a `mapping`.\n   *\n   * The `path` matches the `mapping` if if it starts with `matcher.prefix` and ends with\n   * `matcher.postfix`.\n   *\n   * @returns the wildcard segment of a matched `path`, or `null` if no match.\n   */\n  private matchMapping(path: string, mapping: ProcessedPathMapping): string|null {\n    const {prefix, postfix, hasWildcard} = mapping.matcher;\n    if (hasWildcard) {\n      return (path.startsWith(prefix) && path.endsWith(postfix)) ?\n          path.substring(prefix.length, path.length - postfix.length) :\n          null;\n    } else {\n      return (path === prefix) ? '' : null;\n    }\n  }\n\n  /**\n   * Compute the candidate paths from the given mapping's templates using the matched\n   * string.\n   */\n  private computeMappedTemplates(mapping: ProcessedPathMapping, match: string) {\n    return mapping.templates.map(\n        template => this.fs.resolve(mapping.baseUrl, template.prefix + match + template.postfix));\n  }\n\n  /**\n   * Search up the folder tree for the first folder that contains `package.json`\n   * or `null` if none is found.\n   */\n  private findPackagePath(path: AbsoluteFsPath): AbsoluteFsPath|null {\n    let folder = path;\n    while (!this.fs.isRoot(folder)) {\n      folder = this.fs.dirname(folder);\n      if (this.fs.exists(this.fs.join(folder, 'package.json'))) {\n        return folder;\n      }\n    }\n    return null;\n  }\n}\n\n/** The result of resolving an import to a module. */\nexport type ResolvedModule = ResolvedExternalModule|ResolvedRelativeModule|ResolvedDeepImport;\n\n/**\n * A module that is external to the package doing the importing.\n * In this case we capture the folder containing the entry-point.\n */\nexport class ResolvedExternalModule {\n  constructor(public entryPointPath: AbsoluteFsPath) {}\n}\n\n/**\n * A module that is relative to the module doing the importing, and so internal to the\n * source module's package.\n */\nexport class ResolvedRelativeModule {\n  constructor(public modulePath: AbsoluteFsPath) {}\n}\n\n/**\n * A module that is external to the package doing the importing but pointing to a\n * module that is deep inside a package, rather than to an entry-point of the package.\n */\nexport class ResolvedDeepImport {\n  constructor(public importPath: AbsoluteFsPath) {}\n}\n\nfunction splitOnStar(str: string): PathMappingPattern {\n  const [prefix, postfix] = str.split('*', 2);\n  return {prefix, postfix: postfix || '', hasWildcard: postfix !== undefined};\n}\n\ninterface ProcessedPathMapping {\n  baseUrl: AbsoluteFsPath;\n  matcher: PathMappingPattern;\n  templates: PathMappingPattern[];\n}\n\ninterface PathMappingPattern {\n  prefix: string;\n  postfix: string;\n  hasWildcard: boolean;\n}\n\nfunction isRelativeImport(from: AbsoluteFsPath, to: AbsoluteFsPath) {\n  return to.startsWith(from) && !to.includes('node_modules');\n}\n"]}