@n3bula/sandbox 0.0.1-alpha.2 → 0.0.1-alpha.3

package/README.md

@@ -1,6 +1,7 @@
 # `@n3bula/sandbox`
 
 ### Simple Sandbox for Node.js module quick test
+
 Just use for debug
 Debug the current process without restart process
 
@@ -18,14 +19,18 @@ pnpm add @n3bula/sandbox
 
 ```ts
 // server.ts
-import net from 'net';
-import { fileURLToPath } from 'node:url';
+import net from 'node:net';
 import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
 import { createSandbox } from '@n3bula/sandbox';
+
 const PORT = 4000;
 const server = net.createServer();
+
+export type Server = typeof server;
+
 server.listen(PORT, () => console.log(`TCP server listening on ${PORT}`));
-server.on('error', err => console.error('server error', err));
 const destroy = () => {
   server.close();
   process.exit();
@@ -33,13 +38,36 @@ const destroy = () => {
 process.on('SIGINT', destroy);
 process.on('SIGTERM', destroy);
 
-createSandbox('sandbox', resolve(fileURLToPath(dirname(import.meta.url)), './client.ts'), { server });
+const file = resolve(fileURLToPath(dirname(import.meta.url)), './client.ts');
+createSandbox(
+  file,
+  {
+    server,
+  },
+  {
+    // name: 'sandbox',
+  },
+);
 ```
 
 ```ts
 // client.ts
-console.log(1); // change to console.log(server);
+import type { Server } from './server';
+
+declare const server: Server;
+console.log(server, typeof server);
 // will print current server instance without restart server
+
+const fs = _require(
+  'node:fs/promises',
+) as typeof import('node:fs/promises');
+
+const file = await fs.readFile('./example/client.ts', 'utf8');
+console.log('file :>>', file);
+
+const { echo } = _require('@n3bula/echo') as typeof import('@n3bula/echo');
+
+echo(globalThis);
 ```
 
 ## Author

package/dist/index.d.mts

@@ -1,4 +1,10 @@
+import { TsconfigRaw } from "esbuild";
+
 //#region src/sandbox.d.ts
-declare function createSandbox(name: string, watchFilePath: string, globals?: {}): void;
+type SandboxOptions = {
+  name?: string;
+  tsconfig?: string | TsconfigRaw;
+};
+declare function createSandbox(watchFilePath: string, globals?: {}, options?: SandboxOptions): void;
 //#endregion
 export { createSandbox };

package/dist/index.mjs

@@ -1,6 +1,10 @@
+import { createRequire } from "node:module";
+import { randomUUID } from "node:crypto";
 import vm from "node:vm";
 import EventEmitter from "node:events";
-import { readFile, stat, watch } from "node:fs";
+import { existsSync, readFileSync, stat, watch } from "node:fs";
+import { join } from "node:path";
+import { buildSync, transformSync } from "esbuild";
 import { echo } from "@n3bula/echo/node";
 //#region src/logger.ts
 const createLogger = (tag) => {
@@ -24,19 +28,47 @@ const logger = createLogger("@n3bula/sandbox");
 const DEBOUNCE_MS = 200;
 const READ_RETRY_MS = 100;
 const MAX_READ_RETRIES = 5;
+const DEFAULT_TSCONFIG = { compilerOptions: {
+	strict: false,
+	target: "ES2022"
+} };
+function findTsconfigFromProcessRoot() {
+	const tsconfigPath = join(process.cwd(), "tsconfig.json");
+	if (existsSync(tsconfigPath)) try {
+		return JSON.parse(readFileSync(tsconfigPath, "utf8"));
+	} catch {
+		return;
+	}
+}
 var FileWatcher = class extends EventEmitter {
 	timer = null;
 	lastStat = null;
 	readRetries = 0;
 	watcher;
-	constructor(filePath) {
+	tsOptions;
+	constructor(filePath, tsconfig) {
 		super();
 		this.filePath = filePath;
+		this.tsconfig = tsconfig;
+		this.normalizeTsOptions();
 		this.scheduleRead = this.scheduleRead.bind(this);
 		this.startWatch();
 	}
+	normalizeTsOptions() {
+		const tsconfig = findTsconfigFromProcessRoot();
+		if (tsconfig) {
+			this.tsOptions = { tsconfigRaw: tsconfig };
+			return;
+		}
+		if (typeof this.tsconfig === "string") try {
+			this.tsOptions = { tsconfigRaw: JSON.parse(this.tsconfig) };
+		} catch {
+			this.tsOptions = { tsconfig: this.tsconfig };
+		}
+		else this.tsOptions = { tsconfigRaw: DEFAULT_TSCONFIG };
+	}
 	safeReadAndNotify() {
-		readFile(this.filePath, "utf8", (err, data) => {
+		stat(this.filePath, (err, fileStat) => {
 			if (err) {
 				if (err.code === "ENOENT" && this.readRetries < MAX_READ_RETRIES) {
 					this.readRetries++;
@@ -47,13 +79,21 @@ var FileWatcher = class extends EventEmitter {
 				return;
 			}
 			this.readRetries = 0;
-			stat(this.filePath, (err2, fileStat) => {
-				if (!err2) {
-					if (this.lastStat && fileStat.mtimeMs === this.lastStat.mtimeMs && fileStat.size === this.lastStat.size) return;
-					this.lastStat = fileStat;
-				}
-				this.emit("change", data.split(/\r?\n/).filter((l) => !/^\s*\/\//.test(l)).map((l) => l.trim()).join(" "));
-			});
+			if (this.lastStat && fileStat.mtimeMs === this.lastStat.mtimeMs && fileStat.size === this.lastStat.size) return;
+			this.lastStat = fileStat;
+			const data = buildSync({
+				charset: "utf8",
+				entryPoints: [this.filePath],
+				format: "esm",
+				legalComments: "none",
+				minify: true,
+				minifyIdentifiers: false,
+				minifySyntax: false,
+				platform: "node",
+				write: false,
+				...this.tsOptions
+			}).outputFiles[0].contents;
+			this.emit("change", transformSync(data, {}).code);
 		});
 	}
 	scheduleRead() {
@@ -91,29 +131,53 @@ var FileWatcher = class extends EventEmitter {
 	}
 };
 //#endregion
+//#region src/require.ts
+const requireCache = /* @__PURE__ */ new Map();
+const _require = new Proxy(createRequire(import.meta.url), { apply(target, thisArg, argArray) {
+	const [id] = argArray;
+	const module = Reflect.apply(target, thisArg, argArray);
+	requireCache.set(_require.resolve(id), module);
+	return module;
+} });
+function sandboxRequireCleanup() {
+	requireCache.forEach((_, id) => {
+		if (!_require.cache[id]) return;
+		Reflect.deleteProperty(_require.cache, id);
+	});
+	requireCache.clear();
+}
+//#endregion
 //#region src/sandbox.ts
 function createContext(sandboxGlobals = {}) {
 	return vm.createContext({
-		console,
-		setTimeout,
-		setInterval,
-		clearTimeout,
+		_require,
 		clearInterval,
+		clearTimeout,
+		console,
 		fetch: typeof fetch !== "undefined" ? fetch : void 0,
+		setInterval,
+		setTimeout,
 		...sandboxGlobals
 	});
 }
-function createSandbox(name, watchFilePath, globals = {}) {
+function createSandbox(watchFilePath, globals = {}, options = {}) {
 	const sandboxContext = createContext({
 		...globals,
-		__sandbox_name: name
+		__sandbox_name: options.name || randomUUID()
 	});
 	function runCode(code) {
-		return new vm.Script(`(async () => { ${code} })()`).runInContext(sandboxContext, { timeout: 2e3 }).then((res) => res).catch((err) => {
+		return new Promise((resolve, reject) => {
+			try {
+				resolve(new vm.Script(`(async () => { ${code} })()`).runInContext(sandboxContext, { timeout: 2e3 }));
+				sandboxRequireCleanup();
+			} catch (error) {
+				reject(error);
+			}
+		}).then((res) => res).catch((err) => {
 			logger.error(err);
 		});
 	}
-	const watcher = new FileWatcher(watchFilePath);
+	const watcher = new FileWatcher(watchFilePath, options.tsconfig);
 	watcher.on("change", (code) => {
 		runCode(code);
 	});

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+declare const __sandbox_name: string;
+declare const _require: NodeJS.Require;

package/package.json

@@ -1,14 +1,25 @@
 {
   "name": "@n3bula/sandbox",
-  "version": "0.0.1-alpha.2",
+  "version": "0.0.1-alpha.3",
   "description": "Simple Sandbox for Node.js module quick test",
   "type": "module",
-  "main": "dist/index.mjs",
-  "typings": "dist/index.d.mts",
   "keywords": [
     "sandbox",
     "node"
   ],
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./types": {
+      "types": "./dist/types.d.ts"
+    }
+  },
   "files": [
     "dist"
   ],
@@ -38,10 +49,12 @@
     "tsdown": "^0.21.5"
   },
   "dependencies": {
+    "esbuild": "^0.25.12",
     "@n3bula/echo": "^0.1.0-alpha.4"
   },
+  "sideEffects": false,
   "scripts": {
-    "dev": "tsx --experimental-vm-modules example/server.ts",
+    "dev": "pnpm -C=example dev",
     "build": "tsdown"
   }
 }