Merge branch 'develop' of github.com:privatenumber/fs-require

src/fs-require.ts

@@ -2,19 +2,14 @@ import vm from 'vm';
 import path from 'path';
 import Module from 'module';
 import {
+	Options,
 	FileSystemLike,
 	fsRequire,
 	Loaders,
-	implicitExtensions,
-	loaderTypes,
 	ModuleCache,
 } from './types';
-import {
-	isFilePathPattern,
-	hasValidExtensionPattern,
-	getBareSpecifier,
-	isDirectory,
-} from './utils';
+import { isBareSpecifier, resolveBareSpecifier } from './utils/resolve-bare-specifier';
+import { resolveModule } from './utils/resolve-module';
 
 export type { FileSystemLike as FileSystem };
 
@@ -53,53 +48,8 @@ loaders['.json'] = function (newModule, sourceCode) {
 	newModule.exports = JSON.parse(sourceCode);
 };
 
-type Resolved = {
-	extension: (typeof loaderTypes)[number];
-	filePath: string;
-}
-
-function resolve(
-	fs: FileSystemLike,
-	filePath: string,
-): Resolved | null {
-	// Exact match
-	if (fs.existsSync(filePath)) {
-		if (isDirectory(fs, filePath)) {
-			return (
-				resolve(fs, path.join(filePath, 'index.js'))
-				|| resolve(fs, path.join(filePath, 'index.json'))
-			);
-		}
-
-		const extension = (filePath.match(hasValidExtensionPattern)?.[0] ?? '') as Resolved['extension'];
-		return {
-			extension,
-			filePath,
-		};
-	}
-
-	// Try extensions
-	for (const extension of implicitExtensions) {
-		const filePathWithExtension = filePath + extension;
-		if (fs.existsSync(filePathWithExtension)) {
-			return {
-				extension,
-				filePath: filePathWithExtension,
-			};
-		}
-	}
-
-	return null;
-}
-
-const realRequire = require;
-
 let idCounter = 0;
 
-type Options = {
-	fs?: boolean | FileSystemLike;
-};
-
 export const createFsRequire = (
 	mfs: FileSystemLike,
 	options?: Options,
@@ -109,41 +59,21 @@ export const createFsRequire = (
 	const moduleCache: ModuleCache = Object.create(null);
 
 	function makeRequireFunction(parentModule: Module): fsRequire {
-		const require = (modulePath: string) => {
-			if (!isFilePathPattern.test(modulePath)) {
-				const [moduleName, moduleSubpath] = getBareSpecifier(modulePath) ?? [];
-
-				if (moduleName === 'fs') {
-					const { fs } = options ?? {};
-
-					// If true, use native fs (can still be truthy)
-					if (fs !== true) {
-						const shimFs = fs || mfs;
-
-						if (!moduleSubpath) {
-							return shimFs;
-						}
-
-						if (moduleSubpath === '/promises' && ('promises' in shimFs)) {
-							return shimFs.promises;
-						}
-
-						throw new Error(`Cannot find module '${modulePath}'`);
-					}
-				}
-
-				return realRequire(modulePath);
+		const resolve = (modulePath: string) => {
+			if (isBareSpecifier(modulePath)) {
+				return modulePath;
 			}
+			const resolved = resolveModule(mfs, parentModule, modulePath);
+			return resolved.filePath;
+		};
 
-			let filePath = path.resolve(path.dirname(parentModule.filename), modulePath);
-
-			const resolvedPath = resolve(mfs, filePath);
-
-			if (!resolvedPath) {
-				throw new Error(`Cannot find module '${modulePath}'`);
+		const require: fsRequire = (modulePath: string) => {
+			if (isBareSpecifier(modulePath)) {
+				return resolveBareSpecifier(mfs, modulePath, options);
 			}
 
-			filePath = resolvedPath.filePath;
+			const resolvedPath = resolveModule(mfs, parentModule, modulePath);
+			const { filePath } = resolvedPath;
 
 			let importedModule = moduleCache[filePath];
 
@@ -167,6 +97,7 @@ export const createFsRequire = (
 		};
 
 		require.id = fsRequireId;
+		require.resolve = resolve;
 		require.cache = moduleCache;
 
 		return require;

src/types.ts

@@ -1,5 +1,9 @@
 import Module from 'module';
 
+export type Options = {
+	fs?: boolean | FileSystemLike;
+};
+
 // These are the only methods fs-require needs to use
 export interface FileSystemLike {
 	readFileSync: (
@@ -16,6 +20,7 @@ export interface FileSystemLike {
 export type ModuleCache = Record<string, Module>;
 export type fsRequire = {
 	(modulePath: string): any;
+	resolve: (modulePath: string) => string;
 	id: number;
 	cache: ModuleCache;
 };

src/utils/index.ts

@@ -0,0 +1,14 @@
+import { FileSystemLike, implicitExtensions } from '../types';
+
+export const hasValidExtensionPattern = new RegExp(
+	`(${
+		implicitExtensions
+			.map(extension => extension.replace(/\./g, '\\$&'))
+			.join('|')
+	})$`,
+);
+
+export const isDirectory = (
+	fs: FileSystemLike,
+	directoryPath: string,
+) => fs.lstatSync(directoryPath).isDirectory();

src/utils/resolve-bare-specifier.ts

@@ -0,0 +1,40 @@
+import { Options, FileSystemLike } from '../types';
+
+const isFilePathPattern = /^[./]/;
+export const isBareSpecifier = (modulePath: string) => !isFilePathPattern.test(modulePath);
+
+const specifierPattern = /^(?:node:)?((?:@[\da-z][\w.-]+\/)?[\da-z][\w.-]+)(\/.+)?$/;
+const parseBareSpecifier = (
+	modulePath: string,
+) => modulePath.match(specifierPattern)?.slice(1, 3);
+
+const realRequire = require;
+
+export function resolveBareSpecifier(
+	mfs: FileSystemLike,
+	modulePath: string,
+	options?: Options,
+) {
+	const [moduleName, moduleSubpath] = parseBareSpecifier(modulePath) ?? [];
+
+	if (moduleName === 'fs') {
+		const { fs } = options ?? {};
+
+		// If true, use native fs (can still be truthy)
+		if (fs !== true) {
+			const shimFs = fs || mfs;
+
+			if (!moduleSubpath) {
+				return shimFs;
+			}
+
+			if (moduleSubpath === '/promises' && ('promises' in shimFs)) {
+				return shimFs.promises;
+			}
+
+			throw new Error(`Cannot find module '${modulePath}'`);
+		}
+	}
+
+	return realRequire(modulePath);
+}

src/utils/resolve-module.ts

@@ -0,0 +1,68 @@
+import path from 'path';
+import Module from 'module';
+import {
+	FileSystemLike,
+	implicitExtensions,
+	loaderTypes,
+} from '../types';
+import {
+	hasValidExtensionPattern,
+	isDirectory,
+} from '.';
+
+type Resolved = {
+	extension: (typeof loaderTypes)[number];
+	filePath: string;
+}
+
+function resolveModuleSafe(
+	mfs: FileSystemLike,
+	parentModule: Module,
+	modulePath: string,
+): Resolved | null {
+	// Absolute path
+	modulePath = path.resolve(path.dirname(parentModule.filename), modulePath);
+
+	// Exact match
+	if (mfs.existsSync(modulePath)) {
+		if (isDirectory(mfs, modulePath)) {
+			return (
+				resolveModuleSafe(mfs, parentModule, path.join(modulePath, 'index.js'))
+				|| resolveModuleSafe(mfs, parentModule, path.join(modulePath, 'index.json'))
+			);
+		}
+
+		const extension = (modulePath.match(hasValidExtensionPattern)?.[0] ?? '') as Resolved['extension'];
+		return {
+			extension,
+			filePath: modulePath,
+		};
+	}
+
+	// Try extensions
+	for (const extension of implicitExtensions) {
+		const filePathWithExtension = modulePath + extension;
+		if (mfs.existsSync(filePathWithExtension)) {
+			return {
+				extension,
+				filePath: filePathWithExtension,
+			};
+		}
+	}
+
+	return null;
+}
+
+export function resolveModule(
+	mfs: FileSystemLike,
+	parentModule: Module,
+	modulePath: string,
+) {
+	const resolved = resolveModuleSafe(mfs, parentModule, modulePath);
+
+	if (!resolved) {
+		throw new Error(`Cannot find module '${modulePath}'`);
+	}
+
+	return resolved;
+}