hono 1.2.0 → 1.3.0

package/dist/context.test.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const context_1 = require("./context");
+describe('Context', () => {
+    const req = new Request('http://localhost/');
+    let c;
+    beforeEach(() => {
+        c = new context_1.Context(req);
+    });
+    it('c.text()', async () => {
+        const res = c.text('text in c', 201, { 'X-Custom': 'Message' });
+        expect(res.status).toBe(201);
+        expect(res.headers.get('Content-Type')).toBe('text/plain; charset=UTF-8');
+        expect(await res.text()).toBe('text in c');
+        expect(res.headers.get('X-Custom')).toBe('Message');
+    });
+    it('c.json()', async () => {
+        const res = c.json({ message: 'Hello' }, 201, { 'X-Custom': 'Message' });
+        expect(res.status).toBe(201);
+        expect(res.headers.get('Content-Type')).toMatch('application/json; charset=UTF-8');
+        const text = await res.text();
+        expect(text).toBe('{"message":"Hello"}');
+        expect(res.headers.get('X-Custom')).toBe('Message');
+    });
+    it('c.json() with c.pretty(true)', async () => {
+        c.pretty(true);
+        const res = c.json({ message: 'Hello' });
+        const text = await res.text();
+        expect(text).toBe(`{
+  "message": "Hello"
+}`);
+    });
+    it('c.json() with c.pretty(true, 4)', async () => {
+        c.pretty(true, 4);
+        const res = c.json({ message: 'Hello' });
+        const text = await res.text();
+        expect(text).toBe(`{
+    "message": "Hello"
+}`);
+    });
+    it('c.html()', async () => {
+        const res = c.html('<h1>Hello! Hono!</h1>', 201, { 'X-Custom': 'Message' });
+        expect(res.status).toBe(201);
+        expect(res.headers.get('Content-Type')).toMatch('text/html');
+        expect(await res.text()).toBe('<h1>Hello! Hono!</h1>');
+        expect(res.headers.get('X-Custom')).toBe('Message');
+    });
+    it('c.redirect()', async () => {
+        let res = c.redirect('/destination');
+        expect(res.status).toBe(302);
+        expect(res.headers.get('Location')).toMatch(/^https?:\/\/.+\/destination$/);
+        res = c.redirect('https://example.com/destination');
+        expect(res.status).toBe(302);
+        expect(res.headers.get('Location')).toBe('https://example.com/destination');
+    });
+    it('c.header()', async () => {
+        c.header('X-Foo', 'Bar');
+        const res = c.body('Hi');
+        const foo = res.headers.get('X-Foo');
+        expect(foo).toBe('Bar');
+    });
+    it('c.status() and c.statusText()', async () => {
+        c.status(201);
+        const res = c.body('Hi');
+        expect(res.status).toBe(201);
+        expect(res.statusText).toBe('Created');
+    });
+    it('Complex pattern', async () => {
+        c.status(404);
+        const res = c.json({ hono: 'great app' });
+        expect(res.status).toBe(404);
+        expect(res.statusText).toBe('Not Found');
+        expect(res.headers.get('Content-Type')).toMatch('application/json; charset=UTF-8');
+        const obj = await res.json();
+        expect(obj['hono']).toBe('great app');
+    });
+    it('Has headers, status, and statusText', async () => {
+        c.header('X-Custom1', 'Message1');
+        c.header('X-Custom2', 'Message2');
+        c.status(200);
+        const res = c.newResponse('this is body', {
+            status: 201,
+            headers: {
+                'X-Custom3': 'Message3',
+                'X-Custom2': 'Message2-Override',
+            },
+        });
+        expect(res.headers.get('X-Custom1')).toBe('Message1');
+        expect(res.headers.get('X-Custom2')).toBe('Message2-Override');
+        expect(res.headers.get('X-Custom3')).toBe('Message3');
+        expect(res.status).toBe(201);
+        expect(await res.text()).toBe('this is body');
+        // res is already set.
+        c.res = res;
+        c.header('X-Custom4', 'Message4');
+        c.status(202);
+        expect(c.res.headers.get('X-Custom4')).toBe('Message4');
+        expect(c.res.status).toBe(201);
+        expect(c.res.statusText).toBe('OK');
+    });
+    it('Should return 200 response', async () => {
+        const res = c.text('Text');
+        expect(res.status).toBe(200);
+        expect(res.statusText).toBe('OK');
+    });
+    it('Should be able read env', async () => {
+        const req = new Request('http://localhost/');
+        const key = 'a-secret-key';
+        const ctx = new context_1.Context(req, {
+            env: {
+                API_KEY: key,
+            },
+            res: null,
+            event: null,
+        });
+        expect(ctx.env.API_KEY).toBe(key);
+    });
+    it('set and set', async () => {
+        const ctx = new context_1.Context(req);
+        expect(ctx.get('k-foo')).toEqual(undefined);
+        ctx.set('k-foo', 'v-foo');
+        expect(ctx.get('k-foo')).toEqual('v-foo');
+        expect(ctx.get('k-bar')).toEqual(undefined);
+        ctx.set('k-bar', { k: 'v' });
+        expect(ctx.get('k-bar')).toEqual({ k: 'v' });
+    });
+});

package/dist/hono.d.ts

@@ -2,15 +2,23 @@
 import { Context } from './context';
 import type { Env } from './context';
 import type { Router } from './router';
-import { METHOD_NAME_ALL_LOWERCASE } from './router';
 declare global {
-    interface Request<ParamKeyType = string> {
-        param: (key: ParamKeyType) => string;
-        query: (key: string) => string;
-        header: (name: string) => string;
+    interface Request<ParamKeyType extends string = string> {
+        param: {
+            (key: ParamKeyType): string;
+            (): Record<ParamKeyType, string>;
+        };
+        query: {
+            (key: string): string;
+            (): Record<string, string>;
+        };
+        header: {
+            (name: string): string;
+            (): Record<string, string>;
+        };
     }
 }
-export declare type Handler<RequestParamKeyType = string, E = Env> = (c: Context<RequestParamKeyType, E>, next?: Next) => Response | Promise<Response> | void | Promise<void>;
+export declare type Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | void | Promise<void>;
 export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response;
 export declare type ErrorHandler<E = Env> = (err: Error, c: Context<string, E>) => Response;
 export declare type Next = () => Promise<void>;
@@ -23,29 +31,11 @@ interface HandlerInterface<T extends string, E = Env, U = Hono<E, T>> {
     <Path extends string>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
     (...handlers: Handler<string, E>[]): U;
 }
-declare const methods: readonly ["get", "post", "put", "delete", "head", "options", "patch"];
-declare type Methods = typeof methods[number] | typeof METHOD_NAME_ALL_LOWERCASE;
-interface Routing<E extends Env> {
+interface Route<E extends Env> {
     path: string;
-    method: Methods;
+    method: string;
     handler: Handler<string, E>;
 }
-declare const Route_base: new <E_1 extends Env, T extends string, U>() => {
-    delete: HandlerInterface<T, E_1, U>;
-    get: HandlerInterface<T, E_1, U>;
-    all: HandlerInterface<T, E_1, U>;
-    post: HandlerInterface<T, E_1, U>;
-    put: HandlerInterface<T, E_1, U>;
-    head: HandlerInterface<T, E_1, U>;
-    options: HandlerInterface<T, E_1, U>;
-    patch: HandlerInterface<T, E_1, U>;
-};
-export declare class Route<E = Env, P extends string = ''> extends Route_base<E, P, Route<E, P>> {
-    #private;
-    routes: Routing<E>[];
-    constructor();
-    private add;
-}
 declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
     delete: HandlerInterface<T, E_1, U>;
     get: HandlerInterface<T, E_1, U>;
@@ -56,17 +46,19 @@ declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
     options: HandlerInterface<T, E_1, U>;
     patch: HandlerInterface<T, E_1, U>;
 };
-export declare class Hono<E = Env, P extends string = ''> extends Hono_base<E, P, Hono<E, P>> {
-    #private;
+export declare class Hono<E = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
     readonly routerClass: {
         new (): Router<any>;
     };
     readonly strict: boolean;
+    private _router;
+    private _tempPath;
     private path;
+    routes: Route<E>[];
     constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
-    route(path: string, route?: Route): Hono<E, P>;
+    route(path: string, app?: Hono<any>): Hono<E, P>;
     use(path: string, ...middleware: Handler<string, E>[]): Hono<E, P>;
     use(...middleware: Handler<string, E>[]): Hono<E, P>;
     onError(handler: ErrorHandler<E>): Hono<E, P>;

package/dist/hono.js

@@ -1,18 +1,6 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Route_path, _Hono_router, _Hono_tempPath;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = exports.Route = void 0;
+exports.Hono = void 0;
 const compose_1 = require("./compose");
 const context_1 = require("./context");
 const router_1 = require("./router");
@@ -24,44 +12,13 @@ function defineDynamicClass() {
     return class {
     };
 }
-class Route extends defineDynamicClass() {
-    constructor() {
-        super();
-        this.routes = [];
-        _Route_path.set(this, '');
-        const allMethods = [...methods, router_2.METHOD_NAME_ALL_LOWERCASE];
-        allMethods.map((method) => {
-            this[method] = (args1, ...args) => {
-                if (typeof args1 === 'string') {
-                    __classPrivateFieldSet(this, _Route_path, args1, "f");
-                }
-                else {
-                    this.add(method, __classPrivateFieldGet(this, _Route_path, "f"), args1);
-                }
-                args.map((handler) => {
-                    if (typeof handler !== 'string') {
-                        this.add(method, __classPrivateFieldGet(this, _Route_path, "f"), handler);
-                    }
-                });
-                return this;
-            };
-        });
-    }
-    add(method, path, handler) {
-        const r = { path: path, method: method, handler: handler };
-        this.routes.push(r);
-        return this;
-    }
-}
-exports.Route = Route;
-_Route_path = new WeakMap();
 class Hono extends defineDynamicClass() {
     constructor(init = {}) {
         super();
         this.routerClass = trie_router_1.TrieRouter;
         this.strict = true; // strict routing - default is true
-        _Hono_router.set(this, void 0);
-        _Hono_tempPath.set(this, void 0);
+        this.path = '/';
+        this.routes = [];
         this.notFoundHandler = (c) => {
             const message = '404 Not Found';
             return c.text(message, 404);
@@ -89,19 +46,17 @@ class Hono extends defineDynamicClass() {
             };
         });
         Object.assign(this, init);
-        __classPrivateFieldSet(this, _Hono_router, new this.routerClass(), "f");
-        __classPrivateFieldSet(this, _Hono_tempPath, null, "f");
+        this._router = new this.routerClass();
+        this._tempPath = null;
     }
-    route(path, route) {
-        const newHono = new Hono();
-        __classPrivateFieldSet(newHono, _Hono_tempPath, path, "f");
-        __classPrivateFieldSet(newHono, _Hono_router, __classPrivateFieldGet(this, _Hono_router, "f"), "f");
-        if (route) {
-            route.routes.map((r) => {
-                newHono.addRoute(r.method, r.path, r.handler);
+    route(path, app) {
+        this._tempPath = path;
+        if (app) {
+            app.routes.map((r) => {
+                this.addRoute(r.method, r.path, r.handler);
             });
         }
-        return newHono;
+        return this;
     }
     use(arg1, ...handlers) {
         if (typeof arg1 === 'string') {
@@ -125,22 +80,30 @@ class Hono extends defineDynamicClass() {
     }
     addRoute(method, path, handler) {
         method = method.toUpperCase();
-        if (__classPrivateFieldGet(this, _Hono_tempPath, "f")) {
-            path = (0, url_1.mergePath)(__classPrivateFieldGet(this, _Hono_tempPath, "f"), path);
+        if (this._tempPath) {
+            path = (0, url_1.mergePath)(this._tempPath, path);
         }
-        __classPrivateFieldGet(this, _Hono_router, "f").add(method, path, handler);
+        this._router.add(method, path, handler);
+        const r = { path: path, method: method, handler: handler };
+        this.routes.push(r);
     }
     async matchRoute(method, path) {
-        return __classPrivateFieldGet(this, _Hono_router, "f").match(method, path);
+        return this._router.match(method, path);
     }
     async dispatch(request, event, env) {
         const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
         const method = request.method;
         const result = await this.matchRoute(method, path);
-        request.param = (key) => {
-            if (result)
-                return result.params[key];
-        };
+        request.param = ((key) => {
+            if (result) {
+                if (key) {
+                    return result.params[key];
+                }
+                else {
+                    return result.params;
+                }
+            }
+        });
         const handlers = result ? result.handlers : [this.notFoundHandler];
         const c = new context_1.Context(request, { env: env, event: event, res: undefined });
         c.notFound = () => this.notFoundHandler(c);
@@ -175,4 +138,3 @@ class Hono extends defineDynamicClass() {
     }
 }
 exports.Hono = Hono;
-_Hono_router = new WeakMap(), _Hono_tempPath = new WeakMap();

package/dist/hono.test.d.ts

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