e53b686375
Previously we only searched for package paths below the set of `basePaths`
that were computed from the `basePath` provided to ngcc and the set of
`pathMappings`.
In some scenarios, such as hoisted packages, the entry-point is not within
any of the `basePaths` identified above. For example:
```
project
packages
app
node_modules
app-lib (depends on lib1)
node_modules
lib1 (depends on lib2)
node_modules
lib2 (depends on lib3/entry-point)
lib3
entry-point
```
When CLI is compiling `app-lib` ngcc will be given
`project/packages/app/node_modules` as the `basePath.
If ngcc is asked to target `lib2`, the `targetPath` will be
`project/node_modules/lib1/node_modules/lib2`.
Since `lib2` depends upon `lib3/entry-point`, ngcc will need to compute
the package path for `project/node_modules/lib3/entry-point`.
Since `project/node_modules/lib3/entry-point` is not contained in the `basePath`
`project/packages/app/node_modules`, ngcc failed to compute the `packagePath`
correctly, instead assuming that it was the same as the entry-point path.
Now we also consider the nearest `node_modules` folder to the entry-point
path as an additional `basePath`. If one is found then we use the first
directory directly below that `node_modules` directory as the package path.
In the case of our example this extra `basePath` would be `project/node_modules`
which allows us to compute the `packagePath` of `project/node_modules/lib3`.
Fixes #35747
PR Close #36249
81 lines
3.0 KiB
TypeScript
81 lines
3.0 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google Inc. 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 {AbsoluteFsPath, getFileSystem, join, relative, resolve} from '../../../src/ngtsc/file_system';
|
|
import {PathMappings} from '../utils';
|
|
|
|
/**
|
|
* 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(
|
|
sourceDirectory: AbsoluteFsPath, pathMappings: PathMappings | undefined): AbsoluteFsPath[] {
|
|
const fs = getFileSystem();
|
|
const basePaths = [sourceDirectory];
|
|
if (pathMappings) {
|
|
const baseUrl = resolve(pathMappings.baseUrl);
|
|
Object.values(pathMappings.paths).forEach(paths => paths.forEach(path => {
|
|
// We only want base paths that exist and are not files
|
|
let basePath = join(baseUrl, extractPathPrefix(path));
|
|
while (basePath !== baseUrl && (!fs.exists(basePath) || fs.stat(basePath).isFile())) {
|
|
basePath = fs.dirname(basePath);
|
|
}
|
|
basePaths.push(basePath);
|
|
}));
|
|
}
|
|
basePaths.sort().reverse(); // Get the paths in order with the longer ones first.
|
|
return basePaths.filter(removeContainedPaths);
|
|
}
|
|
|
|
/**
|
|
* Extract everything in the `path` up to the first `*`.
|
|
* @param path The path to parse.
|
|
* @returns The extracted prefix.
|
|
*/
|
|
function extractPathPrefix(path: string) {
|
|
return path.split('*', 1)[0];
|
|
}
|
|
|
|
/**
|
|
* A filter function that removes 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.)
|
|
*
|
|
* @param value The current path.
|
|
* @param index The index of the current path.
|
|
* @param array The array of paths (sorted in reverse alphabetical order).
|
|
* @returns true if this path is not contained by another path.
|
|
*/
|
|
function removeContainedPaths(value: AbsoluteFsPath, index: number, array: AbsoluteFsPath[]) {
|
|
// We only need to check the following paths since the `array` is sorted in reverse alphabetic
|
|
// order.
|
|
for (let i = index + 1; i < array.length; i++) {
|
|
// We need to use `relative().startsWith()` rather than a simple `startsWith()` to ensure we
|
|
// don't assume that `a/b` contains `a/b-2`.
|
|
if (!relative(array[i], value).startsWith('..')) return false;
|
|
}
|
|
return true;
|
|
}
|