@angular/compiler-cli 12.1.1 → 12.1.5

package/ngcc/src/entry_point_finder/targeted_entry_point_finder.mjs

@@ -1,216 +0,0 @@
-import { hasBeenProcessed } from '../packages/build_marker';
-import { getEntryPointInfo, isEntryPoint } from '../packages/entry_point';
-import { TracingEntryPointFinder } from './tracing_entry_point_finder';
-/**
- * An EntryPointFinder that starts from a target entry-point and only finds
- * entry-points that are dependencies of the target.
- *
- * This is faster than searching the entire file-system for all the entry-points,
- * and is used primarily by the CLI integration.
- */
-export class TargetedEntryPointFinder extends TracingEntryPointFinder {
-    constructor(fs, config, logger, resolver, basePath, pathMappings, targetPath) {
-        super(fs, config, logger, resolver, basePath, pathMappings);
-        this.targetPath = targetPath;
-    }
-    /**
-     * Search for Angular entry-points that can be reached from the entry-point specified by the given
-     * `targetPath`.
-     */
-    findEntryPoints() {
-        const entryPoints = super.findEntryPoints();
-        const invalidTarget = entryPoints.invalidEntryPoints.find(i => i.entryPoint.path === this.targetPath);
-        if (invalidTarget !== undefined) {
-            throw new Error(`The target entry-point "${invalidTarget.entryPoint.name}" has missing dependencies:\n` +
-                invalidTarget.missingDependencies.map(dep => ` - ${dep}\n`).join(''));
-        }
-        return entryPoints;
-    }
-    /**
-     * Determine whether the entry-point at the given `targetPath` needs to be processed.
-     *
-     * @param propertiesToConsider the package.json properties that should be considered for
-     *     processing.
-     * @param compileAllFormats true if all formats need to be processed, or false if it is enough for
-     *     one of the formats covered by the `propertiesToConsider` is processed.
-     */
-    targetNeedsProcessingOrCleaning(propertiesToConsider, compileAllFormats) {
-        const entryPointWithDeps = this.getEntryPointWithDeps(this.targetPath);
-        if (entryPointWithDeps === null) {
-            return false;
-        }
-        for (const property of propertiesToConsider) {
-            if (entryPointWithDeps.entryPoint.packageJson[property]) {
-                // Here is a property that should be processed.
-                if (!hasBeenProcessed(entryPointWithDeps.entryPoint.packageJson, property)) {
-                    return true;
-                }
-                if (!compileAllFormats) {
-                    // This property has been processed, and we only need one.
-                    return false;
-                }
-            }
-        }
-        // All `propertiesToConsider` that appear in this entry-point have been processed.
-        // In other words, there were no properties that need processing.
-        return false;
-    }
-    /**
-     * Return an array containing the `targetPath` from which to start the trace.
-     */
-    getInitialEntryPointPaths() {
-        return [this.targetPath];
-    }
-    /**
-     * For the given `entryPointPath`, compute, or retrieve, the entry-point information, including
-     * paths to other entry-points that this entry-point depends upon.
-     *
-     * @param entryPointPath the path to the entry-point whose information and dependencies are to be
-     *     retrieved or computed.
-     *
-     * @returns the entry-point and its dependencies or `null` if the entry-point is not compiled by
-     *     Angular or cannot be determined.
-     */
-    getEntryPointWithDeps(entryPointPath) {
-        const packagePath = this.computePackagePath(entryPointPath);
-        const entryPoint = getEntryPointInfo(this.fs, this.config, this.logger, packagePath, entryPointPath);
-        if (!isEntryPoint(entryPoint) || !entryPoint.compiledByAngular) {
-            return null;
-        }
-        return this.resolver.getEntryPointWithDependencies(entryPoint);
-    }
-    /**
-     * Compute the path to the package that contains the given entry-point.
-     *
-     * In this entry-point finder it is not trivial to find the containing package, since it is
-     * possible that this entry-point is not directly below the directory containing the package.
-     * Moreover, the import path could be affected by path-mapping.
-     *
-     * @param entryPointPath the path to the entry-point, whose package path we want to compute.
-     */
-    computePackagePath(entryPointPath) {
-        // First try the main basePath, to avoid having to compute the other basePaths from the paths
-        // mappings, which can be computationally intensive.
-        if (this.isPathContainedBy(this.basePath, entryPointPath)) {
-            const packagePath = this.computePackagePathFromContainingPath(entryPointPath, this.basePath);
-            if (packagePath !== null) {
-                return packagePath;
-            }
-        }
-        // The main `basePath` didn't work out so now we try the `basePaths` computed from the paths
-        // mappings in `tsconfig.json`.
-        for (const basePath of this.getBasePaths()) {
-            if (this.isPathContainedBy(basePath, entryPointPath)) {
-                const packagePath = this.computePackagePathFromContainingPath(entryPointPath, basePath);
-                if (packagePath !== null) {
-                    return packagePath;
-                }
-                // If we got here then we couldn't find a `packagePath` for the current `basePath`.
-                // Since `basePath`s are guaranteed not to be a sub-directory of each other then no other
-                // `basePath` will match either.
-                break;
-            }
-        }
-        // Finally, if we couldn't find a `packagePath` using `basePaths` then try to find the nearest
-        // `node_modules` that contains the `entryPointPath`, if there is one, and use it as a
-        // `basePath`.
-        return this.computePackagePathFromNearestNodeModules(entryPointPath);
-    }
-    /**
-     * Compute whether the `test` path is contained within the `base` path.
-     *
-     * Note that this doesn't use a simple `startsWith()` since that would result in a false positive
-     * for `test` paths such as `a/b/c-x` when the `base` path is `a/b/c`.
-     *
-     * Since `fs.relative()` can be quite expensive we check the fast possibilities first.
-     */
-    isPathContainedBy(base, test) {
-        return test === base ||
-            (test.startsWith(base) && !this.fs.relative(base, test).startsWith('..'));
-    }
-    /**
-     * Search down to the `entryPointPath` from the `containingPath` for the first `package.json` that
-     * we come to. This is the path to the entry-point's containing package. For example if
-     * `containingPath` is `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists
-     * `/a/b/c/d/package.json` and `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.
-     *
-     * To account for nested `node_modules` we actually start the search at the last `node_modules` in
-     * the `entryPointPath` that is below the `containingPath`. E.g. if `containingPath` is `/a/b/c`
-     * and `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at
-     * `/a/b/c/d/node_modules`.
-     */
-    computePackagePathFromContainingPath(entryPointPath, containingPath) {
-        let packagePath = containingPath;
-        const segments = this.splitPath(this.fs.relative(containingPath, entryPointPath));
-        let nodeModulesIndex = segments.lastIndexOf('node_modules');
-        // If there are no `node_modules` in the relative path between the `basePath` and the
-        // `entryPointPath` then just try the `basePath` as the `packagePath`.
-        // (This can be the case with path-mapped entry-points.)
-        if (nodeModulesIndex === -1) {
-            if (this.fs.exists(this.fs.join(packagePath, 'package.json'))) {
-                return packagePath;
-            }
-        }
-        // Start the search at the deepest nested `node_modules` folder that is below the `basePath`
-        // but above the `entryPointPath`, if there are any.
-        while (nodeModulesIndex >= 0) {
-            packagePath = this.fs.join(packagePath, segments.shift());
-            nodeModulesIndex--;
-        }
-        // Note that we start at the folder below the current candidate `packagePath` because the
-        // initial candidate `packagePath` is either a `node_modules` folder or the `basePath` with
-        // no `package.json`.
-        for (const segment of segments) {
-            packagePath = this.fs.join(packagePath, segment);
-            if (this.fs.exists(this.fs.join(packagePath, 'package.json'))) {
-                return packagePath;
-            }
-        }
-        return null;
-    }
-    /**
-     * Search up the directory tree from the `entryPointPath` looking for a `node_modules` directory
-     * that we can use as a potential starting point for computing the package path.
-     */
-    computePackagePathFromNearestNodeModules(entryPointPath) {
-        let packagePath = entryPointPath;
-        let scopedPackagePath = packagePath;
-        let containerPath = this.fs.dirname(packagePath);
-        while (!this.fs.isRoot(containerPath) && !containerPath.endsWith('node_modules')) {
-            scopedPackagePath = packagePath;
-            packagePath = containerPath;
-            containerPath = this.fs.dirname(containerPath);
-        }
-        if (this.fs.exists(this.fs.join(packagePath, 'package.json'))) {
-            // The directory directly below `node_modules` is a package - use it
-            return packagePath;
-        }
-        else if (this.fs.basename(packagePath).startsWith('@') &&
-            this.fs.exists(this.fs.join(scopedPackagePath, 'package.json'))) {
-            // The directory directly below the `node_modules` is a scope and the directory directly
-            // below that is a scoped package - use it
-            return scopedPackagePath;
-        }
-        else {
-            // If we get here then none of the `basePaths` contained the `entryPointPath` and the
-            // `entryPointPath` contains no `node_modules` that contains a package or a scoped
-            // package. All we can do is assume that this entry-point is a primary entry-point to a
-            // package.
-            return entryPointPath;
-        }
-    }
-    /**
-     * Split the given `path` into path segments using an FS independent algorithm.
-     */
-    splitPath(path) {
-        const segments = [];
-        let container = this.fs.dirname(path);
-        while (path !== container) {
-            segments.unshift(this.fs.basename(path));
-            path = container;
-            container = this.fs.dirname(container);
-        }
-        return segments;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"targeted_entry_point_finder.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/entry_point_finder/targeted_entry_point_finder.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, PathSegment, ReadonlyFileSystem} from '../../../src/ngtsc/file_system';\nimport {Logger} from '../../../src/ngtsc/logging';\nimport {EntryPointWithDependencies} from '../dependencies/dependency_host';\nimport {DependencyResolver, SortedEntryPointsInfo} from '../dependencies/dependency_resolver';\nimport {hasBeenProcessed} from '../packages/build_marker';\nimport {NgccConfiguration} from '../packages/configuration';\nimport {EntryPointJsonProperty, getEntryPointInfo, isEntryPoint} from '../packages/entry_point';\nimport {PathMappings} from '../path_mappings';\n\nimport {TracingEntryPointFinder} from './tracing_entry_point_finder';\n\n/**\n * An EntryPointFinder that starts from a target entry-point and only finds\n * entry-points that are dependencies of the target.\n *\n * This is faster than searching the entire file-system for all the entry-points,\n * and is used primarily by the CLI integration.\n */\nexport class TargetedEntryPointFinder extends TracingEntryPointFinder {\n  constructor(\n      fs: ReadonlyFileSystem, config: NgccConfiguration, logger: Logger,\n      resolver: DependencyResolver, basePath: AbsoluteFsPath, pathMappings: PathMappings|undefined,\n      private targetPath: AbsoluteFsPath) {\n    super(fs, config, logger, resolver, basePath, pathMappings);\n  }\n\n  /**\n   * Search for Angular entry-points that can be reached from the entry-point specified by the given\n   * `targetPath`.\n   */\n  findEntryPoints(): SortedEntryPointsInfo {\n    const entryPoints = super.findEntryPoints();\n\n    const invalidTarget =\n        entryPoints.invalidEntryPoints.find(i => i.entryPoint.path === this.targetPath);\n    if (invalidTarget !== undefined) {\n      throw new Error(\n          `The target entry-point \"${invalidTarget.entryPoint.name}\" has missing dependencies:\\n` +\n          invalidTarget.missingDependencies.map(dep => ` - ${dep}\\n`).join(''));\n    }\n    return entryPoints;\n  }\n\n  /**\n   * Determine whether the entry-point at the given `targetPath` needs to be processed.\n   *\n   * @param propertiesToConsider the package.json properties that should be considered for\n   *     processing.\n   * @param compileAllFormats true if all formats need to be processed, or false if it is enough for\n   *     one of the formats covered by the `propertiesToConsider` is processed.\n   */\n  targetNeedsProcessingOrCleaning(\n      propertiesToConsider: EntryPointJsonProperty[], compileAllFormats: boolean): boolean {\n    const entryPointWithDeps = this.getEntryPointWithDeps(this.targetPath);\n    if (entryPointWithDeps === null) {\n      return false;\n    }\n\n    for (const property of propertiesToConsider) {\n      if (entryPointWithDeps.entryPoint.packageJson[property]) {\n        // Here is a property that should be processed.\n        if (!hasBeenProcessed(entryPointWithDeps.entryPoint.packageJson, property)) {\n          return true;\n        }\n        if (!compileAllFormats) {\n          // This property has been processed, and we only need one.\n          return false;\n        }\n      }\n    }\n    // All `propertiesToConsider` that appear in this entry-point have been processed.\n    // In other words, there were no properties that need processing.\n    return false;\n  }\n\n  /**\n   * Return an array containing the `targetPath` from which to start the trace.\n   */\n  protected getInitialEntryPointPaths(): AbsoluteFsPath[] {\n    return [this.targetPath];\n  }\n\n  /**\n   * For the given `entryPointPath`, compute, or retrieve, the entry-point information, including\n   * paths to other entry-points that this entry-point depends upon.\n   *\n   * @param entryPointPath the path to the entry-point whose information and dependencies are to be\n   *     retrieved or computed.\n   *\n   * @returns the entry-point and its dependencies or `null` if the entry-point is not compiled by\n   *     Angular or cannot be determined.\n   */\n  protected getEntryPointWithDeps(entryPointPath: AbsoluteFsPath): EntryPointWithDependencies|null {\n    const packagePath = this.computePackagePath(entryPointPath);\n    const entryPoint =\n        getEntryPointInfo(this.fs, this.config, this.logger, packagePath, entryPointPath);\n    if (!isEntryPoint(entryPoint) || !entryPoint.compiledByAngular) {\n      return null;\n    }\n    return this.resolver.getEntryPointWithDependencies(entryPoint);\n  }\n\n  /**\n   * Compute the path to the package that contains the given entry-point.\n   *\n   * In this entry-point finder it is not trivial to find the containing package, since it is\n   * possible that this entry-point is not directly below the directory containing the package.\n   * Moreover, the import path could be affected by path-mapping.\n   *\n   * @param entryPointPath the path to the entry-point, whose package path we want to compute.\n   */\n  private computePackagePath(entryPointPath: AbsoluteFsPath): AbsoluteFsPath {\n    // First try the main basePath, to avoid having to compute the other basePaths from the paths\n    // mappings, which can be computationally intensive.\n    if (this.isPathContainedBy(this.basePath, entryPointPath)) {\n      const packagePath = this.computePackagePathFromContainingPath(entryPointPath, this.basePath);\n      if (packagePath !== null) {\n        return packagePath;\n      }\n    }\n\n    // The main `basePath` didn't work out so now we try the `basePaths` computed from the paths\n    // mappings in `tsconfig.json`.\n    for (const basePath of this.getBasePaths()) {\n      if (this.isPathContainedBy(basePath, entryPointPath)) {\n        const packagePath = this.computePackagePathFromContainingPath(entryPointPath, basePath);\n        if (packagePath !== null) {\n          return packagePath;\n        }\n        // If we got here then we couldn't find a `packagePath` for the current `basePath`.\n        // Since `basePath`s are guaranteed not to be a sub-directory of each other then no other\n        // `basePath` will match either.\n        break;\n      }\n    }\n\n    // Finally, if we couldn't find a `packagePath` using `basePaths` then try to find the nearest\n    // `node_modules` that contains the `entryPointPath`, if there is one, and use it as a\n    // `basePath`.\n    return this.computePackagePathFromNearestNodeModules(entryPointPath);\n  }\n\n  /**\n   * Compute whether the `test` path is contained within the `base` path.\n   *\n   * Note that this doesn't use a simple `startsWith()` since that would result in a false positive\n   * for `test` paths such as `a/b/c-x` when the `base` path is `a/b/c`.\n   *\n   * Since `fs.relative()` can be quite expensive we check the fast possibilities first.\n   */\n  private isPathContainedBy(base: AbsoluteFsPath, test: AbsoluteFsPath): boolean {\n    return test === base ||\n        (test.startsWith(base) && !this.fs.relative(base, test).startsWith('..'));\n  }\n\n  /**\n   * Search down to the `entryPointPath` from the `containingPath` for the first `package.json` that\n   * we come to. This is the path to the entry-point's containing package. For example if\n   * `containingPath` is `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists\n   * `/a/b/c/d/package.json` and `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.\n   *\n   * To account for nested `node_modules` we actually start the search at the last `node_modules` in\n   * the `entryPointPath` that is below the `containingPath`. E.g. if `containingPath` is `/a/b/c`\n   * and `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at\n   * `/a/b/c/d/node_modules`.\n   */\n  private computePackagePathFromContainingPath(\n      entryPointPath: AbsoluteFsPath, containingPath: AbsoluteFsPath): AbsoluteFsPath|null {\n    let packagePath = containingPath;\n    const segments = this.splitPath(this.fs.relative(containingPath, entryPointPath));\n    let nodeModulesIndex = segments.lastIndexOf('node_modules' as PathSegment);\n\n    // If there are no `node_modules` in the relative path between the `basePath` and the\n    // `entryPointPath` then just try the `basePath` as the `packagePath`.\n    // (This can be the case with path-mapped entry-points.)\n    if (nodeModulesIndex === -1) {\n      if (this.fs.exists(this.fs.join(packagePath, 'package.json'))) {\n        return packagePath;\n      }\n    }\n\n    // Start the search at the deepest nested `node_modules` folder that is below the `basePath`\n    // but above the `entryPointPath`, if there are any.\n    while (nodeModulesIndex >= 0) {\n      packagePath = this.fs.join(packagePath, segments.shift()!);\n      nodeModulesIndex--;\n    }\n\n    // Note that we start at the folder below the current candidate `packagePath` because the\n    // initial candidate `packagePath` is either a `node_modules` folder or the `basePath` with\n    // no `package.json`.\n    for (const segment of segments) {\n      packagePath = this.fs.join(packagePath, segment);\n      if (this.fs.exists(this.fs.join(packagePath, 'package.json'))) {\n        return packagePath;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Search up the directory tree from the `entryPointPath` looking for a `node_modules` directory\n   * that we can use as a potential starting point for computing the package path.\n   */\n  private computePackagePathFromNearestNodeModules(entryPointPath: AbsoluteFsPath): AbsoluteFsPath {\n    let packagePath = entryPointPath;\n    let scopedPackagePath = packagePath;\n    let containerPath = this.fs.dirname(packagePath);\n    while (!this.fs.isRoot(containerPath) && !containerPath.endsWith('node_modules')) {\n      scopedPackagePath = packagePath;\n      packagePath = containerPath;\n      containerPath = this.fs.dirname(containerPath);\n    }\n\n    if (this.fs.exists(this.fs.join(packagePath, 'package.json'))) {\n      // The directory directly below `node_modules` is a package - use it\n      return packagePath;\n    } else if (\n        this.fs.basename(packagePath).startsWith('@') &&\n        this.fs.exists(this.fs.join(scopedPackagePath, 'package.json'))) {\n      // The directory directly below the `node_modules` is a scope and the directory directly\n      // below that is a scoped package - use it\n      return scopedPackagePath;\n    } else {\n      // If we get here then none of the `basePaths` contained the `entryPointPath` and the\n      // `entryPointPath` contains no `node_modules` that contains a package or a scoped\n      // package. All we can do is assume that this entry-point is a primary entry-point to a\n      // package.\n      return entryPointPath;\n    }\n  }\n\n  /**\n   * Split the given `path` into path segments using an FS independent algorithm.\n   */\n  private splitPath(path: PathSegment|AbsoluteFsPath) {\n    const segments = [];\n    let container = this.fs.dirname(path);\n    while (path !== container) {\n      segments.unshift(this.fs.basename(path));\n      path = container;\n      container = this.fs.dirname(container);\n    }\n    return segments;\n  }\n}\n"]}

package/ngcc/src/entry_point_finder/tracing_entry_point_finder.mjs

@@ -1,63 +0,0 @@
-import { getBasePaths } from './utils';
-/**
- * An EntryPointFinder that starts from a set of initial files and only returns entry-points that
- * are dependencies of these files.
- *
- * This is faster than processing all entry-points in the entire file-system, and is used primarily
- * by the CLI integration.
- *
- * There are two concrete implementations of this class.
- *
- * * `TargetEntryPointFinder` - is given a single entry-point as the initial entry-point. This can
- *   be used in the synchronous CLI integration where the build tool has identified an external
- *   import to one of the source files being built.
- * * `ProgramBasedEntryPointFinder` - computes the initial entry-points from the source files
- *   computed from a `tsconfig.json` file. This can be used in the asynchronous CLI integration
- *   where the `tsconfig.json` to be used to do the build is known.
- */
-export class TracingEntryPointFinder {
-    constructor(fs, config, logger, resolver, basePath, pathMappings) {
-        this.fs = fs;
-        this.config = config;
-        this.logger = logger;
-        this.resolver = resolver;
-        this.basePath = basePath;
-        this.pathMappings = pathMappings;
-        this.basePaths = null;
-    }
-    /**
-     * Search for Angular package entry-points.
-     */
-    findEntryPoints() {
-        const unsortedEntryPoints = new Map();
-        const unprocessedPaths = this.getInitialEntryPointPaths();
-        while (unprocessedPaths.length > 0) {
-            const path = unprocessedPaths.shift();
-            const entryPointWithDeps = this.getEntryPointWithDeps(path);
-            if (entryPointWithDeps === null) {
-                continue;
-            }
-            unsortedEntryPoints.set(entryPointWithDeps.entryPoint.path, entryPointWithDeps);
-            entryPointWithDeps.depInfo.dependencies.forEach(dep => {
-                if (!unsortedEntryPoints.has(dep)) {
-                    unprocessedPaths.push(dep);
-                }
-            });
-        }
-        return this.resolver.sortEntryPointsByDependency(Array.from(unsortedEntryPoints.values()));
-    }
-    /**
-     * Parse the path-mappings to compute the base-paths that need to be considered when finding
-     * entry-points.
-     *
-     * This processing can be time-consuming if the path-mappings are complex or extensive.
-     * So the result is cached locally once computed.
-     */
-    getBasePaths() {
-        if (this.basePaths === null) {
-            this.basePaths = getBasePaths(this.logger, this.basePath, this.pathMappings);
-        }
-        return this.basePaths;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/entry_point_finder/utils.mjs

@@ -1,176 +0,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
- */
-import { getFileSystem } from '../../../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.
- */
-export function getBasePaths(logger, sourceDirectory, pathMappings) {
-    const fs = getFileSystem();
-    const basePaths = [sourceDirectory];
-    if (pathMappings) {
-        const 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.`);
-        }
-        for (const paths of Object.values(pathMappings.paths)) {
-            for (const path of paths) {
-                let foundMatch = false;
-                // We only want base paths that exist and are not files
-                const { prefix, hasWildcard } = extractPathPrefix(path);
-                let 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.
-                    const wildcardContainer = fs.dirname(basePath);
-                    const wildcardPrefix = fs.basename(basePath);
-                    if (isExistingDirectory(fs, wildcardContainer)) {
-                        const candidates = fs.readdir(wildcardContainer);
-                        for (const candidate of candidates) {
-                            if (candidate.startsWith(wildcardPrefix)) {
-                                const candidatePath = fs.resolve(wildcardContainer, candidate);
-                                if (isExistingDirectory(fs, candidatePath)) {
-                                    foundMatch = true;
-                                    basePaths.push(candidatePath);
-                                }
-                            }
-                        }
-                    }
-                }
-                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.`);
-                }
-            }
-        }
-    }
-    const 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;
-}
-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) {
-    const [prefix, rest] = path.split('*', 2);
-    return { 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`.
- */
-export function trackDuration(task, log) {
-    const startTime = Date.now();
-    const result = task();
-    const duration = Math.round((Date.now() - startTime) / 100) / 10;
-    log(duration);
-    return result;
-}
-/**
- * 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) {
-    const root = { children: new Map() };
-    for (const path of paths) {
-        addPath(fs, root, path);
-    }
-    return flattenTree(root);
-}
-/**
- * Add a path (defined by the `segments`) to the current `node` in the tree.
- */
-function addPath(fs, root, path) {
-    let node = root;
-    if (!fs.isRoot(path)) {
-        const segments = path.split('/');
-        for (let 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.
-            const 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) {
-    const paths = [];
-    const nodes = [root];
-    for (let index = 0; index < nodes.length; index++) {
-        const node = nodes[index];
-        if (isLeaf(node)) {
-            // We found a leaf so store the currentPath
-            paths.push(node.path);
-        }
-        else {
-            node.children.forEach(value => 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"]}