@senrijs/senri 0.0.0-stage → 0.1.0

package/dist/src/dev/server-timing.js

@@ -0,0 +1,45 @@
+// desc は quoted-string なので、" と \ をエスケープする
+// ヘッダーの値は ByteString(U+00FF まで)なので、ASCII の表示文字以外(日本語の名前など)は %XX にする
+// (そのまま入れると Headers.set が例外を投げて、開発モードのレスポンスが返らなくなる)
+function quote(text) {
+    const ascii = text.replace(/[^\x20-\x7e]/gu, (ch) => encodeURIComponent(ch));
+    return `"${ascii.replace(/[\\"]/g, (ch) => `\\${ch}`)}"`;
+}
+const ms = (n) => Math.max(0, n).toFixed(2);
+// timings: 外側から順(最後がいちばん内側)。inner: いちばん内側の層の名前("GET /users/:id" や "notFound")
+// 名前(metric-name)は、アプリが自分で付ける名前とぶつからないよう senri- で始める
+export function serverTimingHeader(timings, inner, total) {
+    const entries = [];
+    const last = timings.length - 1;
+    timings.forEach((t, i) => {
+        // 例外などで途中までしか通っていないと、穴が空くことがある
+        if (!t)
+            return;
+        if (i === last && t.name === inner.name) {
+            entries.push(`senri-${inner.name};desc=${quote(inner.desc)};dur=${ms(t.total)}`);
+        }
+        else {
+            entries.push(`senri-${i + 1};desc=${quote(`${i + 1}. ${t.name} (self ${ms(t.self)}ms)`)};dur=${ms(t.total)}`);
+        }
+    });
+    entries.push(`senri-total;desc="total";dur=${ms(total)}`);
+    return entries.join(", ");
+}
+// レスポンスに足す。アプリが付けた Server-Timing は残して、後ろにつなぐ
+export function withServerTiming(res, value) {
+    // 101(WebSocket のアップグレード)などは作り直すと壊れるので触らない
+    if (res.status < 200)
+        return res;
+    const current = res.headers.get("server-timing");
+    const next = current ? `${current}, ${value}` : value;
+    try {
+        res.headers.set("server-timing", next);
+        return res;
+    }
+    catch {
+        // fetch() や Response.redirect() の Response はヘッダーを変更できないので、作り直す
+        const headers = new Headers(res.headers);
+        headers.set("server-timing", next);
+        return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+    }
+}

package/dist/src/dev/source.d.ts

@@ -0,0 +1,20 @@
+import type { StackFrame } from "./stack.ts";
+export type CodeLine = {
+    num: number;
+    code: string;
+    hit: boolean;
+};
+export type CodeFrame = {
+    file: string;
+    line: number;
+    col: number;
+    lines: CodeLine[];
+    caret: string;
+    label: string;
+};
+export type ReadOptions = {
+    root?: string | null;
+    canRead?: (path: string) => boolean;
+    maxBytes?: number;
+};
+export declare function readCodeFrame(frame: StackFrame, options?: ReadOptions): Promise<CodeFrame | null>;

package/dist/src/dev/source.js

@@ -0,0 +1,106 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import * as runtime from "../runtime.js";
+const CONTEXT = 3;
+const MAX_BYTES = 1024 * 1024;
+const NODE_FS = "node:fs/promises";
+// 等幅フォントで全角(日本語など)は2文字分の幅になるので、^ の位置がずれないよう幅で数える
+function width(text) {
+    let w = 0;
+    for (const ch of text) {
+        const cp = ch.codePointAt(0);
+        const wide = (cp >= 0x1100 && cp <= 0x115f) ||
+            (cp >= 0x2e80 && cp <= 0xa4cf) ||
+            (cp >= 0xac00 && cp <= 0xd7a3) ||
+            (cp >= 0xf900 && cp <= 0xfaff) ||
+            (cp >= 0xfe30 && cp <= 0xfe4f) ||
+            (cp >= 0xff00 && cp <= 0xff60) ||
+            (cp >= 0xffe0 && cp <= 0xffe6) ||
+            cp >= 0x1f300;
+        w += wide ? 2 : 1;
+    }
+    return w;
+}
+function makeCaret(code, col) {
+    const start = Math.min(Math.max(col - 1, 0), code.length);
+    // 字下げのタブはそのままタブにしておくと、上の行とそろう
+    const before = code.slice(0, start).replace(/[^\t]/g, (ch) => " ".repeat(width(ch)));
+    const target = code.slice(start).trimEnd();
+    return before + "^".repeat(Math.max(width(target), 1));
+}
+// "a/./b/../c" → "a/c"。../ でルートの外に出るパスを見抜くため
+function normalize(path) {
+    const out = [];
+    for (const part of path.split("/")) {
+        if (part === ".")
+            continue;
+        if (part === "..")
+            out.pop();
+        else
+            out.push(part);
+    }
+    return out.join("/");
+}
+function isInside(path, root) {
+    const fold = (p) => (/^[A-Za-z]:\//.test(p) ? p.toLowerCase() : p);
+    const p = fold(normalize(path));
+    const r = fold(normalize(root)).replace(/\/$/, "");
+    return p.startsWith(`${r}/`);
+}
+export async function readCodeFrame(frame, options = {}) {
+    // 利用者のコードだけ。Senri 内部・node_modules・ランタイム内部は読まない
+    if (frame.kind !== "user" || frame.line < 1)
+        return null;
+    const root = options.root === undefined ? runtime.cwd() : options.root;
+    if (!root)
+        return null;
+    // スタックに出てきたパスでも、プロジェクトの外や node_modules の中は読まない
+    if (!isInside(frame.file, root) || normalize(frame.file).includes("/node_modules/"))
+        return null;
+    const canRead = options.canRead ?? runtime.canRead;
+    if (!canRead(frame.file))
+        return null;
+    let text;
+    try {
+        // 動的 import にしておくと、ファイルを読めない環境でも Senri 自体は読み込める
+        const fs = (await import(__rewriteRelativeImportExtension(NODE_FS)));
+        const stat = await fs.stat(frame.file);
+        if (stat.size > (options.maxBytes ?? MAX_BYTES))
+            return null;
+        text = await fs.readFile(frame.file, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const all = text.split(/\r?\n/);
+    // 最後の改行のあとの空文字は行として数えない
+    if (all.at(-1) === "")
+        all.pop();
+    if (frame.line > all.length)
+        return null;
+    const first = Math.max(1, frame.line - CONTEXT);
+    const last = Math.min(all.length, frame.line + CONTEXT);
+    const lines = [];
+    for (let num = first; num <= last; num++) {
+        lines.push({ num, code: all[num - 1], hit: num === frame.line });
+    }
+    const hitLine = all[frame.line - 1];
+    // エラーの位置の直前が "throw" か "throw new" なら、その throw で投げたエラー
+    // (V8 は "new" の位置、Bun は "Error" の位置を指すので、どちらでも当たるようにする)
+    // 行のどこかに throw があるだけでは決めない(同じ行の別の場所で起きたエラーもあるので)
+    const thrownHere = /\bthrow\s+(?:new\s+)?$/.test(hitLine.slice(0, Math.max(frame.col - 1, 0)));
+    return {
+        file: frame.file,
+        line: frame.line,
+        col: frame.col,
+        lines,
+        caret: makeCaret(hitLine, frame.col),
+        label: thrownHere ? "ここで throw" : "ここでエラー",
+    };
+}

package/dist/src/dev/stack.d.ts

@@ -0,0 +1,12 @@
+export type FrameKind = "user" | "senri" | "node_modules" | "runtime";
+export type StackFrame = {
+    fn: string;
+    file: string;
+    line: number;
+    col: number;
+    kind: FrameKind;
+};
+export type ParseOptions = {
+    senriDirs?: string[];
+};
+export declare function parseStack(stack: string, options?: ParseOptions): StackFrame[];

package/dist/src/dev/stack.js

@@ -0,0 +1,93 @@
+// err.stack(文字列)を、ページで扱いやすい { fn, file, line, col } の配列にする
+//
+// 3ランタイムとも "    at 関数名 (場所)" か "    at 場所" という V8 風の書式だが、「場所」の書き方が違う
+// - Bun:  C:\Users\me\app.ts:6:15            (Windows の生のパス)
+// - Node: file:///C:/Users/SHO%20T/app.ts:6:11 (エンコードされた file:// URL)
+// - Deno: file:///C:/Users/SHO T/app.ts:6:11   (エンコードされていない file:// URL も混ざる)
+// そこで、場所を「末尾の :行:列」から逆に読み、パスはスラッシュ区切りの絶対パスにそろえる
+// このファイルは src/dev/stack.ts(ビルド後は dist/src/dev/stack.js)にある
+// そこから2つ上がパッケージのルートで、その下の src / adapters / dist が Senri 本体
+// Cloudflare Workers のように1つのファイルにまとめられていると import.meta.url がない(またはファイルの URL でない)。
+// そのときは Senri の場所が分からないので、区別しない(どのフレームも利用者のコードとして扱う)
+function defaultSenriDirs() {
+    const here = import.meta.url;
+    // data: URL のように、相対パスを解決できない URL のこともある
+    if (typeof here !== "string" || !URL.canParse("../..", here))
+        return [];
+    const root = toPath(new URL("../..", here).href).replace(/\/$/, "");
+    // ビルド後は root が .../dist になっている
+    const pkg = root.endsWith("/dist") ? root.slice(0, -"/dist".length) : root;
+    return [`${pkg}/src`, `${pkg}/adapters`, `${pkg}/dist`];
+}
+// "file:///C:/a%20b/x.ts" や "C:\a b\x.ts" を "C:/a b/x.ts" にする
+function toPath(location) {
+    if (location.startsWith("file://")) {
+        // new URL は空白をエンコードし直すので、エンコードあり・なしのどちらでも同じ結果になる
+        const pathname = decodeURIComponent(new URL(location).pathname);
+        // Windows: "/C:/Users/..." の先頭の "/" を取る
+        return /^\/[A-Za-z]:\//.test(pathname) ? pathname.slice(1) : pathname;
+    }
+    return location.replaceAll("\\", "/");
+}
+function isRuntime(location) {
+    return /^(node|ext|bun|deno):/.test(location) || location === "native" || !location.includes("/");
+}
+// Windows はドライブ文字やフォルダ名の大文字小文字を区別しないので、そろえて比べる
+function sameOrInside(path, dir) {
+    const norm = (p) => (/^[A-Za-z]:\//.test(p) ? p.toLowerCase() : p);
+    const p = norm(path);
+    const d = norm(dir).replace(/\/$/, "");
+    return p === d || p.startsWith(`${d}/`);
+}
+function classify(file, senriDirs) {
+    if (isRuntime(file))
+        return "runtime";
+    // node_modules/senri は Senri 本体として扱いたいので、node_modules より先に見る
+    if (senriDirs.some((dir) => sameOrInside(file, dir)))
+        return "senri";
+    if (file.includes("/node_modules/"))
+        return "node_modules";
+    return "user";
+}
+// "Object.auth [as mw]" → "auth"、"async getUser" → "getUser"
+function cleanName(fn) {
+    const name = fn
+        .replace(/^async /, "")
+        .replace(/ \[as [^\]]+\]$/, "")
+        .replace(/^Object\./, "");
+    return name === "" ? "<anonymous>" : name;
+}
+// "場所" を { file, line, col } に。末尾が :行:列 でなければ行も列も 0
+function splitLocation(location) {
+    const m = /^(.*):(\d+):(\d+)$/.exec(location);
+    if (!m)
+        return { file: location, line: 0, col: 0 };
+    return { file: toPath(m[1]), line: Number(m[2]), col: Number(m[3]) };
+}
+function parseLine(line, senriDirs) {
+    const m = /^\s*at (.*)$/.exec(line);
+    if (!m)
+        return null;
+    const rest = m[1];
+    // "関数名 (場所)" の形。パスにも "(" が入りうる("Program Files (x86)")ので、
+    // 最初の " (" で切り、末尾が ")" で閉じているものだけを採用する
+    const open = rest.indexOf(" (");
+    let fn = "<anonymous>";
+    let location = rest;
+    if (open !== -1 && rest.endsWith(")")) {
+        fn = cleanName(rest.slice(0, open));
+        location = rest.slice(open + 2, -1);
+    }
+    const { file, line: lineNo, col } = splitLocation(location);
+    return { fn, file, line: lineNo, col, kind: classify(file, senriDirs) };
+}
+export function parseStack(stack, options = {}) {
+    const senriDirs = (options.senriDirs ?? defaultSenriDirs()).map((d) => d.replaceAll("\\", "/"));
+    const frames = [];
+    for (const line of stack.split("\n")) {
+        const frame = parseLine(line, senriDirs);
+        if (frame)
+            frames.push(frame);
+    }
+    return frames;
+}

package/dist/src/dev/suggest.d.ts

@@ -0,0 +1,12 @@
+export declare function distance(a: string, b: string): number;
+export type Difference = {
+    parts: {
+        text: string;
+        mark: boolean;
+    }[];
+    note: string;
+};
+export declare function explainDifference(requested: string, suggested: string): Difference;
+export declare function suggest<R extends {
+    path: string;
+}>(routes: R[], path: string): R | null;

package/dist/src/dev/suggest.js

@@ -0,0 +1,95 @@
+// dp[i][j] = a の先頭 i 文字と b の先頭 j 文字が、何回の「追加・削除・置き換え」で同じになるか
+function table(a, b) {
+    const dp = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+    return dp;
+}
+// 2つの文字列が、何回の「追加・削除・置き換え」で同じになるかを数える
+export function distance(a, b) {
+    return table(a, b)[a.length][b.length];
+}
+// リクエストされたパスと候補のパスの、どこが違うかを調べる
+// DP の表を右下(両方の最後)から左上へたどると、1文字ずつ「同じ / 足りない / 多い / 違う」が分かる
+export function explainDifference(requested, suggested) {
+    const dp = table(requested, suggested);
+    const ops = [];
+    let i = requested.length;
+    let j = suggested.length;
+    while (i > 0 || j > 0) {
+        const here = dp[i][j];
+        // 「足りない」を先に試すと、"/helo" → "/hello" で後ろの l に印が付く("/hel" + "l" + "o")
+        if (j > 0 && here === dp[i][j - 1] + 1) {
+            ops.push({ kind: "missing", ch: suggested[j - 1] });
+            j--;
+        }
+        else if (i > 0 && j > 0 && requested[i - 1] === suggested[j - 1] && here === dp[i - 1][j - 1]) {
+            ops.push({ kind: "same", ch: suggested[j - 1] });
+            i--;
+            j--;
+        }
+        else if (i > 0 && j > 0 && here === dp[i - 1][j - 1] + 1) {
+            ops.push({ kind: "changed", ch: suggested[j - 1], was: requested[i - 1] });
+            i--;
+            j--;
+        }
+        else {
+            ops.push({ kind: "extra", ch: requested[i - 1] });
+            i--;
+        }
+    }
+    ops.reverse();
+    // 候補のパスを、印あり・なしのかたまりに分ける(「多い」文字は候補にないので出てこない)
+    const parts = [];
+    for (const op of ops) {
+        if (op.kind === "extra")
+            continue;
+        const mark = op.kind !== "same";
+        const last = parts.at(-1);
+        if (last && last.mark === mark)
+            last.text += op.ch;
+        else
+            parts.push({ text: op.ch, mark });
+    }
+    const diffs = ops.filter((op) => op.kind !== "same");
+    const chars = diffs.map((op) => op.ch).join("");
+    let note;
+    if (diffs.every((op) => op.kind === "missing")) {
+        note = `"${chars}" が${diffs.length}文字足りません`;
+    }
+    else if (diffs.every((op) => op.kind === "extra")) {
+        note = `"${chars}" が${diffs.length}文字多いです`;
+    }
+    else if (diffs.length === 1 && diffs[0].kind === "changed") {
+        note = `"${diffs[0].ch}" のところが "${diffs[0].was}" になっています`;
+    }
+    else {
+        note = `${diffs.length}か所違います`;
+    }
+    return { parts, note };
+}
+const MAX_DISTANCE = 3;
+// これより長いパスはタイプミスではないと見なして計算しない(長いほど計算が重くなるので)
+const MAX_PATH_LENGTH = 200;
+// いちばん近いルートを探す(距離が3より大きければ null)
+export function suggest(routes, path) {
+    if (path.length > MAX_PATH_LENGTH)
+        return null;
+    let closest = null;
+    let best = Infinity;
+    for (const r of routes) {
+        // 長さの差がそのまま距離の下限になるので、差が大きければ計算するまでもない
+        if (Math.abs(r.path.length - path.length) > MAX_DISTANCE)
+            continue;
+        const d = distance(r.path, path);
+        if (d < best) {
+            closest = r;
+            best = d;
+        }
+    }
+    return closest && best <= MAX_DISTANCE ? closest : null;
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,23 @@
+import type { Context, HandlerResult } from "./context.ts";
+import type { Route } from "./router.ts";
+export declare class HttpError extends Error {
+    status: number;
+    headers: Headers;
+    constructor(status: number, message?: string, options?: {
+        headers?: HeadersInit;
+        cause?: unknown;
+    });
+}
+export type ConversionOrigin = {
+    kind: "handler" | "middleware";
+    name: string;
+};
+export declare function markConversionError(err: unknown, origin: ConversionOrigin): unknown;
+export declare function conversionOriginOf(err: unknown): ConversionOrigin | null;
+export type ErrorHandler<V extends object = any> = (err: unknown, c: Context<V>) => HandlerResult | Promise<HandlerResult>;
+export type NotFoundHandler<V extends object = any> = (c: Context<V>) => HandlerResult | Promise<HandlerResult>;
+export declare function handleError(err: unknown, c: Context, onError: ErrorHandler): Promise<Response>;
+export declare function defaultOnError(dev: boolean): ErrorHandler;
+export declare function methodNotAllowed(c: Context, path: string, methods: string, dev: boolean): HttpError;
+export declare function checkQueryRequest(c: Context, dev: boolean): Promise<HttpError | null>;
+export declare function defaultNotFound(routes: Route[], dev: boolean): NotFoundHandler;

package/dist/src/errors.js

@@ -0,0 +1,136 @@
+import { suggest } from "./dev/suggest.js";
+import { wantsHtml } from "./dev/render.js";
+// status 付きで投げられるエラー。message はそのままクライアントに見せる前提のもの
+export class HttpError extends Error {
+    status;
+    headers;
+    constructor(status, message, options = {}) {
+        super(message ?? `HTTP ${status}`, { cause: options.cause });
+        this.name = "HttpError";
+        this.status = status;
+        this.headers = new Headers(options.headers);
+    }
+}
+const conversionOrigins = new WeakMap();
+export function markConversionError(err, origin) {
+    if (typeof err === "object" && err !== null)
+        conversionOrigins.set(err, origin);
+    return err;
+}
+export function conversionOriginOf(err) {
+    return typeof err === "object" && err !== null ? (conversionOrigins.get(err) ?? null) : null;
+}
+// onError を通して、例外をレスポンスに変える
+// HttpError なら status と headers を先に c に入れておくので、onError が文字列を返すだけでも正しい status になる
+export async function handleError(err, c, onError) {
+    if (err instanceof HttpError) {
+        c.status(err.status);
+        err.headers.forEach((value, key) => c.header(key, value));
+    }
+    else {
+        c.status(500);
+    }
+    // ログに出すべき「本当のエラー」だけ c.error に入れる(404 や 403 はふつうの応答)
+    if (!(err instanceof HttpError) || err.status >= 500) {
+        c.error = err;
+    }
+    try {
+        return c.toResponse(await onError(err, c));
+    }
+    catch (onErrorFailed) {
+        // onError 自体が壊れていたら、もう頼れるものがないので固定の 500 を返す
+        c.error = onErrorFailed;
+        return new Response("500 Internal Server Error", { status: 500 });
+    }
+}
+// 本番では、エラーの中身(DB のパスワードなど)や、ルートの一覧がもれないよう固定の文言だけ返す
+// dev: true のときだけ、開発者向けの詳しい情報を足す
+// validate.ts を import すると循環するので、形で見分ける
+function isValidationError(err) {
+    return err.name === "ValidationError" && typeof err.describe === "function";
+}
+export function defaultOnError(dev) {
+    return (err, c) => {
+        if (err instanceof HttpError) {
+            // バリデーションのエラーは、開発モードでだけ、どこが違うかを返す
+            if (dev && isValidationError(err))
+                return c.text(err.describe());
+            return c.text(err.message);
+        }
+        if (!dev) {
+            return c.text("500 Internal Server Error");
+        }
+        return c.text(`500 Internal Server Error: ${err instanceof Error ? err.message : String(err)}`);
+    };
+}
+export function methodNotAllowed(c, path, methods, dev) {
+    const message = dev
+        ? `405 Method Not Allowed: ${c.req.method} ${path}\n${methods} ならあります`
+        : "405 Method Not Allowed";
+    return new HttpError(405, message, { headers: { allow: methods } });
+}
+// QUERY(RFC 10008)は、検索の条件をボディに入れて送るメソッド。ボディと、その形式(Content-Type)が必須
+// ハンドラーを呼ぶ前に確かめる。どちらも問題なければ null
+export async function checkQueryRequest(c, dev) {
+    if (await isEmptyBody(c)) {
+        return new HttpError(400, dev
+            ? "400 Bad Request: QUERY リクエストにボディがありません\nQUERY は、検索の条件をボディに入れて送るメソッドです"
+            : "400 Bad Request");
+    }
+    if (!c.req.headers.get("content-type")) {
+        return new HttpError(415, dev
+            ? "415 Unsupported Media Type: QUERY リクエストに Content-Type がありません\nボディの形式を指定してください(例: Content-Type: application/json)"
+            : "415 Unsupported Media Type");
+    }
+    return null;
+}
+// ボディが空か。Content-Length があればそれで決める
+// ないとき(Deno はボディがなくても空のストリームを渡す。チャンク転送のこともある)は、
+// 複製(clone)のほうを中身のあるチャンクが来るまで読んで確かめる。元の c.req はそのまま読める
+async function isEmptyBody(c) {
+    const req = c.req;
+    if (req.body === null)
+        return true;
+    const length = req.headers.get("content-length");
+    if (length !== null)
+        return length.trim() === "0";
+    // ミドルウェアが読み済みなら clone() は例外になる。読めたということは、ボディはあった
+    if (req.bodyUsed)
+        return false;
+    const reader = req.clone().body.getReader();
+    try {
+        // 長さ 0 のチャンクが来ることもある(Deno)
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return true;
+            if (value.byteLength > 0)
+                return false;
+        }
+    }
+    finally {
+        // 複製のほうはもう読まない(元のほうに、読んだ分ため込まれ続けないようにする)
+        reader.cancel().catch(() => { });
+    }
+}
+export function defaultNotFound(routes, dev) {
+    return async (c) => {
+        if (!dev) {
+            return c.text("404 Not Found");
+        }
+        // ブラウザで開いたときは、ルートの一覧付きの404ページ(HTML)にする
+        // ページの HTML は大きいので、本番では読み込まないよう、ここで初めて import() する
+        if (wantsHtml(c.req)) {
+            const { notFoundPage } = await import("./dev/not-found-page.js");
+            return notFoundPage(c, routes);
+        }
+        // ルートと同じく、デコード・正規化したパスで比べる(notFound に来るのはデコードできたリクエストだけ)
+        const path = c.path;
+        let message = `404 Not Found: ${c.req.method} ${path}`;
+        const closest = suggest(routes, path);
+        if (closest) {
+            message += `\nもしかして: ${closest.method} ${closest.path} ?`;
+        }
+        return c.text(message);
+    };
+}

package/dist/src/group.d.ts

@@ -0,0 +1,38 @@
+import type { Handler, Middleware } from "./context.ts";
+import { type ExtractParams, type Simplify } from "./router.ts";
+import { type RouteSchemas, type Validated, type ValidatedParams } from "./validate.ts";
+export declare function routeHandler(path: string, a: Handler | RouteSchemas, b: Handler | undefined): Handler;
+type GroupParams<Prefix extends string, Path extends string> = Simplify<ExtractParams<`${Prefix}/${Path}`>>;
+type GroupMethod<Prefix extends string, V extends object> = {
+    <Path extends string>(path: Path, handler: Handler<GroupParams<Prefix, Path>, V>): void;
+    <Path extends string, S extends RouteSchemas>(path: Path, schemas: S, handler: Handler<ValidatedParams<S, GroupParams<Prefix, Path>>, V, Validated<S>>): void;
+};
+export type Router<Prefix extends string = string, V extends object = any> = {
+    readonly prefix: Prefix;
+    use(pathOrMw: string | Middleware<V>, mw?: Middleware<V>): void;
+    get: GroupMethod<Prefix, V>;
+    post: GroupMethod<Prefix, V>;
+    put: GroupMethod<Prefix, V>;
+    patch: GroupMethod<Prefix, V>;
+    delete: GroupMethod<Prefix, V>;
+    all: GroupMethod<Prefix, V>;
+    head: GroupMethod<Prefix, V>;
+    options: GroupMethod<Prefix, V>;
+    on<Path extends string>(method: string | readonly string[], path: Path, handler: Handler<GroupParams<Prefix, Path>, V>): void;
+    on<Path extends string, S extends RouteSchemas>(method: string | readonly string[], path: Path, schemas: S, handler: Handler<ValidatedParams<S, GroupParams<Prefix, Path>>, V, Validated<S>>): void;
+    route(router: Router<string, V>): void;
+};
+export type GroupEntry = {
+    kind: "route";
+    method: string;
+    path: string;
+    handler: Handler;
+} | {
+    kind: "use";
+    path: string;
+    mw: Middleware;
+};
+export declare function joinPath(...parts: string[]): string;
+export declare function groupEntries(router: Router): GroupEntry[];
+export declare function createRouter<Prefix extends string, V extends object = Record<string, unknown>>(prefix: Prefix): Router<Prefix, V>;
+export {};