255 lines
8.7 KiB
JavaScript
255 lines
8.7 KiB
JavaScript
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Tobias Koppers @sokra
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
const forEachBail = require("./forEachBail");
|
|
const { PathType, getType } = require("./util/path");
|
|
|
|
/** @typedef {import("./Resolver")} Resolver */
|
|
/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
|
|
/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
|
|
/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
|
|
/** @typedef {import("./Resolver").ResolveCallback} ResolveCallback */
|
|
/** @typedef {string | string[] | false} Alias */
|
|
/** @typedef {{ alias: Alias, name: string, onlyModule?: boolean }} AliasOption */
|
|
|
|
/**
|
|
* @typedef {object} CompiledAliasOption
|
|
* @property {string} name original alias name
|
|
* @property {string} nameWithSlash name + "/" — precomputed to avoid per-resolve concat
|
|
* @property {Alias} alias alias target(s)
|
|
* @property {boolean} onlyModule normalized onlyModule flag
|
|
* @property {string | null} absolutePath absolute form of `name` (with slash ending), null when not absolute
|
|
* @property {string | null} wildcardPrefix substring before the single "*" in `name`, null when no wildcard
|
|
* @property {string | null} wildcardSuffix substring after the single "*" in `name`, null when no wildcard
|
|
* @property {number} firstCharCode first character code of `name` — used as a cheap screen on the hot path. `-1` indicates "matches any first char" (empty wildcard prefix).
|
|
* @property {boolean} arrayAlias true when `alias` is an array — precomputed so the hot path skips `Array.isArray`
|
|
*/
|
|
|
|
const EMPTY_COMPILED_OPTIONS = /** @type {CompiledAliasOption[]} */ ([]);
|
|
|
|
/**
|
|
* Precompute per-option strings used on every resolve so the hot path in
|
|
* `aliasResolveHandler` does no string concatenation / split work per entry.
|
|
* Called once per plugin apply — the returned array is stable for the
|
|
* lifetime of the resolver.
|
|
* @param {Resolver} resolver resolver
|
|
* @param {AliasOption[]} options options
|
|
* @returns {CompiledAliasOption[]} compiled options
|
|
*/
|
|
function compileAliasOptions(resolver, options) {
|
|
if (options.length === 0) return EMPTY_COMPILED_OPTIONS;
|
|
const result = Array.from({ length: options.length });
|
|
for (let i = 0; i < options.length; i++) {
|
|
const item = options[i];
|
|
const { name } = item;
|
|
let absolutePath = null;
|
|
const type = getType(name);
|
|
if (type === PathType.AbsolutePosix || type === PathType.AbsoluteWin) {
|
|
absolutePath = resolver.join(name, "_").slice(0, -1);
|
|
}
|
|
const firstStar = name.indexOf("*");
|
|
let wildcardPrefix = null;
|
|
let wildcardSuffix = null;
|
|
if (firstStar !== -1 && !name.includes("*", firstStar + 1)) {
|
|
wildcardPrefix = name.slice(0, firstStar);
|
|
wildcardSuffix = name.slice(firstStar + 1);
|
|
}
|
|
// firstCharCode: used by `aliasResolveHandler` to quickly skip aliases
|
|
// whose name can't possibly match the current innerRequest. For a plain
|
|
// alias (no wildcard) the first char of the name is also the first char
|
|
// of `nameWithSlash` and of `absolutePath` (since the latter is derived
|
|
// from name via `resolver.join(name, "_")`, which only appends). For a
|
|
// wildcard with a non-empty prefix, the first char of that prefix is
|
|
// also the first char of name. Only the `name === "*"` case (empty
|
|
// wildcard prefix) can match arbitrary first chars — encode that as -1.
|
|
let firstCharCode;
|
|
if (wildcardPrefix !== null && wildcardPrefix.length === 0) {
|
|
firstCharCode = -1;
|
|
} else {
|
|
firstCharCode = name.length > 0 ? name.charCodeAt(0) : -1;
|
|
}
|
|
result[i] = {
|
|
name,
|
|
nameWithSlash: `${name}/`,
|
|
alias: item.alias,
|
|
onlyModule: Boolean(item.onlyModule),
|
|
absolutePath,
|
|
wildcardPrefix,
|
|
wildcardSuffix,
|
|
firstCharCode,
|
|
arrayAlias: Array.isArray(item.alias),
|
|
};
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/** @typedef {(err?: null | Error, result?: null | ResolveRequest) => void} InnerCallback */
|
|
/**
|
|
* @param {Resolver} resolver resolver
|
|
* @param {CompiledAliasOption[]} options compiled options
|
|
* @param {ResolveStepHook} target target
|
|
* @param {ResolveRequest} request request
|
|
* @param {ResolveContext} resolveContext resolve context
|
|
* @param {InnerCallback} callback callback
|
|
* @returns {void}
|
|
*/
|
|
function aliasResolveHandler(
|
|
resolver,
|
|
options,
|
|
target,
|
|
request,
|
|
resolveContext,
|
|
callback,
|
|
) {
|
|
if (options.length === 0) return callback();
|
|
const innerRequest = request.request || request.path;
|
|
if (!innerRequest) return callback();
|
|
|
|
// Precompute values used in the inner scan loop so we don't recompute
|
|
// them per option. This is meaningful when `options` has hundreds of
|
|
// entries (e.g. monorepos with generated alias lists) — see the
|
|
// `huge-alias-list` / `huge-alias-miss` benchmarks.
|
|
const innerFirstCharCode = innerRequest.charCodeAt(0);
|
|
const hasRequestString = Boolean(request.request);
|
|
|
|
forEachBail(
|
|
options,
|
|
(item, callback) => {
|
|
// Cheap char-code screen: when the compiled option's first char
|
|
// doesn't match the request's first char (and it isn't an
|
|
// "empty-prefix wildcard" — encoded as -1), this option cannot
|
|
// possibly match, so skip straight away and avoid the
|
|
// `startsWith` / `===` work below.
|
|
const { firstCharCode } = item;
|
|
if (firstCharCode !== -1 && firstCharCode !== innerFirstCharCode) {
|
|
return callback();
|
|
}
|
|
|
|
/** @type {boolean} */
|
|
let shouldStop = false;
|
|
|
|
// For absolute-name aliases, accept the normalized
|
|
// `absolutePath` form as well as the raw `nameWithSlash`.
|
|
// `nameWithSlash` unconditionally appends `/`, so a raw
|
|
// windows request with native backslashes
|
|
// (e.g. `C:\\abs\\foo\\baz` against `name: "C:\\abs\\foo"`)
|
|
// otherwise fails `startsWith("C:\\abs\\foo/")` and is
|
|
// silently skipped. Mirroring the `absolutePath` check in
|
|
// both branches closes the gap without changing any
|
|
// existing matches.
|
|
const { absolutePath } = item;
|
|
const matchRequest =
|
|
innerRequest === item.name ||
|
|
(!item.onlyModule &&
|
|
((hasRequestString && innerRequest.startsWith(item.nameWithSlash)) ||
|
|
(absolutePath !== null && innerRequest.startsWith(absolutePath))));
|
|
|
|
const matchWildcard = !item.onlyModule && item.wildcardPrefix !== null;
|
|
|
|
if (matchRequest || matchWildcard) {
|
|
/**
|
|
* @param {Alias} alias alias
|
|
* @param {(err?: null | Error, result?: null | ResolveRequest) => void} callback callback
|
|
* @returns {void}
|
|
*/
|
|
const resolveWithAlias = (alias, callback) => {
|
|
if (alias === false) {
|
|
/** @type {ResolveRequest} */
|
|
const ignoreObj = {
|
|
...request,
|
|
path: false,
|
|
};
|
|
if (typeof resolveContext.yield === "function") {
|
|
resolveContext.yield(ignoreObj);
|
|
return callback(null, null);
|
|
}
|
|
return callback(null, ignoreObj);
|
|
}
|
|
|
|
let newRequestStr;
|
|
|
|
if (
|
|
matchWildcard &&
|
|
innerRequest.startsWith(
|
|
/** @type {string} */ (item.wildcardPrefix),
|
|
) &&
|
|
innerRequest.endsWith(/** @type {string} */ (item.wildcardSuffix))
|
|
) {
|
|
const match = innerRequest.slice(
|
|
/** @type {string} */ (item.wildcardPrefix).length,
|
|
innerRequest.length -
|
|
/** @type {string} */ (item.wildcardSuffix).length,
|
|
);
|
|
newRequestStr = alias.toString().replace("*", match);
|
|
}
|
|
|
|
if (
|
|
matchRequest &&
|
|
innerRequest !== alias &&
|
|
!innerRequest.startsWith(`${alias}/`)
|
|
) {
|
|
/** @type {string} */
|
|
const remainingRequest = innerRequest.slice(item.name.length);
|
|
newRequestStr = alias + remainingRequest;
|
|
}
|
|
|
|
if (newRequestStr !== undefined) {
|
|
shouldStop = true;
|
|
/** @type {ResolveRequest} */
|
|
const obj = {
|
|
...request,
|
|
request: newRequestStr,
|
|
fullySpecified: false,
|
|
};
|
|
return resolver.doResolve(
|
|
target,
|
|
obj,
|
|
`aliased with mapping '${item.name}': '${alias}' to '${newRequestStr}'`,
|
|
resolveContext,
|
|
(err, result) => {
|
|
if (err) return callback(err);
|
|
if (result) return callback(null, result);
|
|
return callback();
|
|
},
|
|
);
|
|
}
|
|
return callback();
|
|
};
|
|
|
|
/**
|
|
* @param {(null | Error)=} err error
|
|
* @param {(null | ResolveRequest)=} result result
|
|
* @returns {void}
|
|
*/
|
|
const stoppingCallback = (err, result) => {
|
|
if (err) return callback(err);
|
|
|
|
if (result) return callback(null, result);
|
|
// Don't allow other aliasing or raw request
|
|
if (shouldStop) return callback(null, null);
|
|
return callback();
|
|
};
|
|
|
|
if (item.arrayAlias) {
|
|
return forEachBail(
|
|
/** @type {string[]} */ (item.alias),
|
|
resolveWithAlias,
|
|
stoppingCallback,
|
|
);
|
|
}
|
|
return resolveWithAlias(item.alias, stoppingCallback);
|
|
}
|
|
|
|
return callback();
|
|
},
|
|
callback,
|
|
);
|
|
}
|
|
|
|
module.exports.aliasResolveHandler = aliasResolveHandler;
|
|
module.exports.compileAliasOptions = compileAliasOptions;
|