File size: 4,576 Bytes
f119c28 | 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 | /*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
"use strict";
const forEachBail = require("./forEachBail");
const { getPathsCached } = require("./getPaths");
/** @typedef {import("./Resolver")} Resolver */
/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
/** @typedef {(err?: null | Error, result?: null | ResolveRequest) => void} InnerCallback */
/**
* Per-(directories-array) cache of the flat `addrs` list produced for a given
* `request.path`. For a fixed directories configuration the fan-out of
* `ancestor × directory` is deterministic per request.path, and many resolves
* share the same starting directory (sibling files in one project, loops over
* a batch of imports, etc.) — caching avoids the `getPaths` regex split plus
* `len(paths) × len(directories)` join calls per resolve.
*
* The outer map is keyed on the directories array reference (plugin-owned,
* stable for the lifetime of the resolver), and the inner map on the
* starting `request.path`. Kept private to this module (rather than hung off
* `resolver.pathCache`) so the pathCache's hidden-class shape is unchanged —
* that avoids perturbing the interpreter-mode IC state for the
* `resolver.pathCache.{join,dirname,basename}.fn(...)` accesses that run on
* every resolve, which the CodSpeed instruction-count harness is sensitive to.
* @type {WeakMap<string[], Map<string, string[]>>}
*/
const _addrsCacheByDirs = new WeakMap();
/**
* @param {Resolver} resolver resolver
* @param {string[]} directories directories
* @param {ResolveStepHook} target target
* @param {ResolveRequest} request request
* @param {ResolveContext} resolveContext resolve context
* @param {InnerCallback} callback callback
* @returns {void}
*/
function modulesResolveHandler(
resolver,
directories,
target,
request,
resolveContext,
callback,
) {
const fs = resolver.fileSystem;
const requestPath = /** @type {string} */ (request.path);
// Compute-or-reuse the flat `addrs` list. Inlined (rather than a helper
// function) so the cache-hit path — which is the vast majority of
// invocations — stays a single WeakMap + Map lookup with no function-call
// overhead. See `_addrsCacheByDirs` above for caching rationale.
let addrs;
let perPath = _addrsCacheByDirs.get(directories);
if (perPath === undefined) {
perPath = new Map();
_addrsCacheByDirs.set(directories, perPath);
} else {
addrs = perPath.get(requestPath);
}
if (addrs === undefined) {
const { paths } = getPathsCached(fs, requestPath);
const pathsLen = paths.length;
const dirsLen = directories.length;
// Pre-size the flat array rather than going through `map().reduce()`
// with intermediate arrays + spreads.
// eslint-disable-next-line unicorn/no-new-array
addrs = new Array(pathsLen * dirsLen);
let idx = 0;
const joinFn = resolver.pathCache.join.fn;
for (let pi = 0; pi < pathsLen; pi++) {
const pathItem = paths[pi];
for (let di = 0; di < dirsLen; di++) {
addrs[idx++] = joinFn(pathItem, directories[di]);
}
}
perPath.set(requestPath, addrs);
}
// Hoist the dot-prefixed request out of the per-addr iterator. `addrs`
// can have up to `paths.length × directories.length` entries (e.g. 36
// for an 8-deep source dir × 4-module config), and concatenating the
// same `./${request.request}` string on every iteration is wasted
// work — it's constant for the whole fan-out.
const relRequest = `./${request.request}`;
forEachBail(
addrs,
/**
* @param {string} addr addr
* @param {(err?: null | Error, result?: null | ResolveRequest) => void} callback callback
* @returns {void}
*/
(addr, callback) => {
fs.stat(addr, (err, stat) => {
if (!err && stat && stat.isDirectory()) {
/** @type {ResolveRequest} */
const obj = {
...request,
path: addr,
request: relRequest,
module: false,
};
const message = `looking for modules in ${addr}`;
return resolver.doResolve(
target,
obj,
message,
resolveContext,
callback,
);
}
if (resolveContext.log) {
resolveContext.log(`${addr} doesn't exist or is not a directory`);
}
if (resolveContext.missingDependencies) {
resolveContext.missingDependencies.add(addr);
}
return callback();
});
},
callback,
);
}
module.exports = {
modulesResolveHandler,
};
|