forked from jestjs/jest
/
defaultResolver.ts
185 lines (152 loc) Β· 4.91 KB
/
defaultResolver.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
/**
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
import {dirname, isAbsolute, resolve as pathResolve} from 'path';
import pnpResolver from 'jest-pnp-resolver';
import {SyncOpts as UpstreamResolveOptions, sync as resolveSync} from 'resolve';
import {
Options as ResolveExportsOptions,
resolve as resolveExports,
} from 'resolve.exports';
import {
PkgJson,
findClosestPackageJson,
isDirectory,
isFile,
readPackageCached,
realpathSync,
} from './fileWalkers';
// copy from `resolve`'s types so we don't have their types in our definition
// files
interface ResolverOptions {
basedir: string;
browser?: boolean;
conditions?: Array<string>;
defaultResolver: typeof defaultResolver;
extensions?: Array<string>;
moduleDirectory?: Array<string>;
paths?: Array<string>;
rootDir?: string;
packageFilter?: (pkg: PkgJson, dir: string) => PkgJson;
pathFilter?: (pkg: PkgJson, path: string, relativePath: string) => string;
}
type UpstreamResolveOptionsWithConditions = UpstreamResolveOptions &
Pick<ResolverOptions, 'basedir' | 'conditions'>;
export type SyncResolver = (path: string, options: ResolverOptions) => string;
export type AsyncResolver = (
path: string,
options: ResolverOptions,
) => Promise<string>;
export type Resolver = SyncResolver | AsyncResolver;
// https://github.com/facebook/jest/pull/10617
declare global {
namespace NodeJS {
export interface ProcessVersions {
pnp?: any;
}
}
}
const defaultResolver: SyncResolver = (path, options) => {
// Yarn 2 adds support to `resolve` automatically so the pnpResolver is only
// needed for Yarn 1 which implements version 1 of the pnp spec
if (process.versions.pnp === '1') {
return pnpResolver(path, options);
}
const resolveOptions: UpstreamResolveOptionsWithConditions = {
...options,
isDirectory,
isFile,
preserveSymlinks: false,
readPackageSync,
realpathSync,
};
const pathToResolve = getPathInModule(path, resolveOptions);
const result =
// if `getPathInModule` doesn't change the path, attempt to resolve it
pathToResolve === path
? resolveSync(pathToResolve, resolveOptions)
: pathToResolve;
// Dereference symlinks to ensure we don't create a separate
// module instance depending on how it was referenced.
return realpathSync(result);
};
export default defaultResolver;
/*
* helper functions
*/
function readPackageSync(_: unknown, file: string): PkgJson {
return readPackageCached(file);
}
function getPathInModule(
path: string,
options: UpstreamResolveOptionsWithConditions,
): string {
if (shouldIgnoreRequestForExports(path)) {
return path;
}
const segments = path.split('/');
let moduleName = segments.shift();
if (moduleName) {
// TODO: handle `#` here: https://github.com/facebook/jest/issues/12270
if (moduleName.startsWith('@')) {
moduleName = `${moduleName}/${segments.shift()}`;
}
// self-reference
const closestPackageJson = findClosestPackageJson(options.basedir);
if (closestPackageJson) {
const pkg = readPackageCached(closestPackageJson);
if (pkg.name === moduleName && pkg.exports) {
const subpath = segments.join('/') || '.';
const resolved = resolveExports(
pkg,
subpath,
createResolveOptions(options.conditions),
);
if (!resolved) {
throw new Error(
'`exports` exists, but no results - this is a bug in Jest. Please report an issue',
);
}
return pathResolve(dirname(closestPackageJson), resolved);
}
}
let packageJsonPath = '';
try {
packageJsonPath = resolveSync(`${moduleName}/package.json`, options);
} catch {
// ignore if package.json cannot be found
}
if (packageJsonPath && isFile(packageJsonPath)) {
const pkg = readPackageCached(packageJsonPath);
if (pkg.exports) {
const subpath = segments.join('/') || '.';
const resolved = resolveExports(
pkg,
subpath,
createResolveOptions(options.conditions),
);
if (!resolved) {
throw new Error(
'`exports` exists, but no results - this is a bug in Jest. Please report an issue',
);
}
return pathResolve(dirname(packageJsonPath), resolved);
}
}
}
return path;
}
function createResolveOptions(
conditions: Array<string> | undefined,
): ResolveExportsOptions {
return conditions
? {conditions, unsafe: true}
: // no conditions were passed - let's assume this is Jest internal and it should be `require`
{browser: false, require: true};
}
// if it's a relative import or an absolute path, exports are ignored
const shouldIgnoreRequestForExports = (path: string) =>
path.startsWith('.') || isAbsolute(path);