Add Web Worker Platform Adapter && Fix module path bug

src/handler.ts

@@ -1,4 +1,4 @@
-import { method, request, responder, response } from "./interface";
+import { method, request, responder, response } from "./interface/index";
 
 export class handler<RequestCustomType, ResponseCustomType> {
 	public responders: responder<RequestCustomType, ResponseCustomType>[];

src/index.ts

@@ -0,0 +1 @@
+console.log("Hello World!");

src/interface/response.ts

@@ -9,7 +9,7 @@ export class defaultHeaders extends headers {
 			this.set("Content-Type", "text/plain; charset=utf-8");
 		this.set(
 			"Server",
-			`Handlers.JS/${packageJSON.version} ${platform}/${version}`
+			`Handlers.js/${packageJSON.version} ${platform}/${version}`
 		);
 	}
 }

src/lib.ts

@@ -4,13 +4,17 @@ export const platform = (() => {
 	if (typeof process != "undefined") {
 		return "Node.js";
 	}
-	return "UNKNOWN";
+	if (typeof self != "undefined") {
+		return "Web Worker";
+	}
+
+	return "Unknown";
 })();
 export const version = (() => {
 	switch (platform) {
 		case "Node.js":
 			return process.version;
 		default:
-			return "UNKNOWN";
+			return "Unknown";
 	}
 })();

src/platform/export.ts

@@ -1 +1,9 @@
-export { NodePlatformAdapter } from "./node";
+import { NodePlatformAdapter } from "./node";
+import { SWPlatformAdapter } from "./serviceworker";
+
+export const platformAdapaterMapping = {
+	"Node.js": NodePlatformAdapter,
+	"Web Worker": SWPlatformAdapter,
+};
+
+export { NodePlatformAdapter, SWPlatformAdapter };

src/platform/index.ts

@@ -5,7 +5,7 @@ export interface platformAdapater<T = any, K = any> {
 	router: router<T, K>;
 	listen(port: number): void;
 	handleRequest(nativeRequest: any): Promise<request<T>>;
-	handleResponse(response: response<K>, nativeResponse?: any): any;
+	handleResponse(response: response<K> | Promise<response<K>>, nativeResponse?: any): any;
 }
 
 export interface platformAdapaterConstructor<T = any, K = any> {

src/platform/node.ts

@@ -1,6 +1,6 @@
-import { platformAdapater } from ".";
+import { platformAdapater } from "./index";
 import { request, response } from "../interface";
-import { router } from "../../";
+import { router } from "../router";
 import { headers } from "../interface/headers";
 
 import http from "http";
@@ -10,7 +10,6 @@ export class NodePlatformAdapter<T = any, K = any> implements platformAdapater {
 
 	constructor(router: router<T, K>) {
 		this.router = router;
-		return this;
 	}
 
 	async listen(port: number): Promise<void> {

src/platform/serviceworker.ts

@@ -0,0 +1,50 @@
+import { platformAdapater } from "./index";
+import { request } from "../interface/request";
+import { response } from "../interface/response";
+import { router } from "../router";
+import { headers } from "../interface/headers";
+
+export class SWPlatformAdapter<T = any, K = any> implements platformAdapater {
+	public router: router<T, K>;
+
+	constructor(router: router<T, K>) {
+		this.router = router;
+	}
+
+	async listen(_port?: number): Promise<void> {
+		self.addEventListener("fetch", (event: FetchEvent) => {
+			event.respondWith(this.handler(event));
+		});
+	}
+
+	async handleRequest(nativeRequest: Request): Promise<request<T>> {
+		const requestHeaders = new headers(
+			Object.fromEntries(nativeRequest.headers.entries())
+		);
+		const requestMessage: request<T> = new request(
+			nativeRequest.method,
+			new URL(nativeRequest.url),
+			requestHeaders,
+			await nativeRequest.text(),
+			{},
+			requestHeaders.get("CF-Connecting-IP") || ""
+		);
+		return requestMessage;
+	}
+
+	async handleResponse(response: response<K>): Promise<Response> {
+		const nativResponse = new Response(response.body, {
+			status: response.status,
+			headers: response.headers.headers,
+		});
+		return nativResponse;
+	}
+
+	async handler(event: FetchEvent): Promise<Response> {
+		return await this.handleResponse(
+			await this.handleRequest(event.request).then((request) =>
+				this.router.respond(request)
+			)
+		)
+	}
+}

src/router.ts

@@ -6,15 +6,18 @@ import {
 	ChainInterrupted,
 	AllMismatchInterrupted,
 	responder,
+	method,
 } from "./interface/index";
 import { defaultHeaders } from "./interface/response";
 import route from "./route";
-import { method, methodENUM } from "./interface/method";
+import { methodENUM } from "./interface/method";
 import {
 	createPlatformAdapater,
 	platformAdapaterConstructor,
 	platformAdapater,
-} from "./platform";
+} from "./platform/index";
+import { platformAdapaterMapping } from "./platform/export";
+import { platform } from "./lib";
 
 export class router<K = any, V = any> {
 	public routes: route[];
@@ -208,4 +211,15 @@ export class rootRouter<K = any, V = any> extends router<K, V> {
 		this.adapater = createPlatformAdapater(adapater, this);
 		return this;
 	}
+	useMappingAdapter(
+		mapping: { [platform: string]: platformAdapaterConstructor } = platformAdapaterMapping
+	): this {
+		if(mapping[platform] == undefined) throw new Error("Platform not found in mapping");
+		else this.useAdapater(mapping[platform]);
+		return this;
+	}
+	listen(port: number): void {
+		if (this.adapater == null) throw new Error("No platform adapter set");
+		this.adapater.listen(port);
+	}
 }