htmx-router 2.2.5 → 2.2.7

package/dist/event-source.d.ts

@@ -34,7 +34,7 @@ export declare class EventSourceSet<JsxEnabled extends boolean = false> extends
      * Send update to all EventSources, auto closing failed dispatches
      * @returns number of successful sends
      */
-    dispatch(type: string, data: string): number;
+    dispatch(type: string, data: JsxEnabled extends true ? (JSX.Element | string) : string): number;
     /**
      * Cull all closed connections
      * @returns number of connections closed
@@ -51,6 +51,27 @@ export declare class EventSourceSet<JsxEnabled extends boolean = false> extends
      */
     closeAll(): number;
 }
+export declare class EventSourceMap<T, JsxEnabled extends boolean = false> extends Map<EventSource<JsxEnabled>, T> {
+    private onAbort;
+    constructor();
+    set(stream: EventSource<JsxEnabled>, value: T): this;
+    delete(stream: EventSource<JsxEnabled>): boolean;
+    /**
+     * Send update to all EventSources, auto closing failed dispatches
+     * @returns number of successful sends
+     */
+    dispatch(type: string, data: JsxEnabled extends true ? (JSX.Element | string) : string): number;
+    /**
+     * Cull all closed connections
+     * @returns number of connections closed
+     */
+    cull(): number;
+    /**
+     * Close all connections
+     * @returns number of connections closed
+     */
+    closeAll(): number;
+}
 type SharedEventSourceCacheRule = {
     limit: number;
     ttl: number;

package/dist/event-source.js

@@ -182,7 +182,7 @@ export class EventSourceSet extends Set {
             if (success)
                 count++;
         }
-        return count;
+        return count - this.size;
     }
     /**
      * Close all connections
@@ -196,6 +196,62 @@ export class EventSourceSet extends Set {
         return count;
     }
 }
+export class EventSourceMap extends Map {
+    onAbort;
+    constructor() {
+        super();
+        this.onAbort = () => this.cull();
+    }
+    set(stream, value) {
+        stream._signal.addEventListener('abort', this.onAbort);
+        return super.set(stream, value);
+    }
+    delete(stream) {
+        stream._signal.removeEventListener('abort', this.onAbort);
+        return super.delete(stream);
+    }
+    /**
+     * Send update to all EventSources, auto closing failed dispatches
+     * @returns number of successful sends
+     */
+    dispatch(type, data) {
+        let count = 0;
+        for (const stream of this.keys()) {
+            if (stream.readyState !== EventSource.OPEN)
+                continue; // skip closed
+            const success = stream.dispatch(type, data);
+            if (success)
+                count++;
+            else
+                this.delete(stream);
+        }
+        return count;
+    }
+    /**
+     * Cull all closed connections
+     * @returns number of connections closed
+     */
+    cull() {
+        const count = this.size;
+        for (const stream of this.keys()) {
+            if (stream.readyState !== EventSource.CLOSED)
+                continue;
+            this.delete(stream);
+        }
+        return count - this.size;
+    }
+    /**
+     * Close all connections
+     * @returns number of connections closed
+     */
+    closeAll() {
+        const count = this.size;
+        for (const stream of this.keys())
+            stream.close();
+        this.clear();
+        return count;
+    }
+}
 /**
  * DO NOT USE: Experimental
  * @deprecated

package/dist/router.d.ts

@@ -27,6 +27,11 @@ export declare class RouteResolver {
     resolve(): Promise<Response | null>;
     unwind(e: unknown, offset: number): Promise<Response>;
 }
+type IngestContext = {
+    path: string[];
+    route: string;
+    params: string[];
+};
 export declare class RouteTree {
     private nested;
     private index;
@@ -34,12 +39,13 @@ export declare class RouteTree {
     private wild;
     private wildCard;
     constructor();
-    ingest(node: RouteLeaf, path?: string[]): void;
+    ingest(node: RouteLeaf, ctx?: IngestContext): void;
     _applyChain(out: RouteResolver, fragments: string[], offset?: number): void;
 }
 declare class RouteLeaf {
     readonly module: RouteModule<any>;
     readonly path: string;
     constructor(module: RouteModule<any>, path: string);
+    checkParameters(ctx: IngestContext): void;
 }
 export {};

package/dist/router.js

@@ -148,19 +148,28 @@ export class RouteTree {
         this.wild = null;
         this.slug = null;
     }
-    ingest(node, path) {
-        if (!path)
-            path = node.path.length === 0 ? [] : node.path.slice(1).split("/");
-        if (path.length === 0) {
+    ingest(node, ctx) {
+        if (!ctx)
+            ctx = {
+                path: node.path.slice(1).split("/").reverse(),
+                route: node.path,
+                params: [],
+            };
+        const segment = ctx.path.pop();
+        if (!segment) {
+            node.checkParameters(ctx);
             this.index = node;
             return;
         }
-        if (path[0] === "$") {
+        if (segment === "$") {
+            ctx.params.push('$');
+            node.checkParameters(ctx);
             this.slug = node;
             return;
         }
-        if (path[0][0] === "$") {
-            const wildCard = path[0].slice(1);
+        if (segment[0] === "$") {
+            const wildCard = segment.slice(1);
+            ctx.params.push(wildCard);
             // Check wildcard isn't being changed
             if (!this.wild) {
                 this.wildCard = wildCard;
@@ -169,15 +178,15 @@ export class RouteTree {
             else if (wildCard !== this.wildCard) {
                 throw new Error(`Redefinition of wild card ${this.wildCard} to ${wildCard}`);
             }
-            this.wild.ingest(node, path.slice(1));
+            this.wild.ingest(node, ctx);
             return;
         }
-        let next = this.nested.get(path[0]);
+        let next = this.nested.get(segment);
         if (!next) {
             next = new RouteTree();
-            this.nested.set(path[0], next);
+            this.nested.set(segment, next);
         }
-        next.ingest(node, path.slice(1));
+        next.ingest(node, ctx);
     }
     _applyChain(out, fragments, offset = 0) {
         if (this.slug) {
@@ -205,4 +214,13 @@ class RouteLeaf {
         this.module = module;
         this.path = path;
     }
+    checkParameters(ctx) {
+        if (!this.module.parameters)
+            return;
+        for (const key in this.module.parameters) {
+            if (ctx.params.includes(key))
+                continue;
+            console.warn(`\x1b[33mWarn:\x1b[0m \x1b[36m${ctx.route}\x1b[0m has no parameter \x1b[36m${key}\x1b[0m`);
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "htmx-router",
-	"version": "2.2.5",
+	"version": "2.2.7",
 	"description": "A lightweight SSR framework with server+client islands",
 	"keywords": [ "htmx", "router", "client islands", "ssr", "vite" ],
 	"type": "module",