forked from vercel/next.js
/
jsconfig-paths-plugin.ts
275 lines (244 loc) · 8.2 KB
/
jsconfig-paths-plugin.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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
/**
* This webpack resolver is largely based on TypeScript's "paths" handling
* The TypeScript license can be found here:
* https://github.com/microsoft/TypeScript/blob/214df64e287804577afa1fea0184c18c40f7d1ca/LICENSE.txt
*/
import path from 'path'
import { webpack } from 'next/dist/compiled/webpack/webpack'
import { debug } from 'next/dist/compiled/debug'
const log = debug('next:jsconfig-paths-plugin')
export interface Pattern {
prefix: string
suffix: string
}
const asterisk = 0x2a
export function hasZeroOrOneAsteriskCharacter(str: string): boolean {
let seenAsterisk = false
for (let i = 0; i < str.length; i++) {
if (str.charCodeAt(i) === asterisk) {
if (!seenAsterisk) {
seenAsterisk = true
} else {
// have already seen asterisk
return false
}
}
}
return true
}
/**
* Determines whether a path starts with a relative path component (i.e. `.` or `..`).
*/
export function pathIsRelative(testPath: string): boolean {
return /^\.\.?($|[\\/])/.test(testPath)
}
export function tryParsePattern(pattern: string): Pattern | undefined {
// This should be verified outside of here and a proper error thrown.
const indexOfStar = pattern.indexOf('*')
return indexOfStar === -1
? undefined
: {
prefix: pattern.slice(0, indexOfStar),
suffix: pattern.slice(indexOfStar + 1),
}
}
function isPatternMatch({ prefix, suffix }: Pattern, candidate: string) {
return (
candidate.length >= prefix.length + suffix.length &&
candidate.startsWith(prefix) &&
candidate.endsWith(suffix)
)
}
/** Return the object corresponding to the best pattern to match `candidate`. */
export function findBestPatternMatch<T>(
values: readonly T[],
getPattern: (value: T) => Pattern,
candidate: string
): T | undefined {
let matchedValue: T | undefined
// use length of prefix as betterness criteria
let longestMatchPrefixLength = -1
for (const v of values) {
const pattern = getPattern(v)
if (
isPatternMatch(pattern, candidate) &&
pattern.prefix.length > longestMatchPrefixLength
) {
longestMatchPrefixLength = pattern.prefix.length
matchedValue = v
}
}
return matchedValue
}
/**
* patternStrings contains both pattern strings (containing "*") and regular strings.
* Return an exact match if possible, or a pattern match, or undefined.
* (These are verified by verifyCompilerOptions to have 0 or 1 "*" characters.)
*/
export function matchPatternOrExact(
patternStrings: readonly string[],
candidate: string
): string | Pattern | undefined {
const patterns: Pattern[] = []
for (const patternString of patternStrings) {
if (!hasZeroOrOneAsteriskCharacter(patternString)) continue
const pattern = tryParsePattern(patternString)
if (pattern) {
patterns.push(pattern)
} else if (patternString === candidate) {
// pattern was matched as is - no need to search further
return patternString
}
}
return findBestPatternMatch(patterns, (_) => _, candidate)
}
/**
* Tests whether a value is string
*/
export function isString(text: unknown): text is string {
return typeof text === 'string'
}
/**
* Given that candidate matches pattern, returns the text matching the '*'.
* E.g.: matchedText(tryParsePattern("foo*baz"), "foobarbaz") === "bar"
*/
export function matchedText(pattern: Pattern, candidate: string): string {
return candidate.substring(
pattern.prefix.length,
candidate.length - pattern.suffix.length
)
}
export function patternText({ prefix, suffix }: Pattern): string {
return `${prefix}*${suffix}`
}
/**
* Calls the iterator function for each entry of the array
* until the first result or error is reached
*/
function forEachBail<TEntry>(
array: TEntry[],
iterator: (
entry: TEntry,
entryCallback: (err?: any, result?: any) => void
) => void,
callback: (err?: any, result?: any) => void
): void {
if (array.length === 0) return callback()
let i = 0
const next = () => {
let loop: boolean | undefined = undefined
iterator(array[i++], (err, result) => {
if (err || result !== undefined || i >= array.length) {
return callback(err, result)
}
if (loop === false) while (next());
loop = true
})
if (!loop) loop = false
return loop
}
while (next());
}
const NODE_MODULES_REGEX = /node_modules/
type Paths = { [match: string]: string[] }
/**
* Handles tsconfig.json or jsconfig.js "paths" option for webpack
* Largely based on how the TypeScript compiler handles it:
* https://github.com/microsoft/TypeScript/blob/1a9c8197fffe3dace5f8dca6633d450a88cba66d/src/compiler/moduleNameResolver.ts#L1362
*/
export class JsConfigPathsPlugin implements webpack.ResolvePluginInstance {
paths: Paths
resolvedBaseUrl: string
jsConfigPlugin: true
constructor(paths: Paths, resolvedBaseUrl: string) {
this.paths = paths
this.resolvedBaseUrl = resolvedBaseUrl
this.jsConfigPlugin = true
log('tsconfig.json or jsconfig.json paths: %O', paths)
log('resolved baseUrl: %s', resolvedBaseUrl)
}
apply(resolver: any) {
const target = resolver.ensureHook('resolve')
resolver
.getHook('described-resolve')
.tapAsync(
'JsConfigPathsPlugin',
(
request: any,
resolveContext: any,
callback: (err?: any, result?: any) => void
) => {
const paths = this.paths
const pathsKeys = Object.keys(paths)
// If no aliases are added bail out
if (pathsKeys.length === 0) {
log('paths are empty, bailing out')
return callback()
}
const moduleName = request.request
// Exclude node_modules from paths support (speeds up resolving)
if (request.path.match(NODE_MODULES_REGEX)) {
log('skipping request as it is inside node_modules %s', moduleName)
return callback()
}
if (
path.posix.isAbsolute(moduleName) ||
(process.platform === 'win32' && path.win32.isAbsolute(moduleName))
) {
log('skipping request as it is an absolute path %s', moduleName)
return callback()
}
if (pathIsRelative(moduleName)) {
log('skipping request as it is a relative path %s', moduleName)
return callback()
}
// log('starting to resolve request %s', moduleName)
// If the module name does not match any of the patterns in `paths` we hand off resolving to webpack
const matchedPattern = matchPatternOrExact(pathsKeys, moduleName)
if (!matchedPattern) {
log('moduleName did not match any paths pattern %s', moduleName)
return callback()
}
const matchedStar = isString(matchedPattern)
? undefined
: matchedText(matchedPattern, moduleName)
const matchedPatternText = isString(matchedPattern)
? matchedPattern
: patternText(matchedPattern)
let triedPaths = []
forEachBail(
paths[matchedPatternText],
(subst, pathCallback) => {
const curPath = matchedStar
? subst.replace('*', matchedStar)
: subst
// Ensure .d.ts is not matched
if (curPath.endsWith('.d.ts')) {
// try next path candidate
return pathCallback()
}
const candidate = path.join(this.resolvedBaseUrl, curPath)
const obj = Object.assign({}, request, {
request: candidate,
})
resolver.doResolve(
target,
obj,
`Aliased with tsconfig.json or jsconfig.json ${matchedPatternText} to ${candidate}`,
resolveContext,
(resolverErr: any, resolverResult: any) => {
if (resolverErr || resolverResult === undefined) {
triedPaths.push(candidate)
// try next path candidate
return pathCallback()
}
return pathCallback(resolverErr, resolverResult)
}
)
},
callback
)
}
)
}
}