unrun 0.2.5 → 0.2.7

package/dist/index.d.mts

@@ -33,11 +33,17 @@ interface Options {
 }
 //#endregion
 //#region src/types.d.ts
-interface Result {
+interface Result<T = unknown> {
   /**
   * The module that was loaded.
+  * You can specify the type of the module by providing a type argument when using the `unrun` function.
   */
-  module: any;
+  module: T;
+  /**
+  * The dependencies involved when loading the targeted module.
+  * Note: this only includes local file dependencies, npm-resolved dependencies are excluded.
+  */
+  dependencies: string[];
 }
 interface CliResult {
   /**
@@ -53,7 +59,7 @@ interface CliResult {
 * @param options - The options for loading the module.
 * @returns A promise that resolves to the loaded module.
 */
-declare function unrun(options: Options): Promise<Result>;
+declare function unrun<T>(options: Options): Promise<Result<T>>;
 /**
 * Loads a module with JIT transpilation based on the provided options.
 * This function runs synchronously using a worker thread.
@@ -61,7 +67,7 @@ declare function unrun(options: Options): Promise<Result>;
 * @param options - The options for loading the module.
 * @returns The loaded module.
 */
-declare function unrunSync(options: Options): Result;
+declare function unrunSync<T>(options: Options): Result<T>;
 /**
 * Runs a given module with JIT transpilation based on the provided options.
 * This function does not return the module, as it simply executes it.

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { n as unrunCli, r as unrunSync, t as unrun } from "./src-Cy5isIwp.mjs";
+import { n as unrunCli, r as unrunSync, t as unrun } from "./src-BoMbIRQr.mjs";
 
 export { unrun, unrunCli, unrunSync };

package/dist/{src-Cy5isIwp.mjs → src-BoMbIRQr.mjs}

@@ -1,4 +1,4 @@
-import { createRequire } from "node:module";
+import { builtinModules, createRequire } from "node:module";
 import process from "node:process";
 import path from "node:path";
 import fs, { existsSync } from "node:fs";
@@ -74,6 +74,56 @@ function resolveOptions(options = {}) {
 	return resolvedOptions;
 }
 
+//#endregion
+//#region src/utils/module-resolution.ts
+/**
+* Precomputed set of Node.js builtin module specifiers, including both plain and `node:` prefixed forms.
+*/
+const BUILTIN_MODULE_SPECIFIERS = new Set([...builtinModules, ...builtinModules.map((name) => `node:${name}`)]);
+/**
+* Returns true when `id` refers to a Node.js builtin module, accepting both plain and `node:` specifiers.
+*/
+function isBuiltinModuleSpecifier(id) {
+	if (!id) return false;
+	return BUILTIN_MODULE_SPECIFIERS.has(id) || id.startsWith("node:");
+}
+/**
+* Removes Rollup-style query/hash suffixes from importer paths, falling back when importer is virtual or missing.
+*/
+function normalizeImporterPath(importer, fallback) {
+	if (!importer || importer.startsWith("\0")) return fallback;
+	const [withoutQuery] = importer.split("?");
+	return withoutQuery || fallback;
+}
+/**
+* Checks if `child` is inside `parent` directory.
+*/
+function isPathWithinDirectory(parent, child) {
+	const relative = path.relative(parent, child);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+
+//#endregion
+//#region src/features/external.ts
+/**
+* Builds the rolldown external resolver used to decide which imports remain external.
+* Treat bare imports from the primary node_modules as external, but inline
+* nested node_modules so they keep working once executed from .unrun.
+*/
+function createExternalResolver(options) {
+	const projectNodeModules = path.resolve(process.cwd(), "node_modules");
+	return function external(id, importer) {
+		if (!id || id.startsWith("\0")) return false;
+		if (id.startsWith(".") || id.startsWith("#") || path.isAbsolute(id)) return false;
+		if (isBuiltinModuleSpecifier(id)) return true;
+		const importerPath = normalizeImporterPath(importer, options.path);
+		try {
+			if (!isPathWithinDirectory(projectNodeModules, createRequire(importerPath).resolve(id))) return false;
+		} catch {}
+		return true;
+	};
+}
+
 //#endregion
 //#region src/plugins/console-output-customizer.ts
 /**
@@ -372,7 +422,7 @@ async function bundle(options) {
 	const inputOptions = {
 		input: options.path,
 		platform: "node",
-		external: (id) => !id.startsWith(".") && !path.isAbsolute(id) && !id.startsWith("#"),
+		external: createExternalResolver(options),
 		plugins: [
 			createMakeCjsWrapperAsyncFriendlyPlugin(),
 			createRequireResolveFix(options),
@@ -403,7 +453,11 @@ async function bundle(options) {
 	};
 	const rolldownOutput = await bundle$1.generate(outputOptions);
 	if (!rolldownOutput.output[0]) throw new Error("[unrun] No output chunk found");
-	return rolldownOutput.output[0];
+	const files = await bundle$1.watchFiles;
+	return {
+		chunk: rolldownOutput.output[0],
+		dependencies: files
+	};
 }
 
 //#endregion
@@ -539,14 +593,17 @@ async function loadModule(code, options) {
 */
 async function unrun(options) {
 	const resolvedOptions = resolveOptions(options);
-	const outputChunk = await bundle(resolvedOptions);
+	const output = await bundle(resolvedOptions);
 	let module;
 	try {
-		module = await loadModule(outputChunk.code, resolvedOptions);
+		module = await loadModule(output.chunk.code, resolvedOptions);
 	} catch (error) {
-		throw new Error(`[unrun] Import failed (code length: ${outputChunk.code.length}): ${error.message}`);
+		throw new Error(`[unrun] Import failed (code length: ${output.chunk.code.length}): ${error.message}`);
 	}
-	return { module: preset(resolvedOptions, module) };
+	return {
+		module: preset(resolvedOptions, module),
+		dependencies: output.dependencies
+	};
 }
 /**
 * Loads a module with JIT transpilation based on the provided options.
@@ -569,13 +626,13 @@ function unrunSync(options) {
 */
 async function unrunCli(options, args = []) {
 	const resolvedOptions = resolveOptions(options);
-	const outputChunk = await bundle(resolvedOptions);
-	const moduleUrl = writeModule(outputChunk.code, resolvedOptions);
+	const output = await bundle(resolvedOptions);
+	const moduleUrl = writeModule(output.chunk.code, resolvedOptions);
 	let cliResult;
 	try {
 		cliResult = await execModule(moduleUrl, args);
 	} catch (error) {
-		throw new Error(`[unrun] Run failed (code length: ${outputChunk.code.length}): ${error.message}`);
+		throw new Error(`[unrun] Run failed (code length: ${output.chunk.code.length}): ${error.message}`);
 	}
 	cleanModule(moduleUrl, resolvedOptions);
 	return cliResult;

package/dist/sync/worker.mjs

@@ -1,4 +1,4 @@
-import { t as unrun } from "../src-Cy5isIwp.mjs";
+import { t as unrun } from "../src-BoMbIRQr.mjs";
 import { runAsWorker } from "synckit";
 
 //#region src/sync/worker.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unrun",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "A tool to load and execute any JavaScript or TypeScript code at runtime.",
   "type": "module",
   "license": "MIT",