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

package/request/http.js

@@ -1,59 +0,0 @@
-import { Resolve } from "~/request/native.js";
-export function createRequestHandler(config) {
-    return async (req, res) => {
-        try {
-            const mod = typeof config.build === "function" ? await config.build() : await config.build;
-            const request = NativeRequest(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));
-            }
-        }
-    };
-}
-function NativeRequest(req) {
-    const ctrl = new AbortController();
-    const headers = new Headers(req.headers);
-    const url = new URL(`http://${headers.get('host')}${req.originalUrl || req.url}`);
-    req.once('aborted', () => ctrl.abort());
-    const bodied = req.method !== "GET" && req.method !== "HEAD";
-    const request = new Request(url, {
-        headers,
-        method: req.method,
-        body: bodied ? req : undefined,
-        signal: ctrl.signal,
-        referrer: headers.get("referrer") || undefined,
-        // @ts-ignore
-        duplex: bodied ? 'half' : undefined
-    });
-    if (!request.headers.has("X-Real-IP")) {
-        const info = req.socket.address();
-        if ("address" in info)
-            request.headers.set("X-Real-IP", info.address);
-    }
-    return request;
-}

package/request/index.d.ts

@@ -1,13 +0,0 @@
-import type { ViteDevServer } from "vite";
-import type { GenericContext, RouteTree } from '~/router.js';
-import * as native from "~/request/native.js";
-import * as http from "~/request/http.js";
-export type Config = {
-    build: Promise<any> | (() => Promise<Record<string, any>>);
-    viteDevServer: ViteDevServer | null;
-    render: GenericContext["render"];
-};
-export type RouterModule = {
-    tree: RouteTree;
-};
-export { http, native };

package/request/index.js

@@ -1,3 +0,0 @@
-import * as native from "~/request/native.js";
-import * as http from "~/request/http.js";
-export { http, native };

package/request/native.d.ts

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

package/request/native.js

@@ -1,46 +0,0 @@
-import { GenericContext } from '~/router.js';
-export function createRequestHandler(config) {
-    return async (req) => {
-        try {
-            const mod = typeof config.build === "function" ? await config.build() : await config.build;
-            let { response } = await Resolve(req, mod.tree, config);
-            return response;
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                console.error(e.stack);
-                config.viteDevServer?.ssrFixStacktrace(e);
-                return new Response(e.message + "\n" + e.stack, { status: 500, statusText: "Internal Server Error" });
-            }
-            else {
-                console.error(e);
-                return new Response(String(e), { status: 500, statusText: "Internal Server Error" });
-            }
-        }
-    };
-}
-export async function Resolve(request, tree, config) {
-    const url = new URL(request.url);
-    const ctx = new GenericContext(request, url, config.render);
-    const x = ctx.url.pathname.endsWith("/") ? ctx.url.pathname.slice(0, -1) : ctx.url.pathname;
-    const fragments = x.split("/").slice(1);
-    let response = await tree.resolve(fragments, ctx);
-    if (response === null)
-        response = new Response("No Route Found", { status: 404, statusText: "Not Found", headers: ctx.headers });
-    // Override with context headers
-    if (response.headers !== ctx.headers) {
-        for (const [key, value] of ctx.headers) {
-            if (response.headers.has(key))
-                continue;
-            response.headers.set(key, value);
-        }
-    }
-    // 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 };
-}

package/response.d.ts

@@ -1,13 +0,0 @@
-export declare function text(text: string, init?: ResponseInit): Response;
-export type TypedResponse<T> = Omit<Response, "json"> & {
-    json(): Promise<T>;
-};
-export type TypedJson<U extends TypedResponse<any>> = U extends TypedResponse<infer T> ? T : never;
-export declare function json<T>(data: T, init?: ResponseInit): TypedResponse<T>;
-export declare function redirect(url: string, init?: ResponseInit & {
-    clientOnly?: boolean;
-}): Response;
-export declare function revalidate(init?: ResponseInit): Response;
-export declare function refresh(init?: ResponseInit & {
-    clientOnly?: boolean;
-}): Response;

package/response.js

@@ -1,46 +0,0 @@
-export function text(text, init) {
-    init ||= {};
-    init.statusText ||= "ok";
-    init.status ||= 200;
-    const res = new Response(text, init);
-    res.headers.set("Content-Type", "text/plain");
-    res.headers.set("X-Caught", "true");
-    return res;
-}
-export function json(data, init) {
-    init ||= {};
-    init.statusText ||= "ok";
-    init.status ||= 200;
-    const res = new Response(JSON.stringify(data), init);
-    res.headers.set("Content-Type", "application/json");
-    res.headers.set("X-Caught", "true");
-    return res;
-}
-export function redirect(url, init) {
-    init ||= {};
-    init.statusText ||= "Temporary Redirect";
-    init.status ||= 307;
-    const res = new Response("", init);
-    if (!init?.clientOnly)
-        res.headers.set("Location", url);
-    res.headers.set("HX-Location", url); // use hx-boost if applicable
-    return res;
-}
-export function revalidate(init) {
-    init ||= {};
-    init.statusText ||= "ok";
-    init.status ||= 200;
-    const res = new Response("", init);
-    res.headers.set("HX-Location", "");
-    return res;
-}
-export function refresh(init) {
-    init ||= {};
-    init.statusText ||= "ok";
-    init.status ||= 200;
-    const res = new Response("", init);
-    if (!init?.clientOnly)
-        res.headers.set("Refresh", "0"); // fallback
-    res.headers.set("HX-Refresh", "true");
-    return res;
-}

package/router.d.ts

@@ -1,51 +0,0 @@
-import { Parameterized, ParameterShaper } from './util/parameters.js';
-import { RouteModule } from "./index.js";
-import { Cookies } from './cookies.js';
-export declare function GenerateRouteTree(modules: Record<string, unknown>): RouteTree;
-export declare class GenericContext {
-    request: Request;
-    headers: Headers;
-    cookie: Cookies;
-    params: {
-        [key: string]: string;
-    };
-    url: URL;
-    render: (res: JSX.Element) => Response;
-    constructor(request: GenericContext["request"], url: GenericContext["url"], renderer: GenericContext["render"]);
-    shape<T extends ParameterShaper>(shape: T): RouteContext<T>;
-}
-export declare class RouteContext<T extends ParameterShaper = {}> {
-    request: Request;
-    headers: Headers;
-    cookie: Cookies;
-    params: Parameterized<T>;
-    url: URL;
-    render: (res: JSX.Element) => Response;
-    constructor(base: GenericContext, shape: T);
-}
-export declare class RouteTree {
-    root: boolean;
-    nested: Map<string, RouteTree>;
-    index: RouteLeaf | null;
-    slug: RouteLeaf | null;
-    wild: RouteTree | null;
-    wildCard: string;
-    constructor(root?: boolean);
-    ingest(path: string | string[], module: RouteModule<any>): void;
-    resolve(fragments: string[], ctx: GenericContext): Promise<Response | null>;
-    private _resolve;
-    private resolveIndex;
-    private resolveNext;
-    private resolveWild;
-    private resolveSlug;
-    private resolveNative;
-    private unwrap;
-}
-declare class RouteLeaf {
-    module: RouteModule<any>;
-    constructor(module: RouteModule<any>);
-    resolve(ctx: GenericContext): Promise<Response | null>;
-    error(ctx: GenericContext, e: unknown): Promise<Response>;
-    private renderWrapper;
-}
-export {};

package/router.js

@@ -1,231 +0,0 @@
-import { ServerOnlyWarning } from "./internal/util.js";
-ServerOnlyWarning("router");
-import * as endpoint from './endpoint.js';
-import * as dynamic from './dynamic.js';
-import * as mount from './internal/mount.js';
-import * as css from './css.js';
-import { Parameterize } from './util/parameters.js';
-import { Cookies } from './cookies.js';
-export function GenerateRouteTree(modules) {
-    const tree = new RouteTree();
-    for (const path in modules) {
-        const mod = modules[path];
-        const tail = path.lastIndexOf(".");
-        const url = path.slice(9, tail);
-        tree.ingest(url, mod);
-        if (mod.route)
-            mod.route(url);
-    }
-    return tree;
-}
-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 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;
-    }
-}
-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;
-    }
-}
-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/shell.d.ts

@@ -1,120 +0,0 @@
-export type ShellOptions<D = {}> = D & MetaDescriptor;
-export declare function ApplyMetaDescriptorDefaults(options: ShellOptions, defaults: Readonly<Partial<ShellOptions>>): void;
-export type InferShellOptions<F> = F extends (jsx: any, options: infer U) => any ? U : never;
-export type MetaDescriptor = {
-    title?: string;
-    description?: string;
-    meta?: Record<string, string>;
-    og?: OpenGraph<string>;
-    jsonLD?: LdJsonObject[];
-};
-export declare function RenderMetaDescriptor<T>(options: ShellOptions<T>): string;
-export 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 OpenGraphType = "website" | "article" | "book" | "profile" | "music.song" | "music.album" | "music.playlist" | "music.radio_station" | "video.movie" | "video.episode" | "video.tv_show" | "video.other" | string;
-export type OpenGraph<T extends OpenGraphType = string> = {
-    type?: T;
-    title?: string;
-    description?: string;
-    determiner?: string;
-    url?: string;
-    secure_url?: string;
-    locale?: string | {
-        base: string;
-        alternative: string[];
-    };
-    image?: OpenGraphImage[];
-    video?: OpenGraphVideo[];
-    audio?: OpenGraphAudio[];
-} & (T extends "music.song" ? OpenGraphSong : T extends "music.album" ? OpenGraphAlbum : T extends "music.playlist" ? OpenGraphPlaylist : T extends "music.radio_station" ? OpenGraphRadioStation : T extends "video.movie" ? OpenGraphMovie : T extends "video.episode" ? OpenGraphEpisode : T extends "video.tv_show" ? OpenGraphTvShow : T extends "video.other" ? OpenGraphVideoOther : T extends "article" ? OpenGraphArticle : T extends "book" ? OpenGraphBook : T extends "profile" ? OpenGraphProfile : {});
-export type OpenGraphImage = {
-    url: string;
-    secure_url?: string;
-    type?: string;
-    width?: number;
-    height?: number;
-    alt?: string;
-};
-export type OpenGraphVideo = {
-    url: string;
-    type?: string;
-    secure_url?: string;
-    width?: number;
-    height?: number;
-    alt?: string;
-};
-export type OpenGraphAudio = {
-    url: string;
-    type?: string;
-    secure_url?: string;
-};
-type OpenGraphSong = {
-    duration?: number;
-    album?: Array<string | {
-        url: string;
-        disc?: number;
-        track?: number;
-    }>;
-    musician?: string[];
-};
-type OpenGraphAlbum = {
-    songs?: Array<string | {
-        url: string;
-        disc?: number;
-        track?: number;
-    }>;
-    musician?: string[];
-    release_date?: Date;
-};
-type OpenGraphPlaylist = {
-    songs?: Array<string | {
-        url: string;
-        disc?: number;
-        track?: number;
-    }>;
-    creator?: string[];
-};
-type OpenGraphRadioStation = {
-    creator?: string[];
-};
-type OpenGraphMovie = {
-    actors?: Array<string | {
-        url: string;
-        role: string;
-    }>;
-    directors?: string[];
-    writers?: string[];
-    duration?: number;
-    release_date?: Date;
-    tag: string[];
-};
-type OpenGraphEpisode = OpenGraphMovie & {
-    series?: string;
-};
-type OpenGraphTvShow = OpenGraphMovie;
-type OpenGraphVideoOther = OpenGraphMovie;
-type OpenGraphArticle = {
-    published_time?: Date;
-    modified_time?: Date;
-    expiration_time?: Date;
-    authors?: string[];
-    section?: string;
-    tag?: string;
-};
-type OpenGraphBook = {
-    authors?: string[];
-    isbn?: string;
-    release_date?: Date;
-    tag?: string;
-};
-type OpenGraphProfile = {
-    first_name?: string;
-    last_name?: string;
-    username?: string;
-    gender?: "male" | "female";
-};
-export {};