source: trip-planner-front/node_modules/@angular/compiler-cli/ngcc/src/entry_point_finder/utils.js

(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/entry_point_finder/utils", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/file_system"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.trackDuration = exports.getBasePaths = void 0;
    var tslib_1 = require("tslib");
    /**
     * @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 file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
    /**
     * Extract all the base-paths that we need to search for entry-points.
     *
     * This always contains the standard base-path (`sourceDirectory`).
     * But it also parses the `paths` mappings object to guess additional base-paths.
     *
     * For example:
     *
     * ```
     * getBasePaths('/node_modules', {baseUrl: '/dist', paths: {'*': ['lib/*', 'lib/generated/*']}})
     * > ['/node_modules', '/dist/lib']
     * ```
     *
     * Notice that `'/dist'` is not included as there is no `'*'` path,
     * and `'/dist/lib/generated'` is not included as it is covered by `'/dist/lib'`.
     *
     * @param sourceDirectory The standard base-path (e.g. node_modules).
     * @param pathMappings Path mapping configuration, from which to extract additional base-paths.
     */
    function getBasePaths(logger, sourceDirectory, pathMappings) {
        var e_1, _a, e_2, _b, e_3, _c;
        var fs = file_system_1.getFileSystem();
        var basePaths = [sourceDirectory];
        if (pathMappings) {
            var baseUrl = fs.resolve(pathMappings.baseUrl);
            if (fs.isRoot(baseUrl)) {
                logger.warn("The provided pathMappings baseUrl is the root path " + baseUrl + ".\n" +
                    "This is likely to mess up how ngcc finds entry-points and is probably not correct.\n" +
                    "Please check your path mappings configuration such as in the tsconfig.json file.");
            }
            try {
                for (var _d = tslib_1.__values(Object.values(pathMappings.paths)), _e = _d.next(); !_e.done; _e = _d.next()) {
                    var paths = _e.value;
                    try {
                        for (var paths_1 = (e_2 = void 0, tslib_1.__values(paths)), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
                            var path = paths_1_1.value;
                            var foundMatch = false;
                            // We only want base paths that exist and are not files
                            var _f = extractPathPrefix(path), prefix = _f.prefix, hasWildcard = _f.hasWildcard;
                            var basePath = fs.resolve(baseUrl, prefix);
                            if (fs.exists(basePath) && fs.stat(basePath).isFile()) {
                                basePath = fs.dirname(basePath);
                            }
                            if (fs.exists(basePath)) {
                                // The `basePath` is itself a directory
                                basePaths.push(basePath);
                                foundMatch = true;
                            }
                            if (hasWildcard) {
                                // The path contains a wildcard (`*`) so also try searching for directories that start
                                // with the wildcard prefix path segment.
                                var wildcardContainer = fs.dirname(basePath);
                                var wildcardPrefix = fs.basename(basePath);
                                if (isExistingDirectory(fs, wildcardContainer)) {
                                    var candidates = fs.readdir(wildcardContainer);
                                    try {
                                        for (var candidates_1 = (e_3 = void 0, tslib_1.__values(candidates)), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
                                            var candidate = candidates_1_1.value;
                                            if (candidate.startsWith(wildcardPrefix)) {
                                                var candidatePath = fs.resolve(wildcardContainer, candidate);
                                                if (isExistingDirectory(fs, candidatePath)) {
                                                    foundMatch = true;
                                                    basePaths.push(candidatePath);
                                                }
                                            }
                                        }
                                    }
                                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
                                    finally {
                                        try {
                                            if (candidates_1_1 && !candidates_1_1.done && (_c = candidates_1.return)) _c.call(candidates_1);
                                        }
                                        finally { if (e_3) throw e_3.error; }
                                    }
                                }
                            }
                            if (!foundMatch) {
                                // We neither found a direct match (i.e. `basePath` is an existing directory) nor a
                                // directory that starts with a wildcard prefix.
                                logger.debug("The basePath \"" + basePath + "\" computed from baseUrl \"" + baseUrl + "\" and path mapping \"" + path + "\" does not exist in the file-system.\n" +
                                    "It will not be scanned for entry-points.");
                            }
                        }
                    }
                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
                    finally {
                        try {
                            if (paths_1_1 && !paths_1_1.done && (_b = paths_1.return)) _b.call(paths_1);
                        }
                        finally { if (e_2) throw e_2.error; }
                    }
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
                }
                finally { if (e_1) throw e_1.error; }
            }
        }
        var dedupedBasePaths = dedupePaths(fs, basePaths);
        // We want to ensure that the `sourceDirectory` is included when it is a node_modules folder.
        // Otherwise our entry-point finding algorithm would fail to walk that folder.
        if (fs.basename(sourceDirectory) === 'node_modules' &&
            !dedupedBasePaths.includes(sourceDirectory)) {
            dedupedBasePaths.unshift(sourceDirectory);
        }
        return dedupedBasePaths;
    }
    exports.getBasePaths = getBasePaths;
    function isExistingDirectory(fs, path) {
        return fs.exists(path) && fs.stat(path).isDirectory();
    }
    /**
     * Extract everything in the `path` up to the first `*`.
     * @param path The path to parse.
     * @returns The extracted prefix and a flag to indicate whether there was a wildcard `*`.
     */
    function extractPathPrefix(path) {
        var _a = tslib_1.__read(path.split('*', 2), 2), prefix = _a[0], rest = _a[1];
        return { prefix: prefix, hasWildcard: rest !== undefined };
    }
    /**
     * Run a task and track how long it takes.
     *
     * @param task The task whose duration we are tracking.
     * @param log The function to call with the duration of the task.
     * @returns The result of calling `task`.
     */
    function trackDuration(task, log) {
        var startTime = Date.now();
        var result = task();
        var duration = Math.round((Date.now() - startTime) / 100) / 10;
        log(duration);
        return result;
    }
    exports.trackDuration = trackDuration;
    /**
     * Remove paths that are contained by other paths.
     *
     * For example:
     * Given `['a/b/c', 'a/b/x', 'a/b', 'd/e', 'd/f']` we will end up with `['a/b', 'd/e', 'd/f]`.
     * (Note that we do not get `d` even though `d/e` and `d/f` share a base directory, since `d` is not
     * one of the base paths.)
     */
    function dedupePaths(fs, paths) {
        var e_4, _a;
        var root = { children: new Map() };
        try {
            for (var paths_2 = tslib_1.__values(paths), paths_2_1 = paths_2.next(); !paths_2_1.done; paths_2_1 = paths_2.next()) {
                var path = paths_2_1.value;
                addPath(fs, root, path);
            }
        }
        catch (e_4_1) { e_4 = { error: e_4_1 }; }
        finally {
            try {
                if (paths_2_1 && !paths_2_1.done && (_a = paths_2.return)) _a.call(paths_2);
            }
            finally { if (e_4) throw e_4.error; }
        }
        return flattenTree(root);
    }
    /**
     * Add a path (defined by the `segments`) to the current `node` in the tree.
     */
    function addPath(fs, root, path) {
        var node = root;
        if (!fs.isRoot(path)) {
            var segments = path.split('/');
            for (var index = 0; index < segments.length; index++) {
                if (isLeaf(node)) {
                    // We hit a leaf so don't bother processing any more of the path
                    return;
                }
                // This is not the end of the path continue to process the rest of this path.
                var next = segments[index];
                if (!node.children.has(next)) {
                    node.children.set(next, { children: new Map() });
                }
                node = node.children.get(next);
            }
        }
        // This path has finished so convert this node to a leaf
        convertToLeaf(node, path);
    }
    /**
     * Flatten the tree of nodes back into an array of absolute paths.
     */
    function flattenTree(root) {
        var paths = [];
        var nodes = [root];
        for (var index = 0; index < nodes.length; index++) {
            var node = nodes[index];
            if (isLeaf(node)) {
                // We found a leaf so store the currentPath
                paths.push(node.path);
            }
            else {
                node.children.forEach(function (value) { return nodes.push(value); });
            }
        }
        return paths;
    }
    function isLeaf(node) {
        return node.path !== undefined;
    }
    function convertToLeaf(node, path) {
        node.path = path;
    }
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/entry_point_finder/utils.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, getFileSystem, PathManipulation, ReadonlyFileSystem} from '../../../src/ngtsc/file_system';\nimport {Logger} from '../../../src/ngtsc/logging';\nimport {PathMappings} from '../path_mappings';\n\n/**\n * Extract all the base-paths that we need to search for entry-points.\n *\n * This always contains the standard base-path (`sourceDirectory`).\n * But it also parses the `paths` mappings object to guess additional base-paths.\n *\n * For example:\n *\n * ```\n * getBasePaths('/node_modules', {baseUrl: '/dist', paths: {'*': ['lib/*', 'lib/generated/*']}})\n * > ['/node_modules', '/dist/lib']\n * ```\n *\n * Notice that `'/dist'` is not included as there is no `'*'` path,\n * and `'/dist/lib/generated'` is not included as it is covered by `'/dist/lib'`.\n *\n * @param sourceDirectory The standard base-path (e.g. node_modules).\n * @param pathMappings Path mapping configuration, from which to extract additional base-paths.\n */\nexport function getBasePaths(\n    logger: Logger, sourceDirectory: AbsoluteFsPath,\n    pathMappings: PathMappings|undefined): AbsoluteFsPath[] {\n  const fs = getFileSystem();\n  const basePaths = [sourceDirectory];\n  if (pathMappings) {\n    const baseUrl = fs.resolve(pathMappings.baseUrl);\n    if (fs.isRoot(baseUrl)) {\n      logger.warn(\n          `The provided pathMappings baseUrl is the root path ${baseUrl}.\\n` +\n          `This is likely to mess up how ngcc finds entry-points and is probably not correct.\\n` +\n          `Please check your path mappings configuration such as in the tsconfig.json file.`);\n    }\n    for (const paths of Object.values(pathMappings.paths)) {\n      for (const path of paths) {\n        let foundMatch = false;\n\n        // We only want base paths that exist and are not files\n        const {prefix, hasWildcard} = extractPathPrefix(path);\n        let basePath = fs.resolve(baseUrl, prefix);\n        if (fs.exists(basePath) && fs.stat(basePath).isFile()) {\n          basePath = fs.dirname(basePath);\n        }\n\n        if (fs.exists(basePath)) {\n          // The `basePath` is itself a directory\n          basePaths.push(basePath);\n          foundMatch = true;\n        }\n\n        if (hasWildcard) {\n          // The path contains a wildcard (`*`) so also try searching for directories that start\n          // with the wildcard prefix path segment.\n          const wildcardContainer = fs.dirname(basePath);\n          const wildcardPrefix = fs.basename(basePath);\n          if (isExistingDirectory(fs, wildcardContainer)) {\n            const candidates = fs.readdir(wildcardContainer);\n            for (const candidate of candidates) {\n              if (candidate.startsWith(wildcardPrefix)) {\n                const candidatePath = fs.resolve(wildcardContainer, candidate);\n                if (isExistingDirectory(fs, candidatePath)) {\n                  foundMatch = true;\n                  basePaths.push(candidatePath);\n                }\n              }\n            }\n          }\n        }\n\n        if (!foundMatch) {\n          // We neither found a direct match (i.e. `basePath` is an existing directory) nor a\n          // directory that starts with a wildcard prefix.\n          logger.debug(\n              `The basePath \"${basePath}\" computed from baseUrl \"${baseUrl}\" and path mapping \"${\n                  path}\" does not exist in the file-system.\\n` +\n              `It will not be scanned for entry-points.`);\n        }\n      }\n    }\n  }\n\n  const dedupedBasePaths = dedupePaths(fs, basePaths);\n\n  // We want to ensure that the `sourceDirectory` is included when it is a node_modules folder.\n  // Otherwise our entry-point finding algorithm would fail to walk that folder.\n  if (fs.basename(sourceDirectory) === 'node_modules' &&\n      !dedupedBasePaths.includes(sourceDirectory)) {\n    dedupedBasePaths.unshift(sourceDirectory);\n  }\n\n  return dedupedBasePaths;\n}\n\nfunction isExistingDirectory(fs: ReadonlyFileSystem, path: AbsoluteFsPath): boolean {\n  return fs.exists(path) && fs.stat(path).isDirectory();\n}\n\n/**\n * Extract everything in the `path` up to the first `*`.\n * @param path The path to parse.\n * @returns The extracted prefix and a flag to indicate whether there was a wildcard `*`.\n */\nfunction extractPathPrefix(path: string): {prefix: string, hasWildcard: boolean} {\n  const [prefix, rest] = path.split('*', 2);\n  return {prefix, hasWildcard: rest !== undefined};\n}\n\n/**\n * Run a task and track how long it takes.\n *\n * @param task The task whose duration we are tracking.\n * @param log The function to call with the duration of the task.\n * @returns The result of calling `task`.\n */\nexport function trackDuration<T = void>(task: () => T extends Promise<unknown>? never : T,\n                                                              log: (duration: number) => void): T {\n  const startTime = Date.now();\n  const result = task();\n  const duration = Math.round((Date.now() - startTime) / 100) / 10;\n  log(duration);\n  return result;\n}\n\n/**\n * Remove paths that are contained by other paths.\n *\n * For example:\n * Given `['a/b/c', 'a/b/x', 'a/b', 'd/e', 'd/f']` we will end up with `['a/b', 'd/e', 'd/f]`.\n * (Note that we do not get `d` even though `d/e` and `d/f` share a base directory, since `d` is not\n * one of the base paths.)\n */\nfunction dedupePaths(fs: PathManipulation, paths: AbsoluteFsPath[]): AbsoluteFsPath[] {\n  const root: Node = {children: new Map()};\n  for (const path of paths) {\n    addPath(fs, root, path);\n  }\n  return flattenTree(root);\n}\n\n/**\n * Add a path (defined by the `segments`) to the current `node` in the tree.\n */\nfunction addPath(fs: PathManipulation, root: Node, path: AbsoluteFsPath): void {\n  let node = root;\n  if (!fs.isRoot(path)) {\n    const segments = path.split('/');\n    for (let index = 0; index < segments.length; index++) {\n      if (isLeaf(node)) {\n        // We hit a leaf so don't bother processing any more of the path\n        return;\n      }\n      // This is not the end of the path continue to process the rest of this path.\n      const next = segments[index];\n      if (!node.children.has(next)) {\n        node.children.set(next, {children: new Map()});\n      }\n      node = node.children.get(next)!;\n    }\n  }\n  // This path has finished so convert this node to a leaf\n  convertToLeaf(node, path);\n}\n\n/**\n * Flatten the tree of nodes back into an array of absolute paths.\n */\nfunction flattenTree(root: Node): AbsoluteFsPath[] {\n  const paths: AbsoluteFsPath[] = [];\n  const nodes: Node[] = [root];\n  for (let index = 0; index < nodes.length; index++) {\n    const node = nodes[index];\n    if (isLeaf(node)) {\n      // We found a leaf so store the currentPath\n      paths.push(node.path);\n    } else {\n      node.children.forEach(value => nodes.push(value));\n    }\n  }\n  return paths;\n}\n\nfunction isLeaf(node: Node): node is Leaf {\n  return node.path !== undefined;\n}\n\nfunction convertToLeaf(node: Node, path: AbsoluteFsPath) {\n  node.path = path;\n}\n\ninterface Node {\n  children: Map<string, Node>;\n  path?: AbsoluteFsPath;\n}\n\ntype Leaf = Required<Node>;\n"]}