import { exports, imports } from "resolve.exports"; import { external as defaultExternal, findPackage, fs as defaultFS, } from "#defaults"; export interface ResolveOptions { /** * The absolute path to the file from which to resolve the module. */ from: string; /** * The root directory for resolution. Defaults to "/". */ root?: string; /** * File extensions to consider. Defaults to [".js", ".json"]. */ exts?: string[]; /** * Package.json fields to check for entry points. Defaults to ["module", "main"] or ["browser", "module", "main"] if browser option is true. */ fields?: string[]; /** * If true, suppresses errors and returns undefined when a module cannot be resolved. Defaults to false. */ silent?: boolean; /** * If true, resolves using CommonJS (require) semantics. */ require?: boolean; /** * If true, resolves using browser field mappings. */ browser?: boolean; /** * Additional conditions for conditional exports/imports. */ conditions?: string[]; /** * Function to determine if a module id should be treated as external. */ external?: (id: string) => boolean; /** * If true, preserves symbolic links instead of resolving to real paths. */ preserveSymlinks?: boolean; /** * Custom file system interface. */ fs?: { isFile(file: string): boolean; readPkg(file: string): unknown; realpath?(file: string): string; }; } interface ResolveContext { root: string; from: string; fromDir: string; exts: string[]; fields: string[]; silent: boolean; external: (id: string) => boolean; isFile(file: string): boolean; readPkg(file: string): unknown; realpath(file: string): string; resolve: { browser: boolean; require: boolean; conditions: string[] | undefined; }; } const defaultExts = [".js", ".json"]; const defaultFields = ["module", "main"]; const defaultBrowserFields = ["browser", "module", "main"]; const identity = (file: string) => file; export function resolveSync( id: string, opts: ResolveOptions, ): string | false | undefined { const ctx = toContext(opts); const resolved = resolveId(ctx, id); if (resolved === undefined) { if (ctx.silent) return; throw new Error(`Cannot find module '${id}' from '${ctx.from}'`); } return resolved; } function toContext(opts: ResolveOptions): ResolveContext { const fs = opts.fs || defaultFS; const realpath = (!opts.preserveSymlinks && fs.realpath) || identity; const root = toPosix(opts.root || "/"); const from = toPosix(opts.from); const fromDir = dirname(from); const browser = !!opts.browser; const require = !!opts.require; return { root, from, fromDir, silent: !!opts.silent, exts: opts.exts || defaultExts, fields: opts.fields || (browser ? defaultBrowserFields : defaultFields), realpath, external: opts.external || defaultExternal, readPkg: fs.readPkg, isFile: fs.isFile, resolve: { browser, require, conditions: opts.conditions, }, }; } // A resolved file is canonicalized; an external id is returned as given. function resolveId(ctx: ResolveContext, id: string) { switch (id[0]) { case ".": return toRealpath(ctx, resolveRelative(ctx, ctx.fromDir, id)); case "#": return toRealpath(ctx, resolveSubImport(ctx, ctx.fromDir, id)); default: return ctx.external(id) ? id : toRealpath(ctx, resolvePkg(ctx, id)); } } function toRealpath(ctx: ResolveContext, file: string | false | undefined) { return file ? ctx.realpath(file) : file; } function resolveRelative(ctx: ResolveContext, dir: string, id: string) { const file = join(dir, id); return id === "." || id === ".." || id[id.length - 1] === "/" ? resolveDir(ctx, file) : resolveFile(ctx, file) || resolveDir(ctx, file); } function resolveSubImport(ctx: ResolveContext, fromDir: string, id: string) { let dir = fromDir; do { const pkgFile = dir + "/package.json"; if (ctx.isFile(pkgFile)) { return resolveFirst(ctx, dir, matchImports(ctx, pkgFile, id)); } const parent = dirname(dir); // A directory that is its own parent is the file system root (e.g. // "D:/" on Windows, which never equals the default "/" root). if (parent === dir) return; dir = parent; } while (dir !== ctx.root); } function resolveFirst( ctx: ResolveContext, dir: string, matches: void | string[], ) { if (matches) { for (const match of matches) { const file = join(dir, match); if (ctx.isFile(file)) { return file; } } } } function resolveFile(ctx: ResolveContext, file: string): string | undefined { if (ctx.isFile(file)) { return file; } for (const ext of ctx.exts) { const fileWithExt = file + ext; if (ctx.isFile(fileWithExt)) { return fileWithExt; } } } function resolveDir(ctx: ResolveContext, file: string): string | undefined { return resolvePkgPart(ctx, file, "") || resolveFile(ctx, file + "/index"); } function resolvePkg(ctx: ResolveContext, id: string) { let dir = ctx.fromDir; let slash = id.indexOf("/"); let name = id; let part = ""; if (slash !== -1) { if (id[0] !== "@") { name = id.slice(0, slash); part = id.slice(slash); } else { slash = id.indexOf("/", slash + 1); if (slash !== -1) { name = id.slice(0, slash); part = id.slice(slash); } } } // Found where the package manager put it (eg Yarn PnP), or else in the // nearest `node_modules` holding it. if (findPackage) { const pkgDir = findPackage(name, ctx.from); if (pkgDir) { const resolved = resolvePkgPart(ctx, trimSlash(toPosix(pkgDir)), part); if (resolved !== undefined) return resolved; } } do { // As in Node, a `node_modules` folder's own `node_modules` is never tried. if (!dir.endsWith("/node_modules")) { const resolved = resolvePkgPart(ctx, dir + "/node_modules/" + name, part); if (resolved !== undefined) return resolved; } const parent = dirname(dir); // A directory that is its own parent is the file system root (e.g. // "D:/" on Windows, which never equals the default "/" root). if (parent === dir) break; dir = parent; } while (dir !== ctx.root); return resolveSelf(ctx, name, part); } // A package importing itself by name, through its own `exports`. Node tries // this before `node_modules`; trying it after keeps found packages as fast. function resolveSelf(ctx: ResolveContext, name: string, part: string) { let dir = ctx.fromDir; do { const pkgFile = dir + "/package.json"; if (ctx.isFile(pkgFile)) { const pkg = ctx.readPkg(pkgFile) as { name?: unknown; exports?: unknown; } | null; if (pkg && pkg.name === name && pkg.exports != null) { return resolveFirst(ctx, dir, matchExports(ctx, pkg, part)); } return; } const parent = dirname(dir); if (parent === dir) return; dir = parent; } while (dir !== ctx.root); } function resolvePkgPart(ctx: ResolveContext, pkgDir: string, part: string) { const pkgFile = pkgDir + "/package.json"; if (ctx.isFile(pkgFile)) { const pkg = ctx.readPkg(pkgFile); if (!pkg || typeof pkg !== "object") { if (ctx.silent) return; throw new Error(`Invalid package '${pkgFile}' loaded by '${ctx.from}'.`); } const resolved = "exports" in pkg ? resolveFirst(ctx, pkgDir, matchExports(ctx, pkg, part)) : resolvePkgField(ctx, pkg, pkgDir, part); if (resolved === undefined) { if (ctx.silent) return; throw new Error( `Could not resolve entry for package '${pkgFile}' loaded by '${ctx.from}'.`, ); } return resolved; } } function matchExports(ctx: ResolveContext, pkg: object, part: string) { try { return exports(pkg, "." + part, ctx.resolve); } catch (err) { // resolve.exports throws when the exports map cannot satisfy the // requested subpath or conditions. if (!ctx.silent) throw err; } } function matchImports(ctx: ResolveContext, pkgFile: string, id: string) { try { return imports(ctx.readPkg(pkgFile) as object, id, ctx.resolve); } catch (err) { // resolve.exports throws when the imports map cannot satisfy the // requested specifier or conditions. if (!ctx.silent) throw err; } } function resolvePkgField( ctx: ResolveContext, pkg: object, pkgDir: string, part: string, ) { const remapPart = getBrowserRemap(ctx, pkg, part); if (remapPart === false) { return false; } if (remapPart) { return resolveRelative(ctx, pkgDir, remapPart); } if (part && part !== "/") { return resolveRelative(ctx, pkgDir, "." + part); } for (const field of ctx.fields) { const value = (pkg as Record)[field]; if (typeof value === "string") { return resolveRelative(ctx, pkgDir, value); } } return resolveFile(ctx, pkgDir + "/index"); } function getBrowserRemap( ctx: ResolveContext, pkg: object, part: string, ): string | false | undefined { const remaps = ctx.resolve.browser && "browser" in pkg && typeof pkg.browser === "object" && (pkg.browser as Record); if (remaps) { let entry = "." + part; let remap = remaps[entry]; if (remap !== undefined) { return remap; } if (entry === ".") { // Check `.` and `./` entry = "./"; remap = remaps[entry]; if (remap !== undefined) { return remap; } } for (const ext of ctx.exts) { remap = remaps[entry + ext]; if (remap !== undefined) { return remap; } } // try adding `/index` to the end. entry += "/index"; remap = remaps[entry]; if (remap !== undefined) { return remap; } for (const ext of ctx.exts) { remap = remaps[entry + ext]; if (remap !== undefined) { return remap; } } } } function dirname(dir: string) { const i = dir.lastIndexOf("/"); if (i === 2 && dir[1] === ":") { // if windows path like C:\ return including the drive letter and colon. return dir.slice(0, 3); } return dir.slice(0, i) || "/"; } function join(base: string, part: string): string { if (part === "." || part === "./") { return base; } const len = part.length; let up = 0; let i = 0; while (i < len && part[i] === ".") { if ( i + 1 < len && part[i + 1] === "." && (i + 2 === len || part[i + 2] === "/") ) { up++; i += 3; } else if (i + 1 === len || part[i + 1] === "/") { i += 2; } else { break; } } let pre = base; if (up) { let end = base.length; while (up--) { end = base.lastIndexOf("/", end - 1); if (end < 0) return "/"; } pre = base.slice(0, end) || "/"; } if (i >= len) { return pre; } if (pre[pre.length - 1] !== "/") { pre += "/"; } return pre + (i ? part.slice(i) : part); } function trimSlash(dir: string) { return dir.length > 1 && dir[dir.length - 1] === "/" ? dir.slice(0, -1) : dir; } function toPosix(file: string) { return file[0] === "/" ? file : file.replace(/\\/g, "/"); }