hadars 0.1.1

package/src/utils/serve.ts

@@ -0,0 +1,140 @@
+import { isBun, isDeno } from './runtime';
+
+/**
+ * Minimal server context passed to every fetch handler invocation.
+ * On Bun, `upgrade` performs a real WebSocket upgrade.
+ * On all other runtimes it is a no-op that always returns false.
+ */
+export interface ServerContext {
+    upgrade(req: Request): boolean;
+}
+
+type FetchHandler = (
+    req: Request,
+    ctx: ServerContext,
+) => Promise<Response | undefined> | Response | undefined;
+
+/** Converts a Node.js Readable stream to a Web ReadableStream<Uint8Array>. */
+function nodeReadableToWebStream(readable: NodeJS.ReadableStream): ReadableStream<Uint8Array> {
+    const enc = new TextEncoder();
+    return new ReadableStream<Uint8Array>({
+        start(controller) {
+            readable.on('data', (chunk: Buffer | string) => {
+                controller.enqueue(
+                    typeof chunk === 'string'
+                        ? enc.encode(chunk)
+                        : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength),
+                );
+            });
+            readable.on('end', () => controller.close());
+            readable.on('error', (err) => controller.error(err));
+        },
+        cancel() {
+            (readable as any).destroy?.();
+        },
+    });
+}
+
+const noopCtx: ServerContext = { upgrade: () => false };
+
+/**
+ * Starts an HTTP server on the given port using the best available runtime API:
+ * - **Bun**:    `Bun.serve()` — full WebSocket support via the `websocket` option
+ * - **Deno**:   `Deno.serve()`
+ * - **Node.js**: `node:http` `createServer()` with a Web-Fetch bridge
+ *
+ * The `fetchHandler` may return `undefined` to signal that the response was
+ * handled out-of-band (e.g. a Bun WebSocket upgrade).
+ */
+export async function serve(
+    port: number,
+    fetchHandler: FetchHandler,
+    /** Bun WebSocketHandler — ignored on Deno and Node.js. */
+    websocket?: unknown,
+): Promise<void> {
+    // ── Bun ────────────────────────────────────────────────────────────────
+    if (isBun) {
+        (globalThis as any).Bun.serve({
+            port,
+            websocket,
+            async fetch(req: Request, server: any) {
+                const ctx: ServerContext = { upgrade: (r) => server.upgrade(r) };
+                // Returning undefined from a Bun fetch handler means the
+                // request was handled as a WebSocket upgrade.
+                return (await fetchHandler(req, ctx)) ?? undefined;
+            },
+        });
+        return;
+    }
+
+    // ── Deno ───────────────────────────────────────────────────────────────
+    // Deno 2.x changed the signature to options-first. Use the single-object
+    // form { port, handler } which is stable across Deno 1.x and 2.x.
+    if (isDeno) {
+        (globalThis as any).Deno.serve({
+            port,
+            handler: async (req: Request) => {
+                const res = await fetchHandler(req, noopCtx);
+                return res ?? new Response('Not Found', { status: 404 });
+            },
+        });
+        return;
+    }
+
+    // ── Node.js ────────────────────────────────────────────────────────────
+    const { createServer } = await import('node:http');
+
+    const server = createServer(async (nodeReq, nodeRes) => {
+        try {
+            // Collect body for non-GET/HEAD requests
+            const chunks: Buffer[] = [];
+            if (!['GET', 'HEAD'].includes(nodeReq.method ?? 'GET')) {
+                for await (const chunk of nodeReq) {
+                    chunks.push(chunk as Buffer);
+                }
+            }
+            const body = chunks.length > 0 ? Buffer.concat(chunks) : undefined;
+
+            const url = `http://localhost:${port}${nodeReq.url ?? '/'}`;
+            const reqInit: RequestInit & { duplex?: string } = {
+                method: nodeReq.method ?? 'GET',
+                headers: new Headers(nodeReq.headers as Record<string, string>),
+            };
+            if (body) {
+                reqInit.body = body;
+                reqInit.duplex = 'half';
+            }
+            const req = new Request(url, reqInit);
+
+            const res = await fetchHandler(req, noopCtx);
+            const response = res ?? new Response('Not Found', { status: 404 });
+
+            const headers: Record<string, string> = {};
+            response.headers.forEach((v, k) => { headers[k] = v; });
+            nodeRes.writeHead(response.status, headers);
+
+            if (response.body) {
+                const reader = response.body.getReader();
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) break;
+                    await new Promise<void>((resolve, reject) =>
+                        nodeRes.write(value, (err) => (err ? reject(err) : resolve())),
+                    );
+                }
+            }
+        } catch (err) {
+            console.error('[hadars] request error', err);
+            if (!nodeRes.headersSent) nodeRes.writeHead(500);
+        } finally {
+            nodeRes.end();
+        }
+    });
+
+    await new Promise<void>((resolve, reject) => {
+        server.listen(port, () => resolve());
+        server.once('error', reject);
+    });
+}
+
+export { nodeReadableToWebStream };

package/src/utils/staticFile.ts

@@ -0,0 +1,48 @@
+import { readFile, stat } from 'node:fs/promises';
+
+/** MIME type map keyed by lowercase file extension. */
+const MIME: Record<string, string> = {
+    html: 'text/html; charset=utf-8',
+    htm: 'text/html; charset=utf-8',
+    css: 'text/css',
+    js: 'application/javascript',
+    mjs: 'application/javascript',
+    cjs: 'application/javascript',
+    json: 'application/json',
+    map: 'application/json',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    svg: 'image/svg+xml',
+    ico: 'image/x-icon',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    ttf: 'font/ttf',
+    otf: 'font/otf',
+    txt: 'text/plain',
+    xml: 'application/xml',
+    pdf: 'application/pdf',
+};
+
+/**
+ * Tries to serve a file at the given absolute path.
+ * Returns a Response with the correct Content-Type, or null if the file does
+ * not exist or cannot be read.
+ */
+export async function tryServeFile(filePath: string): Promise<Response | null> {
+    try {
+        await stat(filePath);
+    } catch {
+        return null;
+    }
+    try {
+        const data = await readFile(filePath);
+        const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
+        const contentType = MIME[ext] ?? 'application/octet-stream';
+        return new Response(data, { headers: { 'Content-Type': contentType } });
+    } catch {
+        return null;
+    }
+}

package/src/utils/template.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="NINETY_HEAD">
+</head>
+<body>
+    <meta name="NINETY_BODY">
+</body>
+</html>

package/src/utils/upgradeRequest.tsx

@@ -0,0 +1,19 @@
+import type { ServerContext } from './serve';
+import type { HadarsOptions, HadarsRequest } from "../types/ninety";
+
+type UpgradeHandle = (req: HadarsRequest, ctx: ServerContext) => boolean;
+
+export const upgradeHandler = (options: HadarsOptions): UpgradeHandle | null => {
+    const { wsPath = '/ws' } = options;
+
+    if (options.websocket) {
+        return (req: HadarsRequest, ctx: ServerContext) => {
+            if (req.pathname === wsPath) {
+                return ctx.upgrade(req);
+            }
+            return false;
+        };
+    }
+
+    return null;
+};