htmx-router 1.0.12 → 1.0.14

package/event-source.d.ts

@@ -3,13 +3,17 @@
  * Includes a keep alive empty packet sent every 30sec (because Chrome implodes at 120sec, and can be unreliable at 60sec)
  */
 export declare class EventSource {
-    private controller;
-    private timer;
-    private state;
+    #private;
     readonly response: Response;
+    readonly createdAt: number;
+    get updatedAt(): number;
+    readonly withCredentials: boolean;
     readonly url: string;
-    constructor(request: Request, keepAlive?: number);
     get readyState(): number;
+    static CONNECTING: number;
+    static OPEN: number;
+    static CLOSED: number;
+    constructor(request: Request, keepAlive?: number);
     private sendBytes;
     private sendText;
     private keepAlive;

package/event-source.js

@@ -2,45 +2,60 @@ 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");
+const headers = {
+    // Chunked encoding with immediate forwarding by proxies (i.e. nginx)
+    "X-Accel-Buffering": "no",
+    "Transfer-Encoding": "chunked",
+    "Content-Type": "text/event-stream",
+    // the maximum keep alive chrome shouldn't ignore
+    "Keep-Alive": "timeout=60",
+    "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)
  */
 export class EventSource {
-    controller;
-    timer;
-    state;
+    #controller;
+    #timer;
+    #state;
     response;
-    url; // just to make it polyfill
+    // activity timestamps, in unix time for minimal storage
+    // since most use cases won't need the Date object anyway
+    // no point waiting space and cycles creating it
+    createdAt;
+    get updatedAt() { return this.#updatedAt; }
+    #updatedAt;
+    // just to make it polyfill
+    withCredentials;
+    url;
+    get readyState() { return this.#state; }
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSED = 2;
     constructor(request, keepAlive = 30_000) {
-        this.controller = null;
-        this.state = 0;
+        this.#controller = null;
+        this.#state = EventSource.CONNECTING;
+        this.withCredentials = request.mode === "cors";
         this.url = request.url;
-        const stream = new ReadableStream({
-            start: (c) => { this.controller = c; this.state = 1; },
-            cancel: () => { this.close(); }
-        });
-        request.signal.addEventListener('abort', () => this.close());
+        this.createdAt = Date.now();
+        this.#updatedAt = 0;
+        // immediate prepare for abortion
+        const cancel = () => { this.close(); };
+        request.signal.addEventListener('abort', cancel);
+        const start = (c) => { this.#controller = c; this.#state = EventSource.OPEN; };
+        const stream = new ReadableStream({ start, cancel }, { highWaterMark: 0 });
         this.response = new Response(stream, { headers });
-        this.timer = setInterval(() => this.keepAlive(), keepAlive);
+        this.#timer = setInterval(() => this.keepAlive(), keepAlive);
         register.add(this);
     }
-    get readyState() {
-        return this.state;
-    }
-    sendBytes(chunk) {
-        if (!this.controller)
+    sendBytes(chunk, active) {
+        if (!this.#controller)
             return false;
         try {
-            this.controller.enqueue(chunk);
+            this.#controller.enqueue(chunk);
+            if (active)
+                this.#updatedAt = Date.now();
             return true;
         }
         catch (e) {
@@ -49,33 +64,40 @@ export class EventSource {
             return false;
         }
     }
-    sendText(chunk) {
-        return this.sendBytes(encoder.encode(chunk));
+    sendText(chunk, simulated) {
+        return this.sendBytes(encoder.encode(chunk), simulated);
     }
     keepAlive() {
-        return this.sendText("\n\n");
+        return this.sendText("\n\n", false);
     }
     dispatch(type, data) {
-        return this.sendText(`event: ${type}\ndata: ${data}\n\n`);
+        if (this.#state === EventSource.CLOSED) {
+            const err = new Error(`Warn: Attempted to dispatch event "${type}" to a closed connection for: ${this.url}`, {});
+            console.warn(err);
+        }
+        return this.sendText(`event: ${type}\ndata: ${data}\n\n`, true);
     }
     close(unlink = true) {
-        if (this.state === 2)
+        if (this.#state === EventSource.CLOSED) {
+            this.#controller = null;
             return false;
-        if (unlink)
-            register.delete(this);
-        try {
-            this.controller?.close();
         }
-        catch (e) {
-            console.error(e);
-            this.controller = null;
-            return false;
+        if (this.#controller) {
+            try {
+                this.#controller.close();
+            }
+            catch (e) {
+                console.error(e);
+            }
+            this.#controller = null;
         }
         // Cleanup
-        if (this.timer)
-            clearInterval(this.timer);
-        this.controller = null;
-        this.state = 2;
+        if (this.#timer)
+            clearInterval(this.#timer);
+        if (unlink)
+            register.delete(this);
+        // Mark closed
+        this.#state = EventSource.CLOSED;
         return true;
     }
 }

package/internal/request/native.js

@@ -12,12 +12,18 @@ 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.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;
+        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) {

package/navigate.d.ts

@@ -1,3 +1,10 @@
-export declare function navigate(href: string, pushHistory?: boolean): Promise<void>;
-export declare function revalidate(): Promise<void>;
+export declare function htmxNavigate(href?: string, pushHistory?: boolean): void;
+/**
+ * @deprecated - use htmxNavigate() instead
+ */
+export declare const navigate: void;
+/**
+ * @deprecated - use navigate() instead
+ */
+export declare function revalidate(): void;
 export declare function htmxAppend(href: string, verb?: string): Promise<void>;

package/navigate.js

@@ -5,7 +5,7 @@ function htmx() {
     return htmx;
 }
 const driver = (typeof document === "object" ? document.createElement("a") : null);
-export async function navigate(href, pushHistory = true) {
+export function htmxNavigate(href = "", pushHistory = true) {
     if (typeof window !== "object")
         return;
     if (!driver)
@@ -29,8 +29,15 @@ export async function navigate(href, pushHistory = true) {
     htmx().process(driver);
     driver.click();
 }
+/**
+ * @deprecated - use htmxNavigate() instead
+ */
+export const navigate = htmxNavigate();
+/**
+ * @deprecated - use navigate() instead
+ */
 export function revalidate() {
-    return navigate("", false);
+    return htmxNavigate("", false);
 }
 export async function htmxAppend(href, verb = "GET") {
     await htmx().ajax(verb, href, {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "htmx-router",
-	"version": "1.0.12",
+	"version": "1.0.14",
 	"description": "A lightweight SSR framework with server+client islands",
 	"keywords": [
 		"htmx",
@@ -28,8 +28,8 @@
 	},
 	"homepage": "https://htmx-router.ajanibilby.com/",
 	"dependencies": {
-		"es-module-lexer": "^1.5.4",
-		"vite": "^6.2.3"
+		"es-module-lexer": "^1.7.0",
+		"vite": "^6.3.5"
 	},
 	"devDependencies": {
 		"@types/node": "^20.4.5",

package/status.d.ts

@@ -1,4 +1,4 @@
-declare const definitions: {
+declare const dictionary: {
     100: "Continue";
     101: "Switching Protocols";
     102: "Processing";
@@ -63,6 +63,12 @@ declare const definitions: {
     510: "Not Extended";
     511: "Network Authentication Required";
 };
-export type StatusText = typeof definitions[keyof typeof definitions];
-export declare function MakeStatus(lookup: number | StatusText, init?: ResponseInit | Headers): ResponseInit;
+type Definitions = typeof dictionary;
+export type StatusCode = keyof Definitions;
+export type StatusText = Definitions[StatusCode];
+export declare function MakeStatus(lookup: StatusCode | StatusText, init?: ResponseInit | Headers): ResponseInit;
+/**
+ * @deprecated
+ */
+export type Status = StatusCode;
 export {};

package/status.js

@@ -1,4 +1,4 @@
-const definitions = {
+const dictionary = {
     100: "Continue",
     101: "Switching Protocols",
     102: "Processing",
@@ -63,15 +63,15 @@ const definitions = {
     510: "Not Extended",
     511: "Network Authentication Required",
 };
-const lookup = new Array(500);
-for (let i = 100; i < 600; i++) {
-    lookup[i - 100] = definitions[i]
-        || definitions[i % 100];
-}
-const index = new Map();
-for (const key in definitions) {
-    const code = Number(key);
-    index.set(definitions[code].toLowerCase(), code);
+const index = {
+    code: new Map(),
+    text: new Map()
+};
+for (const k in dictionary) {
+    const code = Number(k);
+    const text = dictionary[code];
+    index.code.set(text.toLowerCase(), code);
+    index.text.set(code, text);
 }
 export function MakeStatus(lookup, init) {
     if (init instanceof Headers)
@@ -80,25 +80,20 @@ export function MakeStatus(lookup, init) {
         return lookupCode(lookup, init);
     return lookupStatus(lookup, init);
 }
-function lookupCode(status, init) {
-    if (status < 100)
-        throw new TypeError(`Status ${status}<100`);
-    if (status > 599)
-        throw new TypeError(`Status ${status}>599`);
-    const statusText = lookup[status];
-    return Status(status, statusText, init);
+function lookupCode(code, init) {
+    const text = index.text.get(code);
+    if (text === undefined)
+        throw new TypeError(`Status ${code} is not a known status code`);
+    return SetStatus(init, code, text);
 }
-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 lookupStatus(text, init) {
+    const code = index.code.get(text.toLowerCase());
+    if (code === undefined)
+        throw new TypeError(`Status "${text}" is not a known status text`);
+    return SetStatus(init, code, text);
 }
-function Status(status, statusText, init) {
-    if (init) {
-        init.statusText = statusText;
-        init.status = status;
-        return init;
-    }
-    return { status, statusText };
+function SetStatus(into = {}, status, statusText) {
+    into.statusText = statusText;
+    into.status = status;
+    return into;
 }