htmx-router 1.0.4 → 1.0.6

package/css.js

@@ -53,8 +53,7 @@ export async function loader(ctx) {
     const build = GetSheet();
     if (!ctx.params.hash.startsWith(build.hash))
         return null;
-    const headers = new Headers();
-    headers.set("Content-Type", "text/css");
-    headers.set("Cache-Control", "public, max-age=604800");
-    return new Response(build.sheet, { headers });
+    ctx.headers.set("Content-Type", "text/css");
+    ctx.headers.set("Cache-Control", "public, max-age=604800");
+    return new Response(build.sheet, { headers: ctx.headers });
 }

package/event-source.js

@@ -1,5 +1,15 @@
 import { ServerOnlyWarning } from "./internal/util.js";
 ServerOnlyWarning("event-source");
+// global for easy reuse
+const encoder = new TextEncoder();
+const headers = new Headers();
+// Chunked encoding with immediate forwarding by proxies (i.e. nginx)
+headers.set("X-Accel-Buffering", "no");
+headers.set("Transfer-Encoding", "chunked");
+headers.set("Content-Type", "text/event-stream");
+// the maximum keep alive chrome shouldn't ignore
+headers.set("Keep-Alive", "timeout=120");
+headers.set("Connection", "keep-alive");
 /**
  * Helper for Server-Sent-Events, with auto close on SIGTERM and SIGHUP messages
  * Includes a keep alive empty packet sent every 30sec (because Chrome implodes at 120sec, and can be unreliable at 60sec)
@@ -95,15 +105,6 @@ export class EventSourceSet extends Set {
         this.clear();
     }
 }
-// global for easy reuse
-const encoder = new TextEncoder();
-const headers = new Headers();
-// Chunked encoding with immediate forwarding by proxies (i.e. nginx)
-headers.set("X-Accel-Buffering", "no");
-headers.set("Transfer-Encoding", "chunked");
-headers.set("Content-Type", "text/event-stream");
-headers.set("Keep-Alive", "timeout=120"); // the maximum keep alive chrome shouldn't ignore
-headers.set("Connection", "keep-alive");
 // Auto close all SSE streams when shutdown requested
 // Without this graceful shutdowns will hang indefinitely
 const register = new EventSourceSet();

package/internal/mount.js

@@ -120,8 +120,7 @@ export async function loader(ctx) {
     // const build = GetSheet();
     if (!ctx.params.hash.startsWith(hash))
         return null;
-    const headers = new Headers();
-    headers.set("Content-Type", "text/javascript");
-    headers.set("Cache-Control", "public, max-age=604800");
-    return new Response(script, { headers });
+    ctx.headers.set("Content-Type", "text/javascript");
+    ctx.headers.set("Cache-Control", "public, max-age=604800");
+    return new Response(script, { headers: ctx.headers });
 }

package/internal/request/http.d.ts

@@ -1,6 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "http";
 import type { ViteDevServer } from "vite";
-import type { GenericContext } from "../router.js";
+import { GenericContext } from "../router.js";
 type Config = {
     build: Promise<any> | (() => Promise<Record<string, any>>);
     viteDevServer: ViteDevServer | null;

package/internal/request/native.d.ts

@@ -1,6 +1,11 @@
 import type { Config } from './index.js';
 import type { RouteTree } from '../../router.js';
-export declare function createRequestHandler(config: Config): (req: Request) => Promise<Response>;
+export declare function createRequestHandler(config: Config): (req: Request) => Promise<{
+    response: Response;
+    headers: {
+        [key: string]: string | string[];
+    };
+}>;
 export declare function Resolve(request: Request, tree: RouteTree, config: Config): Promise<{
     response: Response;
     headers: {

package/internal/request/native.js

@@ -1,40 +1,41 @@
 import { ServerOnlyWarning } from "../util.js";
 ServerOnlyWarning("native-request");
 import { GenericContext } from "../router.js";
+import { MakeStatus } from "../../status.js";
 export function createRequestHandler(config) {
     return async (req) => {
-        try {
-            const mod = typeof config.build === "function" ? await config.build() : await config.build;
-            let { response } = await Resolve(req, mod.tree, config);
-            return response;
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                console.error(e.stack);
-                config.viteDevServer?.ssrFixStacktrace(e);
-                return new Response(e.message + "\n" + e.stack, { status: 500, statusText: "Internal Server Error" });
-            }
-            else {
-                console.error(e);
-                return new Response(String(e), { status: 500, statusText: "Internal Server Error" });
-            }
-        }
+        const mod = typeof config.build === "function" ? await config.build() : await config.build;
+        return await Resolve(req, mod.tree, config);
     };
 }
 export async function Resolve(request, tree, config) {
-    const url = new URL(request.url);
-    const ctx = new GenericContext(request, url, config.render);
-    const x = ctx.url.pathname.endsWith("/") ? ctx.url.pathname.slice(0, -1) : ctx.url.pathname;
-    const fragments = x.split("/").slice(1);
-    let response = await tree.resolve(fragments, ctx);
-    if (response === null)
-        response = new Response("No Route Found", { status: 404, statusText: "Not Found", headers: ctx.headers });
-    // Override with context headers
-    if (response.headers !== ctx.headers) {
-        for (const [key, value] of ctx.headers) {
-            if (response.headers.has(key))
-                continue;
-            response.headers.set(key, value);
+    const ctx = new GenericContext(request, new URL(request.url), config.render);
+    let response;
+    try {
+        const x = ctx.url.pathname.endsWith("/") ? ctx.url.pathname.slice(0, -1) : ctx.url.pathname;
+        const fragments = x.split("/").slice(1);
+        const res = await tree.resolve(fragments, ctx);
+        response = res === null
+            ? new Response("No Route Found", MakeStatus("Not Found", ctx.headers))
+            : res;
+        // Override with context headers
+        if (response.headers !== ctx.headers) {
+            for (const [key, value] of ctx.headers) {
+                if (key === "content-type")
+                    continue;
+                response.headers.set(key, value);
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            console.error(e.stack);
+            config.viteDevServer?.ssrFixStacktrace(e);
+            response = new Response(e.message + "\n" + e.stack, { status: 500, statusText: "Internal Server Error" });
+        }
+        else {
+            console.error(e);
+            response = new Response(String(e), { status: 500, statusText: "Internal Server Error" });
         }
     }
     // Merge cookie changes

package/internal/util.d.ts

@@ -2,3 +2,4 @@ export declare function QuickHash(input: string): string;
 export declare function CutString(str: string, pivot: string, offset?: number): [string, string];
 export declare function Singleton<T>(name: string, cb: () => T): T;
 export declare function ServerOnlyWarning(context: string): void;
+export declare function AssertUnreachable(x: never): never;

package/internal/util.js

@@ -47,3 +47,7 @@ export function ServerOnlyWarning(context) {
     console.warn(`Warn: Server-side only htmx-router feature ${context} has leaked to client code`);
     console.log(typeof document, typeof process);
 }
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function AssertUnreachable(x) {
+    throw new Error("Unreachable code path reachable");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "htmx-router",
-	"version": "1.0.4",
+	"version": "1.0.6",
 	"description": "A lightweight SSR framework with server+client islands",
 	"keywords": [
 		"htmx",

package/response.d.ts

@@ -1,5 +1,5 @@
-export declare function text(text: string, init?: ResponseInit): Response;
-export declare function html(text: string, init?: ResponseInit): Response;
+export declare function text(text: BodyInit, init?: ResponseInit): Response;
+export declare function html(text: BodyInit, init?: ResponseInit): Response;
 export type TypedResponse<T> = Omit<Response, "json"> & {
     json(): Promise<T>;
 };

package/router.js

@@ -1,10 +1,12 @@
-import { ServerOnlyWarning } from "./internal/util.js";
+import { AssertUnreachable, ServerOnlyWarning } from "./internal/util.js";
 ServerOnlyWarning("router");
+import { MakeStatus } from "./status.js";
 // builtin routes
 import * as endpoint from './endpoint.js';
 import * as dynamic from './defer.js';
 import * as mount from './internal/mount.js';
 import * as css from './css.js';
+import { html } from "./response.js";
 export function GenerateRouteTree(props) {
     if (!props.scope.endsWith("/"))
         props.scope += "/";
@@ -134,7 +136,7 @@ export class RouteTree {
             return res;
         if (res === null)
             return null;
-        return new Response(res, { headers: ctx.headers });
+        AssertUnreachable(res);
     }
     async resolveNext(fragments, ctx) {
         if (fragments.length < 1)
@@ -161,22 +163,12 @@ export class RouteTree {
             return res;
         if (res === null)
             return null;
-        return new Response(res, { headers: ctx.headers });
+        AssertUnreachable(res);
     }
-    async unwrap(ctx, res) {
+    unwrap(ctx, res) {
         if (!this.slug)
             throw res;
-        const caught = await this.slug.error(ctx, res);
-        if (caught instanceof Response) {
-            caught.headers.set("X-Caught", "true");
-            return caught;
-        }
-        ctx.headers.set("X-Caught", "true");
-        return new Response(caught, res instanceof Response ? res : {
-            status: 500,
-            statusText: "Internal Server Error",
-            headers: ctx.headers
-        });
+        return this.slug.error(ctx, res);
     }
 }
 class RouteLeaf {
@@ -185,20 +177,28 @@ class RouteLeaf {
         this.module = module;
     }
     async resolve(ctx) {
-        const res = await this.response(ctx);
-        if (res === null)
+        const jsx = await this.response(ctx);
+        if (jsx === null)
             return null;
+        if (jsx instanceof Response)
+            return jsx;
+        const res = await ctx.render(jsx, ctx.headers);
         if (res instanceof Response)
             return res;
-        return await ctx.render(res, ctx.headers);
+        return html(res, { headers: ctx.headers });
     }
     async error(ctx, e) {
         if (!this.module.error)
             throw e;
-        const res = await this.module.error(ctx, e);
-        if (res instanceof Response)
-            return res;
-        return await ctx.render(res, ctx.headers);
+        let jsx = await this.module.error(ctx, e);
+        const caught = jsx instanceof Response ? jsx
+            : await ctx.render(jsx, ctx.headers);
+        if (caught instanceof Response) {
+            caught.headers.set("X-Caught", "true");
+            return caught;
+        }
+        ctx.headers.set("X-Caught", "true");
+        return html(caught, e instanceof Response ? e : MakeStatus("Internal Server Error", ctx.headers));
     }
     async response(ctx) {
         try {
@@ -213,7 +213,7 @@ class RouteLeaf {
             }
             if (this.module.action)
                 return await this.module.action(context);
-            throw new Response("Method not Allowed", { status: 405, statusText: "Method not Allowed", headers: ctx.headers });
+            throw new Response("Method not Allowed", MakeStatus("Method Not Allowed", ctx.headers));
         }
         catch (e) {
             return await this.error(ctx, e);

package/status.d.ts

@@ -64,8 +64,5 @@ declare const definitions: {
     511: "Network Authentication Required";
 };
 export type StatusText = typeof definitions[keyof typeof definitions];
-export declare function MakeStatus(lookup: number | StatusText): {
-    status: number;
-    statusText: StatusText;
-};
+export declare function MakeStatus(lookup: number | StatusText, init?: ResponseInit | Headers): ResponseInit;
 export {};

package/status.js

@@ -73,21 +73,32 @@ for (const key in definitions) {
     const code = Number(key);
     index.set(definitions[code].toLowerCase(), code);
 }
-export function MakeStatus(lookup) {
+export function MakeStatus(lookup, init) {
+    if (init instanceof Headers)
+        init = { headers: init };
     if (typeof lookup === "number")
-        return lookupCode(lookup);
-    return lookupStatus(lookup);
+        return lookupCode(lookup, init);
+    return lookupStatus(lookup, init);
 }
-function lookupCode(status) {
+function lookupCode(status, init) {
     if (status < 100)
         throw new TypeError(`Status ${status}<100`);
     if (status > 599)
         throw new TypeError(`Status ${status}>599`);
-    return { status, statusText: lookup[status] };
+    const statusText = lookup[status];
+    return Status(status, statusText, init);
 }
-function lookupStatus(statusText) {
+function lookupStatus(statusText, init) {
     const status = index.get(statusText.toLowerCase());
     if (!status)
         throw new TypeError(`statusText ${statusText} is not of type StatusText`);
+    return Status(status, statusText, init);
+}
+function Status(status, statusText, init) {
+    if (init) {
+        init.statusText = statusText;
+        init.status = status;
+        return init;
+    }
     return { status, statusText };
 }