htmx-router 1.0.5 → 1.0.6

package/internal/request/native.js

@@ -20,8 +20,11 @@ export async function Resolve(request, tree, config) {
             : res;
         // Override with context headers
         if (response.headers !== ctx.headers) {
-            for (const [key, value] of ctx.headers)
+            for (const [key, value] of ctx.headers) {
+                if (key === "content-type")
+                    continue;
                 response.headers.set(key, value);
+            }
         }
     }
     catch (e) {

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.5",
+	"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);