htmx-router 1.0.0-alpha.5 → 1.0.0-pre1

package/bin/router.js

@@ -1,217 +0,0 @@
-import * as endpoint from './util/endpoint.js';
-import * as dynamic from './util/dynamic.js';
-import * as mount from './client/mount.js';
-import * as css from './util/css.js';
-import { Parameterize } from './util/parameters.js';
-import { Cookies } from './util/cookies.js';
-export class GenericContext {
-    request;
-    headers; // response headers
-    cookie;
-    params;
-    url;
-    render;
-    constructor(request, url, renderer) {
-        this.cookie = new Cookies(request.headers);
-        this.headers = new Headers();
-        this.request = request;
-        this.params = {};
-        this.url = url;
-        this.render = renderer;
-        this.headers.set("x-powered-by", "htmx-router");
-    }
-    shape(shape) {
-        return new RouteContext(this, shape);
-    }
-}
-export class RouteContext {
-    request;
-    headers; // response headers
-    cookie;
-    params;
-    url;
-    render;
-    constructor(base, shape) {
-        this.params = Parameterize(base.params, shape);
-        this.cookie = base.cookie;
-        this.headers = base.headers;
-        this.request = base.request;
-        this.render = base.render;
-        this.url = base.url;
-    }
-}
-export class RouteLeaf {
-    module;
-    constructor(module) {
-        this.module = module;
-    }
-    async resolve(ctx) {
-        const res = await this.renderWrapper(ctx);
-        if (res === null)
-            return null;
-        if (res instanceof Response)
-            return res;
-        return ctx.render(res);
-    }
-    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 ctx.render(res);
-    }
-    async renderWrapper(ctx) {
-        try {
-            if (!this.module.loader && !this.module.action)
-                return null;
-            const context = ctx.shape(this.module.parameters || {});
-            if (ctx.request.method === "HEAD" || ctx.request.method === "GET") {
-                if (this.module.loader)
-                    return await this.module.loader(context);
-                else
-                    return null;
-            }
-            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 });
-        }
-        catch (e) {
-            return await this.error(ctx, e);
-        }
-        return null;
-    }
-}
-export class RouteTree {
-    root;
-    nested;
-    // Leaf nodes
-    index; // about._index
-    // Wild card route
-    slug; // $
-    wild; // e.g. $userID
-    wildCard;
-    constructor(root = true) {
-        this.root = root;
-        this.nested = new Map();
-        this.wildCard = "";
-        this.slug = null;
-        this.wild = null;
-        this.index = null;
-    }
-    ingest(path, module) {
-        if (!Array.isArray(path))
-            path = path.split("/");
-        if (path.length === 0 || (path.length == 1 && path[0] === "_index")) {
-            this.index = new RouteLeaf(module);
-            return;
-        }
-        if (path[0] === "$") {
-            this.slug = new RouteLeaf(module);
-            return;
-        }
-        if (path[0][0] === "$") {
-            const wildCard = path[0].slice(1);
-            // Check wildcard isn't being changed
-            if (!this.wild) {
-                this.wildCard = wildCard;
-                this.wild = new RouteTree(false);
-            }
-            else if (wildCard !== this.wildCard) {
-                throw new Error(`Redefinition of wild card ${this.wildCard} to ${wildCard}`);
-            }
-            path.splice(0, 1);
-            this.wild.ingest(path, module);
-            return;
-        }
-        let next = this.nested.get(path[0]);
-        if (!next) {
-            next = new RouteTree(false);
-            this.nested.set(path[0], next);
-        }
-        path.splice(0, 1);
-        next.ingest(path, module);
-    }
-    async resolve(fragments, ctx) {
-        if (!this.slug)
-            return await this._resolve(fragments, ctx);
-        try {
-            return await this._resolve(fragments, ctx);
-        }
-        catch (e) {
-            return this.unwrap(ctx, e);
-        }
-    }
-    async _resolve(fragments, ctx) {
-        let res = await this.resolveNative(fragments, ctx)
-            || await this.resolveIndex(fragments, ctx)
-            || await this.resolveNext(fragments, ctx)
-            || await this.resolveWild(fragments, ctx)
-            || await this.resolveSlug(fragments, ctx);
-        if (res instanceof Response) {
-            if (100 <= res.status && res.status <= 399)
-                return res;
-            if (res.headers.has("X-Caught"))
-                return res;
-            return this.unwrap(ctx, res);
-        }
-        return res;
-    }
-    async resolveIndex(fragments, ctx) {
-        if (fragments.length > 0)
-            return null;
-        if (!this.index)
-            return null;
-        return await this.index.resolve(ctx);
-    }
-    async resolveNext(fragments, ctx) {
-        if (fragments.length < 1)
-            return null;
-        const next = this.nested.get(fragments[0]);
-        if (!next)
-            return null;
-        return await next.resolve(fragments.slice(1), ctx);
-    }
-    async resolveWild(fragments, ctx) {
-        if (!this.wild)
-            return null;
-        if (fragments.length < 1)
-            return null;
-        ctx.params[this.wildCard] = fragments[0];
-        return this.wild.resolve(fragments.slice(1), ctx);
-    }
-    async resolveSlug(fragments, ctx) {
-        if (!this.slug)
-            return null;
-        ctx.params["$"] = fragments.join("/");
-        const res = this.slug.resolve
-            ? await this.slug.resolve(ctx)
-            : null;
-        return res;
-    }
-    async resolveNative(fragments, ctx) {
-        if (!this.root)
-            return null;
-        if (fragments.length < 2)
-            return null;
-        if (fragments[0] != "_")
-            return null;
-        return await ResolveNatively(fragments, ctx);
-    }
-    async unwrap(ctx, res) {
-        if (!this.slug)
-            throw res;
-        const caught = await this.slug.error(ctx, res);
-        caught.headers.set("X-Caught", "true");
-        return caught;
-    }
-}
-async function ResolveNatively(fragments, ctx) {
-    switch (fragments[1]) {
-        case "dynamic": return dynamic._resolve(fragments, ctx);
-        case "endpoint": return endpoint._resolve(fragments, ctx);
-        case "mount": return mount._resolve(fragments);
-        case "style": return css._resolve(fragments);
-    }
-    return null;
-}

package/bin/types.d.ts

@@ -1,10 +0,0 @@
-import { ParameterShaper } from "./util/parameters.js";
-import { RouteContext } from "./router.js";
-export type CatchFunction<T> = (args: T, err: unknown) => Promise<Response | JSX.Element>;
-export type RenderFunction<T> = (args: T) => Promise<Response | JSX.Element | null>;
-export type RouteModule<T extends ParameterShaper> = {
-    parameters?: T;
-    loader?: RenderFunction<RouteContext<T>>;
-    action?: RenderFunction<RouteContext<T>>;
-    error?: CatchFunction<RouteContext<T>>;
-};

package/bin/types.js

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

package/bin/util/cookies.d.ts

@@ -1,25 +0,0 @@
-export interface CookieOptions {
-    domain?: string | undefined;
-    expires?: Date;
-    httpOnly?: boolean;
-    maxAge?: number;
-    partitioned?: boolean;
-    path?: string;
-    priority?: "low" | "medium" | "high";
-    sameSite?: "lax" | "strict" | "none";
-    secure?: boolean;
-}
-/**
- * Helper provided in the Generic and RouteContext which provides reading and updating cookies
- */
-export declare class Cookies {
-    private map;
-    private config;
-    constructor(headers: Headers);
-    get(name: string): string | null;
-    has(name: string): boolean;
-    set(name: string, value: string, options?: CookieOptions): void;
-    flash(name: string, value: string): void;
-    unset(name: string): void;
-    export(): string[];
-}

package/bin/util/cookies.js

@@ -1,60 +0,0 @@
-/**
- * Helper provided in the Generic and RouteContext which provides reading and updating cookies
- */
-export class Cookies {
-    map;
-    config;
-    constructor(headers) {
-        this.config = {};
-        this.map = {};
-        const cookie = headers.get("Cookie");
-        if (!cookie)
-            return;
-        for (const line of cookie.split("; ")) {
-            const [name, value] = line.split("=");
-            this.map[name] = value;
-        }
-    }
-    get(name) {
-        return this.map[name] || null;
-    }
-    has(name) {
-        return name in this.map;
-    }
-    set(name, value, options = {}) {
-        if (!options['path'])
-            options['path'] = "/";
-        this.config[name] = options;
-        this.map[name] = value;
-    }
-    flash(name, value) {
-        return this.set(name, value, { maxAge: 0 });
-    }
-    unset(name) {
-        return this.set(name, "", { maxAge: 0 });
-    }
-    export() {
-        const headers = new Array();
-        for (const name in this.config) {
-            let config = "";
-            for (const opt in this.config[name]) {
-                const prop = opt === "maxAge"
-                    ? "Max-Age"
-                    : opt[0].toUpperCase() + opt.slice(1);
-                const raw = this.config[name][opt];
-                if (raw === true) {
-                    config += `; ${prop}`;
-                    continue;
-                }
-                if (raw === false)
-                    continue;
-                let value = String(raw);
-                value = value[0].toUpperCase() + value.slice(1);
-                config += `; ${prop}=${value}`;
-            }
-            const cookie = name + "=" + this.map[name] + config + ";";
-            headers.push(cookie);
-        }
-        return headers;
-    }
-}

package/bin/util/css.d.ts

@@ -1,13 +0,0 @@
-/**
- * Create a new css class to be included in the sheet
- * Use .this as your class name in the source, and it will be replaced with a unique name
- */
-export declare class StyleClass {
-    readonly name: string;
-    readonly style: string;
-    readonly hash: string;
-    constructor(name: string, style: string);
-    toString(): string;
-}
-export declare function GetSheetUrl(): string;
-export declare function _resolve(fragments: string[]): Response | null;

package/bin/util/css.js

@@ -1,55 +0,0 @@
-import { QuickHash } from "../util/hash.js";
-const classNamePattern = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
-const registry = new Map();
-let cache = null;
-/**
- * Create a new css class to be included in the sheet
- * Use .this as your class name in the source, and it will be replaced with a unique name
- */
-export class StyleClass {
-    name; // unique name generated based on the original name and hash of the style
-    style; // the mutated source
-    hash;
-    constructor(name, style) {
-        if (!name.match(classNamePattern))
-            throw new Error("Cannot use given name for CSS class");
-        this.hash = QuickHash(style);
-        this.name = `${name}-${this.hash}`;
-        style = style.replaceAll(".this", "." + this.name);
-        this.style = style;
-        registry.set(this.name, this);
-        cache = null;
-    }
-    toString() {
-        return this.name;
-    }
-}
-function GetSheet() {
-    return cache || BuildSheet();
-}
-export function GetSheetUrl() {
-    const sheet = GetSheet();
-    return `/_/style/${sheet.hash}.css`;
-}
-export function _resolve(fragments) {
-    if (!fragments[2])
-        return null;
-    const build = GetSheet();
-    if (!fragments[2].startsWith(build.hash))
-        return null;
-    const headers = new Headers();
-    headers.set("Content-Type", "text/css");
-    headers.set("Cache-Control", "public, max-age=604800");
-    return new Response(build.sheet, { headers });
-}
-function BuildSheet() {
-    let composite = "";
-    let sheet = "";
-    for (const [key, def] of registry) {
-        composite += key;
-        sheet += def.style;
-    }
-    const hash = QuickHash(composite);
-    cache = { hash, sheet };
-    return cache;
-}

package/bin/util/dynamic.d.ts

@@ -1,8 +0,0 @@
-/**
- * This whole file is only for internal use but the generated router for the <Dynamic> component
- */
-import { GenericContext } from "../router.js";
-export declare function DynamicReference<T extends Record<string, string>>(loader: Loader<T>, params?: T): string;
-type Loader<T> = (ctx: GenericContext, params: T) => Promise<JSX.Element>;
-export declare function _resolve(fragments: string[], ctx: GenericContext): Promise<Response | null>;
-export {};

package/bin/util/dynamic.js

@@ -1,40 +0,0 @@
-/**
- * This whole file is only for internal use but the generated router for the <Dynamic> component
- */
-import { QuickHash } from "../util/hash.js";
-const registry = new Map();
-const index = new Map();
-function Register(load) {
-    const existing = index.get(load);
-    if (existing)
-        return existing;
-    const hash = QuickHash(String(load));
-    const name = `${encodeURIComponent(load.name)}-${hash}`;
-    registry.set(name, load);
-    const url = `/_/dynamic/${name}`;
-    index.set(load, url);
-    return url;
-}
-export function DynamicReference(loader, params) {
-    let url = Register(loader);
-    if (params) {
-        const query = new URLSearchParams();
-        if (params)
-            for (const key in params)
-                query.set(key, params[key]);
-        url += "?" + query.toString();
-    }
-    return url;
-}
-export async function _resolve(fragments, ctx) {
-    if (!fragments[2])
-        return null;
-    const endpoint = registry.get(fragments[2]);
-    if (!endpoint)
-        return null;
-    const props = {};
-    for (const [key, value] of ctx.url.searchParams)
-        props[key] = value;
-    ctx.headers.set("X-Partial", "true");
-    return ctx.render(await endpoint(ctx, props));
-}

package/bin/util/endpoint.d.ts

@@ -1,13 +0,0 @@
-import { RenderFunction } from "../types.js";
-import { GenericContext } from "../router.js";
-/**
- * Create a route-less endpoint
- * The name is optional and will be inferred from the function if not given (helpful for network waterfalls)
- */
-export declare class Endpoint {
-    readonly render: RenderFunction<GenericContext>;
-    readonly name: string;
-    readonly url: string;
-    constructor(render: RenderFunction<GenericContext>, name?: string);
-}
-export declare function _resolve(fragments: string[], ctx: GenericContext): Promise<Response | null>;

package/bin/util/endpoint.js

@@ -1,32 +0,0 @@
-import { QuickHash } from "../util/hash.js";
-const registry = new Map();
-/**
- * Create a route-less endpoint
- * The name is optional and will be inferred from the function if not given (helpful for network waterfalls)
- */
-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

@@ -1,16 +0,0 @@
-/**
- * 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 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

@@ -1,85 +0,0 @@
-/**
- * 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 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

@@ -1,4 +0,0 @@
-/**
- * Not the best hash in the world, but it's something really fast that will work on all JS runtimes
- */
-export declare function QuickHash(input: string): string;

package/bin/util/hash.js

@@ -1,10 +0,0 @@
-/**
- * Not the best hash in the world, but it's something really fast that will work on all JS runtimes
- */
-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

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

package/bin/util/index.js

@@ -1,7 +0,0 @@
-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

@@ -1,10 +0,0 @@
-/**
- * This is used by GenericContext to convert itself to a RouteContext<T>
- */
-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

@@ -1,17 +0,0 @@
-/**
- * This is used by GenericContext to convert itself to a RouteContext<T>
- */
-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/path-builder.d.ts

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