htmx-router 0.2.0 → 1.0.0-alpha.1

package/bin/util/endpoint.js

@@ -0,0 +1,28 @@
+import { QuickHash } from "../util/hash.js";
+const registry = new Map();
+export class Endpoint {
+    render;
+    name;
+    url;
+    constructor(render, name) {
+        this.render = render;
+        name ||= render.constructor.name;
+        const hash = QuickHash(String(render));
+        this.name = name ? `${encodeURIComponent(name)}-${hash}` : hash;
+        this.url = `/_/endpoint/${this.name}`;
+        registry.set(this.name, this);
+    }
+}
+export async function _resolve(fragments, ctx) {
+    if (!fragments[2])
+        return null;
+    const endpoint = registry.get(fragments[2]);
+    if (!endpoint)
+        return null;
+    const res = await endpoint.render(ctx);
+    if (res === null)
+        return null;
+    if (res instanceof Response)
+        return res;
+    return ctx.render(res);
+}

package/bin/util/event-source.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Create a new SSE handler
+ * Includes auto keep-alive, and graceful shutdown
+ */
+export declare class EventSourceConnection {
+    private controller;
+    private stream;
+    private timer;
+    readonly createdAt: number;
+    constructor(request: Request, keepAlive?: number);
+    response(): Response;
+    private keepAlive;
+    send(type: string, data: string, timeStamp: number): boolean;
+    isClosed(): boolean;
+    close(unlink?: boolean): boolean;
+}

package/bin/util/event-source.js

@@ -0,0 +1,85 @@
+/**
+ * Create a new SSE handler
+ * Includes auto keep-alive, and graceful shutdown
+ */
+export class EventSourceConnection {
+    controller;
+    stream;
+    timer;
+    createdAt; // unix time
+    constructor(request, keepAlive = 30_000) {
+        this.createdAt = Date.now();
+        this.controller = null;
+        this.stream = new ReadableStream({
+            start: (c) => { this.controller = c; },
+            cancel: () => { this.close(); }
+        });
+        request.signal.addEventListener('abort', () => this.close());
+        this.timer = setInterval(() => this.keepAlive(), keepAlive);
+        register.push(this);
+    }
+    response() {
+        const headers = new Headers();
+        headers.set("Content-Type", "text/event-stream");
+        headers.set("Transfer-Encoding", "chunked");
+        headers.set("Connection", "keep-alive");
+        headers.set("Keep-Alive", `timeout=120`);
+        return new Response(this.stream, { headers });
+    }
+    keepAlive() {
+        if (!this.controller)
+            return;
+        try {
+            this.controller.enqueue("\n\n");
+        }
+        catch (e) {
+            console.error(e);
+            this.close(); // unbind on failure
+        }
+    }
+    send(type, data, timeStamp) {
+        if (!this.controller)
+            return false;
+        try {
+            this.controller.enqueue(`event: ${type}\ndata: [${data},${timeStamp}]\n\n`);
+            return true;
+        }
+        catch (e) {
+            console.error(e);
+            this.close(); // unbind on failure
+            return false;
+        }
+    }
+    isClosed() {
+        return this.controller === null;
+    }
+    close(unlink = true) {
+        clearInterval(this.timer);
+        if (!this.controller)
+            return false;
+        if (unlink) {
+            const i = register.indexOf(this);
+            if (i !== -1)
+                register.splice(i, 1);
+        }
+        try {
+            this.controller?.close();
+        }
+        catch (e) {
+            console.error(e);
+            this.controller = null;
+            return false;
+        }
+        this.controller = null;
+        return true;
+    }
+}
+// Auto close all SSE streams when shutdown requested
+// Without this graceful shutdowns will hang indefinitely
+const register = new Array();
+function CloseAll() {
+    for (const connection of register)
+        connection.close(false); // don't waste time unregistering
+}
+process.on('SIGTERM', CloseAll);
+process.on('SIGHUP', CloseAll);

package/bin/util/hash.d.ts

@@ -0,0 +1 @@
+export declare function QuickHash(input: string): string;

package/bin/util/hash.js

@@ -0,0 +1,7 @@
+export function QuickHash(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        hash = (hash * 31 + input.charCodeAt(i)) >>> 0;
+    }
+    return hash.toString(36).slice(0, 5);
+}

package/bin/util/index.d.ts

@@ -0,0 +1 @@
+export declare function MergeHeaders(base: Headers, extension: Headers, override: boolean): void;

package/bin/util/index.js

@@ -0,0 +1,7 @@
+export function MergeHeaders(base, extension, override) {
+    extension.forEach((val, key) => {
+        if (!override && base.has(key))
+            return;
+        base.set(key, val);
+    });
+}

package/bin/util/parameters.d.ts

@@ -0,0 +1,7 @@
+export type Parameterized<T extends ParameterShaper> = {
+    [K in keyof T]: ReturnType<T[K]>;
+};
+export type ParameterShaper = Record<string, (val: string) => any>;
+export declare function Parameterize<T extends ParameterShaper>(params: {
+    [key: string]: string;
+}, shape: T): Parameterized<T>;

package/bin/util/parameters.js

@@ -0,0 +1,14 @@
+export function Parameterize(params, shape) {
+    const out = {};
+    for (const key in shape) {
+        if (!(key in params))
+            console.warn(`Parameter ${key} not present in route, but defined in parameters`);
+        const func = shape[key];
+        const val = func(params[key] || "");
+        // NaN moment
+        if (func === Number && typeof val === "number" && isNaN(val))
+            throw new Error("Invalid Number");
+        out[key] = val;
+    }
+    return out;
+}

package/bin/util/shell.d.ts

@@ -0,0 +1,32 @@
+export type MetaDescriptor = {
+    charSet: "utf-8";
+} | {
+    title: string;
+} | {
+    name: string;
+    content: string;
+} | {
+    property: string;
+    content: string;
+} | {
+    httpEquiv: string;
+    content: string;
+} | {
+    "script:ld+json": LdJsonObject;
+} | {
+    tagName: "meta" | "link";
+    [name: string]: string;
+} | {
+    [name: string]: unknown;
+};
+type LdJsonObject = {
+    [Key in string]?: LdJsonValue | undefined;
+};
+type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
+type LdJsonPrimitive = string | number | boolean | null;
+type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
+export type ShellOptions = {
+    meta?: Array<MetaDescriptor>;
+} | undefined;
+export type ShellProps<T> = T & ShellOptions;
+export {};

package/bin/util/shell.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,10 +1,11 @@
 {
 	"name": "htmx-router",
-	"version": "0.2.0",
-	"description": "A remix.js style file path router for htmX websites",
+	"version": "1.0.0-alpha.1",
+	"description": "A simple SSR framework with dynamic+client islands",
 	"main": "./bin/index.js",
+	"type": "module",
 	"scripts": {
-		"build": "tsc"
+		"build": "tsc && tsc-alias"
 	},
 	"bin": {
 		"htmx-router": "bin/cli/index.js"
@@ -19,13 +20,14 @@
 		"url": "https://github.com/AjaniBilby/htmx-router/issues"
 	},
 	"homepage": "https://github.com/AjaniBilby/htmx-router#readme",
+	"dependencies": {
+		"es-module-lexer": "^1.5.4",
+		"vite": "^6.0.1"
+	},
 	"devDependencies": {
 		"@types/node": "^20.4.5",
 		"ts-node": "^10.9.1",
+		"tsc-alias": "^1.8.10",
 		"typescript": "^5.1.6"
-	},
-	"dependencies": {
-		"@kitajs/html": "^1.4.2",
-		"csstype": "^3.1.2"
 	}
 }