Launch an HTTP server when testing starts

Author: paul-go

core/HttpServer.ts

@@ -0,0 +1,144 @@
+
+namespace Moduless
+{
+	const Http = require("http") as typeof import("http");
+	const Path = require("path") as typeof import("path");
+	const Fs = require("fs") as typeof import("fs");
+	
+	/**
+	 * Launches a static HTTP file server at the specified path, from the specified port number.
+	 */
+	export function createServer(options: {
+		path: string,
+		port?: number,
+		route?: (path: string) => string | Buffer | void
+	})
+	{
+		const server = Http.createServer((req, res) =>
+		{
+			const path = req.url || "";
+			const joined = Path.join(options.path, path);
+			if (!Fs.existsSync(joined))
+			{
+				res.writeHead(404);
+				res.end();
+				return;
+			}
+			
+			let size = 0;
+			let body: string | Buffer = "";
+			
+			const maybeOverride = options.route?.(path);
+			if (maybeOverride !== undefined)
+			{
+				size = maybeOverride.length;
+				body = maybeOverride;
+			}
+			else
+			{
+				const stat = Fs.lstatSync(joined);
+				size = stat.size;
+				body = Fs.readFileSync(joined);
+			}
+			
+			const mimeType = MimeType.fromFileName(joined) || "text/html";
+			
+			res.writeHead(200, {
+				"Content-Length": size,
+				"Content-Type": mimeType
+			});
+			
+			res.end(body);
+		});
+		
+		server.listen(options.port || defaultHttpPort);
+	}
+	
+	export const defaultHttpPort = 54321;
+	
+	/** */
+	export enum MimeType
+	{
+		unknown = "",
+		
+		gif = "image/gif",
+		jpg = "image/jpeg",
+		png = "image/png",
+		svg = "image/svg+xml",
+		webp = "image/webp",
+		avif = "image/avif",
+		
+		// Videos
+		mp4 = "video/mp4",
+		webm = "video/av1",
+		
+		// Zip
+		zip = "application/zip",
+		
+		// Text
+		html = "text/html",
+		css = "text/css",
+		js = "text/javascript",
+		ts = "text/plain",
+		json = "application/json",
+		map = "application/json",
+	}
+	
+	/** */
+	export const enum MimeClass
+	{
+		other = "",
+		image = "image",
+		video = "video",
+	}
+	
+	/** */
+	export namespace MimeType
+	{
+		const mimes: Map<string, string> = new Map(Object.entries(MimeType)
+			.filter(([k, v]) => typeof v === "string") as [string, string][]);
+		
+		/** */
+		export function from(mimeString: string)
+		{
+			for (const mime of mimes.values())
+				if (mime === mimeString)
+					return mime as MimeType;
+			
+			return null;
+		}
+		
+		/** */
+		export function getExtension(mimeType: MimeType)
+		{
+			for (const [ext, mime] of mimes)
+				if (mime === mimeType)
+					return ext;
+			
+			return "";
+		}
+		
+		/** */
+		export function getClass(mimeType: string)
+		{
+			const [cls] = mimeType.split("/");
+			switch (cls)
+			{
+				case MimeClass.image: return MimeClass.image;
+				case MimeClass.video: return MimeClass.video;
+			}
+			
+			return MimeClass.other;
+		}
+		
+		/**
+		 * Parses the specified file name and returns the mime
+		 * type that is likely associated with it, based on the file extension.
+		 */
+		export function fromFileName(fileName: string)
+		{
+			const ext = fileName.split(".").slice(-1)[0] || "";
+			return (mimes.get(ext) || "") as MimeType;
+		}
+	}
+}

core/Run.ts

@@ -93,19 +93,21 @@ namespace Moduless
 				if (ex && typeof ex === "object" && !Array.isArray(ex))
 					out.push({ project, exported: ex });
 
+				const g = globalThis as any;
+				
 				// Globalize the exports of the project.
 				for (const [name, value] of Object.entries(ex))
 				{
-					if (name in globalThis)
-					{
+					if (!(name in g))
+						g[name] = value;
+					
+					else if (g[name]?.constructor === Object)
+						Object.assign(g[name], value);
+					
+					else
 						console.warn(
 							`Skipping adding ${name} from ${project.projectPath} to global scope ` +
 							`because another member with this name is already defined globally.`);
-						
-						continue;
-					}
-					
-					(globalThis as any)[name] = value;
 				}
 			}
 			catch (e)
@@ -130,6 +132,8 @@ namespace Moduless
 		if (!startingProject)
 			throw new Error("No projects found at location: " + target.projectPath);
 
+		startHttpServer(graph.map(entry => entry.project));
+		
 		const tryResolveNamepace = (root: object) =>
 		{
 			let current: any = root;
@@ -180,6 +184,44 @@ namespace Moduless
 		return true;
 	}
 
+	/**
+	 * Starts an HTTP server that serves the outFiles associated with the specified
+	 * list of projects.
+	 */
+	function startHttpServer(projects: Project[])
+	{
+		const outFiles = projects.map(p => p.outFile);
+		let charIndex = 0;
+		for (;;)
+		{
+			if (outFiles.some(f => f.length <= charIndex))
+				break;
+			
+			if (!outFiles.every(f => f[charIndex] === outFiles[0][charIndex]))
+				break;
+			
+			charIndex++;
+		}
+		
+		const path = outFiles[0].slice(0, charIndex);
+		
+		Moduless.createServer({
+			path,
+			route: path =>
+			{
+				if (path === "/")
+				{
+					return [
+						"<!DOCTYPE html>",
+						...outFiles.map(f => `<script src="${f.slice(charIndex)}"></script>`),
+					].join("\n");
+				}
+			}
+		});
+		
+		console.log("HTTP server is available at: http://localhost:" + Moduless.defaultHttpPort);
+	}
+	
 	/**
 	 * Returns the name of the cover function currently being tested.
 	 */