htmx-router 2.0.0 → 2.0.2

package/cookies.d.ts

@@ -24,7 +24,7 @@ export declare class Cookies {
     has(name: string): boolean;
     set(name: string, value: string, options?: CookieOptions): void;
     private string;
-    unset(name: string): void;
+    unset(name: string, options?: CookieOptions): void;
     /** Creates the response headers required to make the changes done to these cookies */
     export(): string[];
 }

package/cookies.js

@@ -55,9 +55,10 @@ export class Cookies {
         return encodeURIComponent(name) + "=" + encodeURIComponent(this.map[name]) + StringifyOptions(this.config[name]);
         ;
     }
-    unset(name) {
+    unset(name, options = { maxAge: -1 }) {
+        options.maxAge ||= -1;
         this.parse();
-        return this.set(name, "", { maxAge: 0 });
+        return this.set(name, "", options);
     }
     /** Creates the response headers required to make the changes done to these cookies */
     export() {

package/internal/request/server.d.ts

@@ -1,5 +1,4 @@
 import type { ViteDevServer } from "vite";
-import { connectToWeb } from "./compatibility/vite/connectToWeb.js";
 import { GenericContext } from "../router.js";
 import { RouterModule } from "./index.js";
 export type Config = {
@@ -11,10 +10,7 @@ type ServerBindType = "pre" | "post";
 type ServerBind = (ctx: GenericContext) => Promise<Response | null> | Response | null;
 export declare class HtmxRouterServer {
     #private;
-    readonly vite: {
-        handler: ReturnType<typeof connectToWeb>;
-        server: Config["viteDevServer"];
-    } | null;
+    readonly vite: Config["viteDevServer"];
     readonly render: Config["render"];
     readonly build: Config["build"];
     constructor(config: Config);

package/internal/request/server.js

@@ -21,18 +21,15 @@ export class HtmxRouterServer {
     build;
     #binding;
     constructor(config) {
-        this.vite = config.viteDevServer ? {
-            handler: connectToWeb(config.viteDevServer.middlewares),
-            server: config.viteDevServer
-        } : null;
+        this.vite = config.viteDevServer;
         this.render = config.render;
         this.build = config.build;
         this.#binding = {
             pre: [UrlCleaner],
             post: []
         };
-        if (config.viteDevServer) {
-            const handler = connectToWeb(config.viteDevServer.middlewares);
+        if (this.vite) {
+            const handler = connectToWeb(this.vite.middlewares);
             this.#binding.post.push(handler);
         }
     }
@@ -108,7 +105,7 @@ export class HtmxRouterServer {
         }
         catch (e) {
             if (e instanceof Error)
-                this.vite?.server?.ssrFixStacktrace(e);
+                this.vite?.ssrFixStacktrace(e);
             console.error(e);
             response = await tree.unwrap(ctx, e);
         }

package/package.json

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

package/internal/request/http.d.ts

@@ -1,13 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "http";
-import type { ViteDevServer } from "vite";
-import { GenericContext } from "../router.js";
-type Config = {
-    build: Promise<any> | (() => Promise<Record<string, any>>);
-    viteDevServer: ViteDevServer | null;
-    render: GenericContext["render"];
-};
-/**
- * @deprecated
- */
-export declare function createRequestHandler(config: Config): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-export {};

package/internal/request/http.js

@@ -1,43 +0,0 @@
-import { ServerOnlyWarning } from "../util.js";
-ServerOnlyWarning("http-request");
-import { CreateRequest } from "./compatibility/node.js";
-import { Resolve } from "./native.js";
-/**
- * @deprecated
- */
-export function createRequestHandler(config) {
-    return async (req, res) => {
-        try {
-            const mod = typeof config.build === "function" ? await config.build() : await config.build;
-            const request = CreateRequest(req);
-            let { response, headers } = await Resolve(request, mod.tree, config);
-            res.writeHead(response.status, headers);
-            if (response.body instanceof ReadableStream) {
-                const reader = response.body.getReader();
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    res.write(value); // `value` is a Uint8Array.
-                }
-                res.end();
-            }
-            else {
-                const rendered = await response.text();
-                res.end(rendered);
-            }
-        }
-        catch (e) {
-            res.statusCode = 500;
-            if (e instanceof Error) {
-                console.error(e.stack);
-                config.viteDevServer?.ssrFixStacktrace(e);
-                res.end(e.stack);
-            }
-            else {
-                console.error(e);
-                res.end(String(e));
-            }
-        }
-    };
-}

package/internal/request/native.d.ts

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

package/internal/request/native.js

@@ -1,61 +0,0 @@
-import { ServerOnlyWarning } from "../util.js";
-ServerOnlyWarning("native-request");
-import { GenericContext } from "../router.js";
-import { MakeStatus } from "../../status.js";
-/**
- * @deprecated
- */
-export function createRequestHandler(config) {
-    return async (req) => {
-        const mod = typeof config.build === "function" ? await config.build() : await config.build;
-        return await Resolve(req, mod.tree, config);
-    };
-}
-/**
- * @deprecated
- */
-export async function Resolve(request, tree, config) {
-    const ctx = new GenericContext(request, new URL(request.url), config.render);
-    let response;
-    try {
-        const x = ctx.url.pathname.slice(1);
-        if (x.endsWith("/")) {
-            ctx.headers.set("location", ctx.url.pathname.slice(0, -1) + ctx.url.search + ctx.url.hash);
-            response = new Response("", MakeStatus("Permanent Redirect", { headers: ctx.headers }));
-        }
-        else {
-            const fragments = x === "" ? [] : x.split("/");
-            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
-    const headers = Object.fromEntries(response.headers);
-    const cookies = ctx.cookie.export();
-    if (cookies.length > 0) {
-        headers['set-cookie'] = cookies;
-        response.headers.set("Set-Cookie", cookies[0]); // Response object doesn't support multi-header..[]
-    }
-    return { response, headers };
-}