@jderstd/hono 0.7.1 → 0.8.0

package/README.md

@@ -20,7 +20,9 @@ And the response will be shown as below:
 
 ```json
 {
-    "success": true
+    "success": true,
+    "data": null,
+    "errors": []
 }
 ```
 

package/dist/body-limit.d.ts

@@ -4,63 +4,63 @@ declare const BODY_LIMIT_MAX_DEFAULT: 10485760;
 /** Options for `bodyLimit` middleware. */
 type BodyLimitOptions = {
   /**
-   * Maximum body size in bytes.
-   *
-   * By default, it is `BODY_LIMIT_MAX_DEFAULT`.
-   */
+  * Maximum body size in bytes.
+  *
+  * By default, it is `BODY_LIMIT_MAX_DEFAULT`.
+  */
   max?: number;
 };
 /**
- * Body limit middleware.
- *
- * Following error will be returned if the body size is over the limit:
- *
- * ```jsonc
- * // Status: 413
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "too_large",
- *             "path": [
- *                 "request",
- *                 "body"
- *             ],
- *             "message": "Request body is too large"
- *         }
- *     ]
- * }
- * ```
- *
- * For more information, please refer to
- * [Body Limit](https://hono.dev/docs/middleware/builtin/body-limit).
- *
- * ### Examples
- *
- * A example of using `bodyLimit` middleware:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { bodyLimit } from "@jderstd/hono/body-limit";
- *
- * const app: Hono = new Hono();
- *
- * app.use(bodyLimit());
- * ```
- *
- * A example of using `bodyLimit` middleware with options:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { bodyLimit } from "@jderstd/hono/body-limit";
- *
- * const app: Hono = new Hono();
- *
- * app.use(bodyLimit({
- *     max: 20 * 1024 * 1024, // 20MiB
- * }));
- * ```
- */
+* Body limit middleware.
+*
+* Following error will be returned if the body size is over the limit:
+*
+* ```jsonc
+* // Status: 413
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "too_large",
+*             "path": [
+*                 "request",
+*                 "body"
+*             ],
+*             "message": "Request body is too large"
+*         }
+*     ]
+* }
+* ```
+*
+* For more information, please refer to
+* [Body Limit](https://hono.dev/docs/middleware/builtin/body-limit).
+*
+* ### Examples
+*
+* A example of using `bodyLimit` middleware:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { bodyLimit } from "@jderstd/hono/body-limit";
+*
+* const app: Hono = new Hono();
+*
+* app.use(bodyLimit());
+* ```
+*
+* A example of using `bodyLimit` middleware with options:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { bodyLimit } from "@jderstd/hono/body-limit";
+*
+* const app: Hono = new Hono();
+*
+* app.use(bodyLimit({
+*     max: 20 * 1024 * 1024, // 20MiB
+* }));
+* ```
+*/
 declare const bodyLimit: (options?: BodyLimitOptions) => MiddlewareHandler;
 export { BODY_LIMIT_MAX_DEFAULT, type BodyLimitOptions, bodyLimit };
 //# sourceMappingURL=body-limit.d.ts.map

package/dist/ip-limit.d.ts

@@ -10,9 +10,9 @@ type IpLimitBaseOptions = {
   /** Denied IP addresses. */
   denyList?: IPRestrictionRule[];
   /**
-   * Whether show more information.
-   * By default, it's `false`.
-   */
+  * Whether show more information.
+  * By default, it's `false`.
+  */
   verbose?: boolean;
 };
 /** Options for `ipLimit` middleware. */
@@ -21,79 +21,79 @@ type IpLimitOptions = Format<{
   getConnInfo: GetIPAddr;
 } & IpLimitBaseOptions>;
 /**
- * IP limit middleware.
- *
- * Following error will be returned if the IP address is not allowed:
- *
- * ```jsonc
- * // Status: 403
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "forbidden"
- *         }
- *     ]
- * }
- * ```
- *
- * When `verbose` is `true`, the error will be like:
- *
- * ```jsonc
- * // Status: 403
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "forbidden",
- *             "path": [
- *                 "request",
- *                 "ip"
- *             ],
- *             "message": "Forbidden IP address: x.x.x.x"
- *         }
- *     ]
- * }
- * ```
- *
- * For more information, please refer to
- * [IP Restriction](https://hono.dev/docs/middleware/builtin/ip-restriction).
- *
- * For `getConnInfo`, please refer to
- * [ConnInfo helper](https://hono.dev/docs/helpers/conninfo).
- *
- * ### Example
- *
- * ```ts
- * import { Hono } from "hono";
- * import { ipLimit } from "@jderstd/hono/ip-limit";
- *
- * // getConnInfo helper for Node.js
- * import { getConnInfo } from "@hono/node-server/conninfo";
- *
- * const app: Hono = new Hono();
- *
- * app.use(
- *     ipLimit({
- *         getConnInfo,
- *         allowList: [],
- *         denyList: [],
- *     })
- * );
- * ```
- */
+* IP limit middleware.
+*
+* Following error will be returned if the IP address is not allowed:
+*
+* ```jsonc
+* // Status: 403
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "forbidden"
+*         }
+*     ]
+* }
+* ```
+*
+* When `verbose` is `true`, the error will be like:
+*
+* ```jsonc
+* // Status: 403
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "forbidden",
+*             "path": [
+*                 "request",
+*                 "ip"
+*             ],
+*             "message": "Forbidden IP address: x.x.x.x"
+*         }
+*     ]
+* }
+* ```
+*
+* For more information, please refer to
+* [IP Restriction](https://hono.dev/docs/middleware/builtin/ip-restriction).
+*
+* For `getConnInfo`, please refer to
+* [ConnInfo helper](https://hono.dev/docs/helpers/conninfo).
+*
+* ### Example
+*
+* ```ts
+* import { Hono } from "hono";
+* import { ipLimit } from "@jderstd/hono/ip-limit";
+*
+* // getConnInfo helper for Node.js
+* import { getConnInfo } from "@hono/node-server/conninfo";
+*
+* const app: Hono = new Hono();
+*
+* app.use(
+*     ipLimit({
+*         getConnInfo,
+*         allowList: [],
+*         denyList: [],
+*     })
+* );
+* ```
+*/
 declare function ipLimit(options: IpLimitOptions): MiddlewareHandler;
 /**
- * IP limit middleware for compatibility with `hono/ip-restriction`.
- *
- * This is functionally equivalent to:
- *
- * ```ts
- * ipLimit({ getConnInfo, ...options });
- * ```
- *
- * And it behaves the same as the main `ipLimit` function.
- */
+* IP limit middleware for compatibility with `hono/ip-restriction`.
+*
+* This is functionally equivalent to:
+*
+* ```ts
+* ipLimit({ getConnInfo, ...options });
+* ```
+*
+* And it behaves the same as the main `ipLimit` function.
+*/
 declare function ipLimit(getConnInfo: GetIPAddr, options?: IpLimitBaseOptions): MiddlewareHandler;
 export { type AddressType, type ConnInfo, type GetConnInfo, type GetIPAddr, type IPRestrictionRule, type IpLimitBaseOptions, type IpLimitOptions, type NetAddrInfo, ipLimit };
 //# sourceMappingURL=ip-limit.d.ts.map

package/dist/not-found.d.ts

@@ -1,33 +1,33 @@
 import { Context } from "hono";
 /**
- * Not found handler.
- *
- * Following response will be returned on route not found:
- *
- * ```jsonc
- * // Status: 404
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "not_found",
- *             "message": "Content not found"
- *         }
- *     ]
- * }
- * ```
- *
- * ### Example
- *
- * ```ts
- * import { Hono } from "hono";
- * import { notFoundHandler } from "@jderstd/hono/not-found";
- *
- * const app: Hono = new Hono();
- *
- * app.notFound(notFoundHandler());
- * ```
- */
+* Not found handler.
+*
+* Following response will be returned on route not found:
+*
+* ```jsonc
+* // Status: 404
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "not_found",
+*             "message": "Content not found"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Example
+*
+* ```ts
+* import { Hono } from "hono";
+* import { notFoundHandler } from "@jderstd/hono/not-found";
+*
+* const app: Hono = new Hono();
+*
+* app.notFound(notFoundHandler());
+* ```
+*/
 declare const notFoundHandler: () => ((c: Context) => Response);
 export { notFoundHandler };
 //# sourceMappingURL=not-found.d.ts.map

package/dist/on-error.d.ts

@@ -3,64 +3,64 @@ import { HTTPResponseError } from "hono/types";
 /** Options for `onErrorHandler` function. */
 type OnErrorHandlerOptions = {
   /**
-   * Whether show more information.
-   * By default, it's `false`.
-   */
+  * Whether show more information.
+  * By default, it's `false`.
+  */
   verbose?: boolean;
 };
 /**
- * On error handler.
- *
- * Following responses could be returned on error:
- *
- * ```jsonc
- * // Status: 400
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "bad_request"
- *         }
- *     ]
- * }
- * ```
- *
- * ```jsonc
- * // Status: 500
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "server"
- *         }
- *     ]
- * }
- * ```
- *
- * ### Examples
- *
- * Basic example of using `onErrorHandler` handler:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { onErrorHandler } from "@jderstd/hono/on-error";
- *
- * const app: Hono = new Hono();
- *
- * app.onError(onErrorHandler());
- * ```
- *
- * Show more information with `verbose` option:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { onErrorHandler } from "@jderstd/hono/on-error";
- *
- * const app: Hono = new Hono();
- *
- * app.onError(onErrorHandler({ verbose: true }));
- * ```
- */
+* On error handler.
+*
+* Following responses could be returned on error:
+*
+* ```jsonc
+* // Status: 400
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "bad_request"
+*         }
+*     ]
+* }
+* ```
+*
+* ```jsonc
+* // Status: 500
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "server"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Examples
+*
+* Basic example of using `onErrorHandler` handler:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { onErrorHandler } from "@jderstd/hono/on-error";
+*
+* const app: Hono = new Hono();
+*
+* app.onError(onErrorHandler());
+* ```
+*
+* Show more information with `verbose` option:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { onErrorHandler } from "@jderstd/hono/on-error";
+*
+* const app: Hono = new Hono();
+*
+* app.onError(onErrorHandler({ verbose: true }));
+* ```
+*/
 declare const onErrorHandler: (options?: OnErrorHandlerOptions) => ((err: Error | HTTPResponseError, c: Context) => Response);
 export { onErrorHandler };
 //# sourceMappingURL=on-error.d.ts.map

package/dist/response/common/index.d.ts

@@ -5,78 +5,78 @@ import { StatusCode } from "hono/utils/http-status";
 /** Options of `createResponse` function. */
 type CreateResponseOptions<B extends BodyInit = BodyInit> = Format<{
   /**
-   * Status code of the response.
-   * By default, it is `200` for success and `400` for failure.
-   */
+  * Status code of the response.
+  * By default, it is `200` for success and `400` for failure.
+  */
   status?: StatusCode;
 } & Omit<CreateResponseStructOptions<B>, "status">>;
 /**
- * Create a response.
- *
- * ### Examples
- *
- * Example for creating a basic response:
- *
- * ```ts
- * import { createResponse } from "@jderstd/hono/response";
- *
- * const route = (): Response => {
- *     return createResponse();
- * };
- * ```
- *
- * Example for creating a response with status, headers, and body:
- *
- * ```ts
- * import { createResponse } from "@jderstd/hono/response";
- *
- * const route = (): Response => {
- *     return createResponse({
- *         status: 404,
- *         headers: [
- *             ["Content-Type", "text/plain"],
- *         ],
- *         body: "Not Found",
- *     });
- * };
- * ```
- */
+* Create a response.
+*
+* ### Examples
+*
+* Example for creating a basic response:
+*
+* ```ts
+* import { createResponse } from "@jderstd/hono/response";
+*
+* const route = (): Response => {
+*     return createResponse();
+* };
+* ```
+*
+* Example for creating a response with status, headers, and body:
+*
+* ```ts
+* import { createResponse } from "@jderstd/hono/response";
+*
+* const route = (): Response => {
+*     return createResponse({
+*         status: 404,
+*         headers: [
+*             ["Content-Type", "text/plain"],
+*         ],
+*         body: "Not Found",
+*     });
+* };
+* ```
+*/
 declare function createResponse<B extends BodyInit = BodyInit>(options?: CreateResponseOptions<B>): Response;
 /**
- * Create a response with context.
- *
- * ### Examples
- *
- * Example for creating a basic response:
- *
- * ```ts
- * import type { Context } from "hono";
- *
- * import { createResponse } from "@jderstd/hono/response";
- *
- * const route = (c: Context): Response => {
- *     return createResponse(c);
- * };
- * ```
- *
- * Example for creating a response with status, headers, and body:
- *
- * ```ts
- * import type { Context } from "hono";
- *
- * import { createResponse } from "@jderstd/hono/response";
- *
- * const route = (c: Context): Response => {
- *     return createResponse(c, {
- *         status: 404,
- *         headers: [
- *             ["Content-Type", "text/plain"],
- *         ],
- *         body: "Not Found",
- *     });
- * };
- * ```
- */
+* Create a response with context.
+*
+* ### Examples
+*
+* Example for creating a basic response:
+*
+* ```ts
+* import type { Context } from "hono";
+*
+* import { createResponse } from "@jderstd/hono/response";
+*
+* const route = (c: Context): Response => {
+*     return createResponse(c);
+* };
+* ```
+*
+* Example for creating a response with status, headers, and body:
+*
+* ```ts
+* import type { Context } from "hono";
+*
+* import { createResponse } from "@jderstd/hono/response";
+*
+* const route = (c: Context): Response => {
+*     return createResponse(c, {
+*         status: 404,
+*         headers: [
+*             ["Content-Type", "text/plain"],
+*         ],
+*         body: "Not Found",
+*     });
+* };
+* ```
+*/
 declare function createResponse<B extends BodyInit = BodyInit>(context?: Context, options?: CreateResponseOptions<B>): Response;
 export { type CreateResponseOptions, createResponse };
 //# sourceMappingURL=index.d.ts.map

package/dist/response/common/index.js

@@ -1,8 +1,8 @@
 const require_index = require('../json/index.js');
-let __jderstd_core_response_common_struct = require("@jderstd/core/response/common/struct");
+let _jderstd_core_response_common_struct = require("@jderstd/core/response/common/struct");
 
 function createResponse(contextOrOptions, options) {
-	const { status, headers, body } = require_index.isContext(contextOrOptions) ? (0, __jderstd_core_response_common_struct.createResponseStruct)(options) : (0, __jderstd_core_response_common_struct.createResponseStruct)(contextOrOptions);
+	const { status, headers, body } = require_index.isContext(contextOrOptions) ? (0, _jderstd_core_response_common_struct.createResponseStruct)(options) : (0, _jderstd_core_response_common_struct.createResponseStruct)(contextOrOptions);
 	if (require_index.isContext(contextOrOptions)) {
 		const c = contextOrOptions;
 		c.status(status);

package/dist/response/common/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["isContext","c: Context"],"sources":["../../../src/response/common/index.ts"],"sourcesContent":["import type { CreateResponseStructOptions } from \"@jderstd/core/response/common/struct\";\nimport type { Context } from \"hono\";\nimport type { StatusCode } from \"hono/utils/http-status\";\nimport type { Format, Omit } from \"ts-vista\";\n\nimport { createResponseStruct } from \"@jderstd/core/response/common/struct\";\n\nimport { isContext } from \"#/response/json\";\n\n/** Options of `createResponse` function. */\ntype CreateResponseOptions<B extends BodyInit = BodyInit> = Format<\n    {\n        /**\n         * Status code of the response.\n         * By default, it is `200` for success and `400` for failure.\n         */\n        status?: StatusCode;\n    } & Omit<CreateResponseStructOptions<B>, \"status\">\n>;\n\n/**\n * Create a response.\n *\n * ### Examples\n *\n * Example for creating a basic response:\n *\n * ```ts\n * import { createResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createResponse();\n * };\n * ```\n *\n * Example for creating a response with status, headers, and body:\n *\n * ```ts\n * import { createResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createResponse({\n *         status: 404,\n *         headers: [\n *             [\"Content-Type\", \"text/plain\"],\n *         ],\n *         body: \"Not Found\",\n *     });\n * };\n * ```\n */\nfunction createResponse<B extends BodyInit = BodyInit>(\n    options?: CreateResponseOptions<B>,\n): Response;\n\n/**\n * Create a response with context.\n *\n * ### Examples\n *\n * Example for creating a basic response:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createResponse(c);\n * };\n * ```\n *\n * Example for creating a response with status, headers, and body:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createResponse(c, {\n *         status: 404,\n *         headers: [\n *             [\"Content-Type\", \"text/plain\"],\n *         ],\n *         body: \"Not Found\",\n *     });\n * };\n * ```\n */\nfunction createResponse<B extends BodyInit = BodyInit>(\n    context?: Context,\n    options?: CreateResponseOptions<B>,\n): Response;\n\nfunction createResponse<B extends BodyInit = BodyInit>(\n    contextOrOptions?: Context | CreateResponseOptions<B>,\n    options?: CreateResponseOptions<B>,\n): Response {\n    const { status, headers, body } = isContext(contextOrOptions)\n        ? createResponseStruct(options)\n        : createResponseStruct(contextOrOptions);\n\n    if (isContext(contextOrOptions)) {\n        const c: Context = contextOrOptions;\n\n        c.status(status as StatusCode);\n\n        for (const [key, value] of headers) c.header(key, value);\n\n        return body\n            ? c.body(body as string | ArrayBuffer | ReadableStream)\n            : c.body(null);\n    }\n\n    return new Response(body, {\n        status,\n        headers,\n    });\n}\n\nexport type { CreateResponseOptions };\nexport { createResponse };\n"],"mappings":";;;AA+FA,SAAS,eACL,kBACA,SACQ;CACR,MAAM,EAAE,QAAQ,SAAS,SAASA,wBAAU,iBAAiB,mEAClC,QAAQ,mEACR,iBAAiB;AAE5C,KAAIA,wBAAU,iBAAiB,EAAE;EAC7B,MAAMC,IAAa;AAEnB,IAAE,OAAO,OAAqB;AAE9B,OAAK,MAAM,CAAC,KAAK,UAAU,QAAS,GAAE,OAAO,KAAK,MAAM;AAExD,SAAO,OACD,EAAE,KAAK,KAA8C,GACrD,EAAE,KAAK,KAAK;;AAGtB,QAAO,IAAI,SAAS,MAAM;EACtB;EACA;EACH,CAAC"}
+{"version":3,"file":"index.js","names":["isContext","c: Context"],"sources":["../../../src/response/common/index.ts"],"sourcesContent":["import type { CreateResponseStructOptions } from \"@jderstd/core/response/common/struct\";\nimport type { Context } from \"hono\";\nimport type { StatusCode } from \"hono/utils/http-status\";\nimport type { Format, Omit } from \"ts-vista\";\n\nimport { createResponseStruct } from \"@jderstd/core/response/common/struct\";\n\nimport { isContext } from \"#/response/json\";\n\n/** Options of `createResponse` function. */\ntype CreateResponseOptions<B extends BodyInit = BodyInit> = Format<\n    {\n        /**\n         * Status code of the response.\n         * By default, it is `200` for success and `400` for failure.\n         */\n        status?: StatusCode;\n    } & Omit<CreateResponseStructOptions<B>, \"status\">\n>;\n\n/**\n * Create a response.\n *\n * ### Examples\n *\n * Example for creating a basic response:\n *\n * ```ts\n * import { createResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createResponse();\n * };\n * ```\n *\n * Example for creating a response with status, headers, and body:\n *\n * ```ts\n * import { createResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createResponse({\n *         status: 404,\n *         headers: [\n *             [\"Content-Type\", \"text/plain\"],\n *         ],\n *         body: \"Not Found\",\n *     });\n * };\n * ```\n */\nfunction createResponse<B extends BodyInit = BodyInit>(\n    options?: CreateResponseOptions<B>,\n): Response;\n\n/**\n * Create a response with context.\n *\n * ### Examples\n *\n * Example for creating a basic response:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createResponse(c);\n * };\n * ```\n *\n * Example for creating a response with status, headers, and body:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createResponse(c, {\n *         status: 404,\n *         headers: [\n *             [\"Content-Type\", \"text/plain\"],\n *         ],\n *         body: \"Not Found\",\n *     });\n * };\n * ```\n */\nfunction createResponse<B extends BodyInit = BodyInit>(\n    context?: Context,\n    options?: CreateResponseOptions<B>,\n): Response;\n\nfunction createResponse<B extends BodyInit = BodyInit>(\n    contextOrOptions?: Context | CreateResponseOptions<B>,\n    options?: CreateResponseOptions<B>,\n): Response {\n    const { status, headers, body } = isContext(contextOrOptions)\n        ? createResponseStruct(options)\n        : createResponseStruct(contextOrOptions);\n\n    if (isContext(contextOrOptions)) {\n        const c: Context = contextOrOptions;\n\n        c.status(status as StatusCode);\n\n        for (const [key, value] of headers) c.header(key, value);\n\n        return body\n            ? c.body(body as string | ArrayBuffer | ReadableStream)\n            : c.body(null);\n    }\n\n    return new Response(body, {\n        status,\n        headers,\n    });\n}\n\nexport type { CreateResponseOptions };\nexport { createResponse };\n"],"mappings":";;;AA+FA,SAAS,eACL,kBACA,SACQ;CACR,MAAM,EAAE,QAAQ,SAAS,SAASA,wBAAU,iBAAiB,kEAClC,QAAQ,kEACR,iBAAiB;AAE5C,KAAIA,wBAAU,iBAAiB,EAAE;EAC7B,MAAMC,IAAa;AAEnB,IAAE,OAAO,OAAqB;AAE9B,OAAK,MAAM,CAAC,KAAK,UAAU,QAAS,GAAE,OAAO,KAAK,MAAM;AAExD,SAAO,OACD,EAAE,KAAK,KAA8C,GACrD,EAAE,KAAK,KAAK;;AAGtB,QAAO,IAAI,SAAS,MAAM;EACtB;EACA;EACH,CAAC"}

package/dist/response/error/index.d.ts

@@ -1,53 +1,53 @@
 /**
- * Response error code.
- */
+* Response error code.
+*/
 declare enum ResponseErrorCode {
   /**
-   * Request body is too large.
-   *
-   * For `bodyLimit` middleware.
-   */
+  * Request body is too large.
+  *
+  * For `bodyLimit` middleware.
+  */
   TooLarge = "too_large",
   /**
-   * Forbidden access.
-   *
-   * For `ipLimit` middleware.
-   */
+  * Forbidden access.
+  *
+  * For `ipLimit` middleware.
+  */
   Forbidden = "forbidden",
   /**
-   * Request timeout.
-   *
-   * For `timeLimit` middleware.
-   */
+  * Request timeout.
+  *
+  * For `timeLimit` middleware.
+  */
   Timeout = "timeout",
   /**
-   * Content not found.
-   *
-   * For `notFoundHandler` function.
-   */
+  * Content not found.
+  *
+  * For `notFoundHandler` function.
+  */
   NotFound = "not_found",
   /**
-   * Bad request.
-   *
-   * For `onErrorHandler` function.
-   */
+  * Bad request.
+  *
+  * For `onErrorHandler` function.
+  */
   BadRequest = "bad_request",
   /**
-   * Internal server error.
-   *
-   * For `onErrorHandler` function.
-   */
+  * Internal server error.
+  *
+  * For `onErrorHandler` function.
+  */
   Server = "server",
   /**
-   * Validation error.
-   *
-   * For validator package.
-   */
+  * Validation error.
+  *
+  * For validator package.
+  */
   Parse = "parse",
 }
 /**
- * Get response error message by code.
- */
+* Get response error message by code.
+*/
 declare const getResponseErrorMessage: (code: ResponseErrorCode) => string;
 export { ResponseErrorCode, getResponseErrorMessage };
 //# sourceMappingURL=index.d.ts.map

package/dist/response/json/index.d.ts

@@ -5,106 +5,106 @@ import { CreateJsonResponseStructOptions } from "@jderstd/core/response/json/str
 /** Options of `createJsonResponse` function. */
 type CreateJsonResponseOptions<D = unknown> = Format<{
   /**
-   * Status code of the response.
-   * By default, it is `200` for success and `400` for failure.
-   */
+  * Status code of the response.
+  * By default, it is `200` for success and `400` for failure.
+  */
   status?: StatusCode;
 } & Omit<CreateJsonResponseStructOptions<D>, "status">>;
 /**
- * Create a JSON response.
- *
- * ### Examples
- *
- * Example for creating a successful JSON response without data:
- *
- * ```ts
- * import { createJsonResponse } from "@jderstd/hono/response";
- *
- * const route = (): Response => {
- *     return createJsonResponse();
- * };
- * ```
- *
- * Example for creating a successful JSON response with data:
- *
- * ```ts
- * import { createJsonResponse } from "@jderstd/hono/response";
- *
- * const route = (): Response => {
- *     return createJsonResponse({
- *         data: "Hello, World!",
- *     });
- * }
- * ```
- *
- * Example for creating a failed JSON response:
- *
- * ```ts
- * import { createJsonResponse } from "@jderstd/hono/response";
- *
- * const route = (): Response => {
- *     return createJsonResponse({
- *         errors: [
- *             {
- *                 code: "server",
- *                 message: "Internal server error",
- *             },
- *         ],
- *     });
- * };
- * ```
- */
+* Create a JSON response.
+*
+* ### Examples
+*
+* Example for creating a successful JSON response without data:
+*
+* ```ts
+* import { createJsonResponse } from "@jderstd/hono/response";
+*
+* const route = (): Response => {
+*     return createJsonResponse();
+* };
+* ```
+*
+* Example for creating a successful JSON response with data:
+*
+* ```ts
+* import { createJsonResponse } from "@jderstd/hono/response";
+*
+* const route = (): Response => {
+*     return createJsonResponse({
+*         data: "Hello, World!",
+*     });
+* }
+* ```
+*
+* Example for creating a failed JSON response:
+*
+* ```ts
+* import { createJsonResponse } from "@jderstd/hono/response";
+*
+* const route = (): Response => {
+*     return createJsonResponse({
+*         errors: [
+*             {
+*                 code: "server",
+*                 message: "Internal server error",
+*             },
+*         ],
+*     });
+* };
+* ```
+*/
 declare function createJsonResponse<D = unknown>(options?: CreateJsonResponseOptions<D>): Response;
 /**
- * Create a JSON response with context.
- *
- * ### Examples
- *
- * Example for creating a successful JSON response without data:
- *
- * ```ts
- * import type { Context } from "hono";
- *
- * import { createJsonResponse } from "@jderstd/hono/response";
- *
- * const route = (c: Context): Response => {
- *     return createJsonResponse(c);
- * };
- * ```
- *
- * Example for creating a successful JSON response with data:
- *
- * ```ts
- * import type { Context } from "hono";
- *
- * import { createJsonResponse } from "@jderstd/hono/response";
- *
- * const route = (c: Context): Response => {
- *     return createJsonResponse(c, {
- *         data: "Hello, World!",
- *     });
- * }
- * ```
- *
- * Example for creating a failed JSON response:
- *
- * ```ts
- * import type { Context } from "hono";
- *
- * import { createJsonResponse } from "@jderstd/hono/response";
- *
- * const route = (c: Context): Response => {
- *     return createJsonResponse(c, {
- *         errors: [
- *             {
- *                 code: "server",
- *                 message: "Internal server error",
- *             },
- *         ],
- *     });
- * };
- * ```
- */
+* Create a JSON response with context.
+*
+* ### Examples
+*
+* Example for creating a successful JSON response without data:
+*
+* ```ts
+* import type { Context } from "hono";
+*
+* import { createJsonResponse } from "@jderstd/hono/response";
+*
+* const route = (c: Context): Response => {
+*     return createJsonResponse(c);
+* };
+* ```
+*
+* Example for creating a successful JSON response with data:
+*
+* ```ts
+* import type { Context } from "hono";
+*
+* import { createJsonResponse } from "@jderstd/hono/response";
+*
+* const route = (c: Context): Response => {
+*     return createJsonResponse(c, {
+*         data: "Hello, World!",
+*     });
+* }
+* ```
+*
+* Example for creating a failed JSON response:
+*
+* ```ts
+* import type { Context } from "hono";
+*
+* import { createJsonResponse } from "@jderstd/hono/response";
+*
+* const route = (c: Context): Response => {
+*     return createJsonResponse(c, {
+*         errors: [
+*             {
+*                 code: "server",
+*                 message: "Internal server error",
+*             },
+*         ],
+*     });
+* };
+* ```
+*/
 declare function createJsonResponse<D = unknown>(context?: Context, options?: CreateJsonResponseOptions<D>): Response;
 export { type CreateJsonResponseOptions, createJsonResponse };
 //# sourceMappingURL=index.d.ts.map

package/dist/response/json/index.js

@@ -1,9 +1,9 @@
-let __jderstd_core_response_json_struct = require("@jderstd/core/response/json/struct");
+let _jderstd_core_response_json_struct = require("@jderstd/core/response/json/struct");
 
 /** Check if the argument is a Hono context. */
 const isContext = (arg) => arg?.req !== void 0;
 function createJsonResponse(contextOrOptions, options) {
-	const { status, headers, json } = isContext(contextOrOptions) ? (0, __jderstd_core_response_json_struct.createJsonResponseStruct)(options) : (0, __jderstd_core_response_json_struct.createJsonResponseStruct)(contextOrOptions);
+	const { status, headers, json } = isContext(contextOrOptions) ? (0, _jderstd_core_response_json_struct.createJsonResponseStruct)(options) : (0, _jderstd_core_response_json_struct.createJsonResponseStruct)(contextOrOptions);
 	if (isContext(contextOrOptions)) {
 		const c = contextOrOptions;
 		c.status(status);

package/dist/response/json/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["c: Context"],"sources":["../../../src/response/json/index.ts"],"sourcesContent":["import type { CreateJsonResponseStructOptions } from \"@jderstd/core/response/json/struct\";\nimport type { Context } from \"hono\";\nimport type { StatusCode } from \"hono/utils/http-status\";\nimport type { Format, Omit } from \"ts-vista\";\n\nimport { createJsonResponseStruct } from \"@jderstd/core/response/json/struct\";\n\n/** Check if the argument is a Hono context. */\nconst isContext = (arg: any): arg is Context => arg?.req !== undefined;\n\n/** Options of `createJsonResponse` function. */\ntype CreateJsonResponseOptions<D = unknown> = Format<\n    {\n        /**\n         * Status code of the response.\n         * By default, it is `200` for success and `400` for failure.\n         */\n        status?: StatusCode;\n    } & Omit<CreateJsonResponseStructOptions<D>, \"status\">\n>;\n\n/**\n * Create a JSON response.\n *\n * ### Examples\n *\n * Example for creating a successful JSON response without data:\n *\n * ```ts\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createJsonResponse();\n * };\n * ```\n *\n * Example for creating a successful JSON response with data:\n *\n * ```ts\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createJsonResponse({\n *         data: \"Hello, World!\",\n *     });\n * }\n * ```\n *\n * Example for creating a failed JSON response:\n *\n * ```ts\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createJsonResponse({\n *         errors: [\n *             {\n *                 code: \"server\",\n *                 message: \"Internal server error\",\n *             },\n *         ],\n *     });\n * };\n * ```\n */\nfunction createJsonResponse<D = unknown>(\n    options?: CreateJsonResponseOptions<D>,\n): Response;\n\n/**\n * Create a JSON response with context.\n *\n * ### Examples\n *\n * Example for creating a successful JSON response without data:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createJsonResponse(c);\n * };\n * ```\n *\n * Example for creating a successful JSON response with data:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createJsonResponse(c, {\n *         data: \"Hello, World!\",\n *     });\n * }\n * ```\n *\n * Example for creating a failed JSON response:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createJsonResponse(c, {\n *         errors: [\n *             {\n *                 code: \"server\",\n *                 message: \"Internal server error\",\n *             },\n *         ],\n *     });\n * };\n * ```\n */\nfunction createJsonResponse<D = unknown>(\n    context?: Context,\n    options?: CreateJsonResponseOptions<D>,\n): Response;\n\nfunction createJsonResponse<D = unknown>(\n    contextOrOptions?: Context | CreateJsonResponseOptions<D>,\n    options?: CreateJsonResponseOptions<D>,\n): Response {\n    const { status, headers, json } = isContext(contextOrOptions)\n        ? createJsonResponseStruct(options)\n        : createJsonResponseStruct(contextOrOptions);\n\n    if (isContext(contextOrOptions)) {\n        const c: Context = contextOrOptions;\n\n        c.status(status as StatusCode);\n\n        for (const [key, value] of headers) c.header(key, value);\n\n        return c.json(json);\n    }\n\n    return new Response(JSON.stringify(json), {\n        status,\n        headers,\n    });\n}\n\nexport type { CreateJsonResponseOptions };\nexport { isContext, createJsonResponse };\n"],"mappings":";;;AAQA,MAAM,aAAa,QAA6B,KAAK,QAAQ;AAoH7D,SAAS,mBACL,kBACA,SACQ;CACR,MAAM,EAAE,QAAQ,SAAS,SAAS,UAAU,iBAAiB,qEAC9B,QAAQ,qEACR,iBAAiB;AAEhD,KAAI,UAAU,iBAAiB,EAAE;EAC7B,MAAMA,IAAa;AAEnB,IAAE,OAAO,OAAqB;AAE9B,OAAK,MAAM,CAAC,KAAK,UAAU,QAAS,GAAE,OAAO,KAAK,MAAM;AAExD,SAAO,EAAE,KAAK,KAAK;;AAGvB,QAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;EACtC;EACA;EACH,CAAC"}
+{"version":3,"file":"index.js","names":["c: Context"],"sources":["../../../src/response/json/index.ts"],"sourcesContent":["import type { CreateJsonResponseStructOptions } from \"@jderstd/core/response/json/struct\";\nimport type { Context } from \"hono\";\nimport type { StatusCode } from \"hono/utils/http-status\";\nimport type { Format, Omit } from \"ts-vista\";\n\nimport { createJsonResponseStruct } from \"@jderstd/core/response/json/struct\";\n\n/** Check if the argument is a Hono context. */\nconst isContext = (arg: any): arg is Context => arg?.req !== undefined;\n\n/** Options of `createJsonResponse` function. */\ntype CreateJsonResponseOptions<D = unknown> = Format<\n    {\n        /**\n         * Status code of the response.\n         * By default, it is `200` for success and `400` for failure.\n         */\n        status?: StatusCode;\n    } & Omit<CreateJsonResponseStructOptions<D>, \"status\">\n>;\n\n/**\n * Create a JSON response.\n *\n * ### Examples\n *\n * Example for creating a successful JSON response without data:\n *\n * ```ts\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createJsonResponse();\n * };\n * ```\n *\n * Example for creating a successful JSON response with data:\n *\n * ```ts\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createJsonResponse({\n *         data: \"Hello, World!\",\n *     });\n * }\n * ```\n *\n * Example for creating a failed JSON response:\n *\n * ```ts\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (): Response => {\n *     return createJsonResponse({\n *         errors: [\n *             {\n *                 code: \"server\",\n *                 message: \"Internal server error\",\n *             },\n *         ],\n *     });\n * };\n * ```\n */\nfunction createJsonResponse<D = unknown>(\n    options?: CreateJsonResponseOptions<D>,\n): Response;\n\n/**\n * Create a JSON response with context.\n *\n * ### Examples\n *\n * Example for creating a successful JSON response without data:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createJsonResponse(c);\n * };\n * ```\n *\n * Example for creating a successful JSON response with data:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createJsonResponse(c, {\n *         data: \"Hello, World!\",\n *     });\n * }\n * ```\n *\n * Example for creating a failed JSON response:\n *\n * ```ts\n * import type { Context } from \"hono\";\n *\n * import { createJsonResponse } from \"@jderstd/hono/response\";\n *\n * const route = (c: Context): Response => {\n *     return createJsonResponse(c, {\n *         errors: [\n *             {\n *                 code: \"server\",\n *                 message: \"Internal server error\",\n *             },\n *         ],\n *     });\n * };\n * ```\n */\nfunction createJsonResponse<D = unknown>(\n    context?: Context,\n    options?: CreateJsonResponseOptions<D>,\n): Response;\n\nfunction createJsonResponse<D = unknown>(\n    contextOrOptions?: Context | CreateJsonResponseOptions<D>,\n    options?: CreateJsonResponseOptions<D>,\n): Response {\n    const { status, headers, json } = isContext(contextOrOptions)\n        ? createJsonResponseStruct(options)\n        : createJsonResponseStruct(contextOrOptions);\n\n    if (isContext(contextOrOptions)) {\n        const c: Context = contextOrOptions;\n\n        c.status(status as StatusCode);\n\n        for (const [key, value] of headers) c.header(key, value);\n\n        return c.json(json);\n    }\n\n    return new Response(JSON.stringify(json), {\n        status,\n        headers,\n    });\n}\n\nexport type { CreateJsonResponseOptions };\nexport { isContext, createJsonResponse };\n"],"mappings":";;;AAQA,MAAM,aAAa,QAA6B,KAAK,QAAQ;AAoH7D,SAAS,mBACL,kBACA,SACQ;CACR,MAAM,EAAE,QAAQ,SAAS,SAAS,UAAU,iBAAiB,oEAC9B,QAAQ,oEACR,iBAAiB;AAEhD,KAAI,UAAU,iBAAiB,EAAE;EAC7B,MAAMA,IAAa;AAEnB,IAAE,OAAO,OAAqB;AAE9B,OAAK,MAAM,CAAC,KAAK,UAAU,QAAS,GAAE,OAAO,KAAK,MAAM;AAExD,SAAO,EAAE,KAAK,KAAK;;AAGvB,QAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;EACtC;EACA;EACH,CAAC"}

package/dist/response.d.ts

@@ -1,4 +1,4 @@
 import { CreateResponseOptions, createResponse } from "./response/common/index.js";
 import { CreateJsonResponseOptions, createJsonResponse } from "./response/json/index.js";
-import { JsonResponse, JsonResponseError } from "@jderstd/core";
-export { type CreateJsonResponseOptions, type CreateResponseOptions, type JsonResponse, type JsonResponseError, createJsonResponse, createResponse };
+import { JsonResponse, JsonResponseError, JsonResponseErrorInput } from "@jderstd/core";
+export { type CreateJsonResponseOptions, type CreateResponseOptions, type JsonResponse, type JsonResponseError, type JsonResponseErrorInput, createJsonResponse, createResponse };

package/dist/time-limit.d.ts

@@ -4,59 +4,59 @@ declare const TIME_LIMIT_MAX_DEFAULT: 5000;
 /** Options for `timeLimit` middleware. */
 type TimeLimitOptions = {
   /**
-   * Maximum time in milliseconds.
-   *
-   * By default, it is `TIME_LIMIT_MAX_DEFAULT`.
-   */
+  * Maximum time in milliseconds.
+  *
+  * By default, it is `TIME_LIMIT_MAX_DEFAULT`.
+  */
   max?: number;
 };
 /**
- * Time limit middleware.
- *
- * Following error will be returned if the request takes longer than the limit:
- *
- * ```jsonc
- * // Status: 504
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "timeout",
- *             "message": "Request timeout"
- *         }
- *     ]
- * }
- * ```
- *
- * For more information, please refer to
- * [Timeout](https://hono.dev/docs/middleware/builtin/timeout).
- *
- * ### Examples
- *
- * A example of using `timeLimit` middleware:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { timeLimit } from "@jderstd/hono/time-limit";
- *
- * const app: Hono = new Hono();
- *
- * app.use(timeLimit());
- * ```
- *
- * A example of using `timeLimit` middleware with options:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { timeLimit } from "@jderstd/hono/time-limit";
- *
- * const app: Hono = new Hono();
- *
- * app.use(timeLimit({
- *     max: 10 * 1000, // 10s
- * }));
- * ```
- */
+* Time limit middleware.
+*
+* Following error will be returned if the request takes longer than the limit:
+*
+* ```jsonc
+* // Status: 504
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "timeout",
+*             "message": "Request timeout"
+*         }
+*     ]
+* }
+* ```
+*
+* For more information, please refer to
+* [Timeout](https://hono.dev/docs/middleware/builtin/timeout).
+*
+* ### Examples
+*
+* A example of using `timeLimit` middleware:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { timeLimit } from "@jderstd/hono/time-limit";
+*
+* const app: Hono = new Hono();
+*
+* app.use(timeLimit());
+* ```
+*
+* A example of using `timeLimit` middleware with options:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { timeLimit } from "@jderstd/hono/time-limit";
+*
+* const app: Hono = new Hono();
+*
+* app.use(timeLimit({
+*     max: 10 * 1000, // 10s
+* }));
+* ```
+*/
 declare const timeLimit: (options?: TimeLimitOptions) => MiddlewareHandler;
 export { TIME_LIMIT_MAX_DEFAULT, type TimeLimitOptions, timeLimit };
 //# sourceMappingURL=time-limit.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jderstd/hono",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "A response builder for Hono",
   "keywords": [
     "jder",
@@ -73,8 +73,8 @@
     "dist"
   ],
   "dependencies": {
-    "@jderstd/core": "~0.4.0",
-    "ts-vista": "~0.2.2"
+    "@jderstd/core": "0.5.0",
+    "ts-vista": "~0.2.3"
   },
   "devDependencies": {
     "hono": "4.5.0"