feat: init

node_modules/srvx/dist/loader.mjs

@@ -0,0 +1,116 @@
+import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import * as nodeHTTP$1 from "node:http";
+const defaultExts = [
+	".mjs",
+	".js",
+	".mts",
+	".ts"
+];
+const defaultEntries = [
+	"server",
+	"server/index",
+	"src/server",
+	"server/server"
+];
+async function loadServerEntry(opts) {
+	let entry = opts.entry;
+	if (entry) {
+		entry = resolve(opts.dir || ".", entry);
+		if (!existsSync(entry)) return { notFound: true };
+	} else {
+		for (const defEntry of defaultEntries) {
+			for (const defExt of defaultExts) {
+				const entryPath = resolve(opts.dir || ".", `${defEntry}${defExt}`);
+				if (existsSync(entryPath)) {
+					entry = entryPath;
+					break;
+				}
+			}
+			if (entry) break;
+		}
+		if (!entry) return { notFound: true };
+	}
+	const url = entry.startsWith("file://") ? entry : pathToFileURL(resolve(entry)).href;
+	let mod;
+	let interceptedNodeHandler;
+	let interceptedFetchHandler;
+	try {
+		if (opts.interceptHttpListen !== false) {
+			const loaded = await interceptListen(() => import(url));
+			mod = loaded.res;
+			interceptedNodeHandler = loaded.listenHandler;
+			interceptedFetchHandler = loaded.fetchHandler;
+		} else mod = await import(url);
+	} catch (error) {
+		if (error?.code === "ERR_UNKNOWN_FILE_EXTENSION") {
+			const message = String(error);
+			if (/"\.(m|c)?ts"/g.test(message)) throw new Error(`Make sure you're using Node.js v22.18+ or v24+ for TypeScript support (current version: ${process.versions.node})`, { cause: error });
+			else if (/"\.(m|c)?tsx"/g.test(message)) throw new Error(`You need a compatible loader for JSX support (Deno, Bun or srvx --register jiti/register)`, { cause: error });
+		}
+		throw error;
+	}
+	mod = await opts?.onLoad?.(mod) || mod;
+	let fetchHandler = mod?.fetch || mod?.default?.fetch || mod?.default?.default?.fetch || interceptedFetchHandler;
+	if (!fetchHandler && typeof mod?.default === "function" && mod.default.length < 2) fetchHandler = mod.default;
+	let nodeCompat = false;
+	if (!fetchHandler && opts.nodeCompat !== false) {
+		const nodeHandler = interceptedNodeHandler || (typeof mod?.default === "function" ? mod.default : void 0);
+		if (nodeHandler) {
+			nodeCompat = true;
+			const { fetchNodeHandler } = await import("srvx/node");
+			fetchHandler = (webReq) => fetchNodeHandler(nodeHandler, webReq);
+		}
+	}
+	return {
+		module: mod,
+		nodeCompat,
+		url,
+		fetch: fetchHandler
+	};
+}
+let _interceptQueue = Promise.resolve();
+async function interceptListen(cb) {
+	const result = _interceptQueue.then(async () => {
+		const originalListen = nodeHTTP$1.Server.prototype.listen;
+		let res;
+		let listenHandler;
+		let fetchHandler;
+		globalThis.__srvxLoader__ = (handler) => {
+			fetchHandler = handler;
+		};
+		try {
+			nodeHTTP$1.Server.prototype.listen = function(arg1, arg2) {
+				listenHandler = this._events.request;
+				if (Array.isArray(listenHandler)) listenHandler = listenHandler[0];
+				nodeHTTP$1.Server.prototype.listen = originalListen;
+				const listenCallback = [arg1, arg2].find((arg) => typeof arg === "function");
+				setImmediate(() => {
+					listenCallback?.();
+				});
+				return new Proxy({}, { get(_, prop) {
+					const server = globalThis.__srvx__;
+					if (!server && prop === "address") return () => ({
+						address: "",
+						family: "",
+						port: 0
+					});
+					return server?.node?.server?.[prop];
+				} });
+			};
+			res = await cb();
+		} finally {
+			nodeHTTP$1.Server.prototype.listen = originalListen;
+			delete globalThis.__srvxLoader__;
+		}
+		return {
+			res,
+			listenHandler,
+			fetchHandler
+		};
+	});
+	_interceptQueue = result.catch(() => {});
+	return result;
+}
+export { defaultEntries, defaultExts, loadServerEntry };