@jderstd/hono 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present, Alpheus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# JDER Hono
+
+A response builder for Hono.
+
+This package includes different response builders based on the JSON response structure specified in [JSON Data Errors Response (JDER)](https://github.com/jderstd/spec). With the builders, various kinds of responses can be created easily instead of sending plain text responses.
+
+## Quick Start
+
+To create a JSON response, use the following code:
+
+```ts
+import { createJsonResponse } from "@jderstd/hono/response";
+
+const route = (): Response => {
+    return createJsonResponse();
+}
+```
+
+And the response will be shown as below:
+
+```json
+{
+    "success": true
+}
+```
+
+## License
+
+This project is licensed under the terms of the MIT license.

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,23 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+
+exports.__toESM = __toESM;

package/dist/body-limit.d.ts

@@ -0,0 +1,66 @@
+import { MiddlewareHandler } from "hono";
+/** Default maximum body size in bytes. */
+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`.
+   */
+  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
+ * }));
+ * ```
+ */
+declare const bodyLimit: (options?: BodyLimitOptions) => MiddlewareHandler;
+export { BODY_LIMIT_MAX_DEFAULT, type BodyLimitOptions, bodyLimit };
+//# sourceMappingURL=body-limit.d.ts.map

package/dist/body-limit.js

@@ -0,0 +1,79 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_index = require('./response/json/index.js');
+const require_response_error = require('./response/error.js');
+let hono_body_limit = require("hono/body-limit");
+hono_body_limit = require_rolldown_runtime.__toESM(hono_body_limit);
+
+/** Default maximum body size in bytes. */
+const BODY_LIMIT_MAX_DEFAULT = 10 * 1024 * 1024;
+/**
+* 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
+* }));
+* ```
+*/
+const bodyLimit = (options) => {
+	const code = require_response_error.ResponseErrorCode.TooLarge;
+	return (0, hono_body_limit.bodyLimit)({
+		maxSize: options?.max ?? BODY_LIMIT_MAX_DEFAULT,
+		onError: (c) => {
+			return require_index.createJsonResponse(c, {
+				status: 413,
+				errors: [{
+					code,
+					path: ["request", "body"],
+					message: require_response_error.getResponseErrorMessage(code)
+				}]
+			});
+		}
+	});
+};
+
+exports.BODY_LIMIT_MAX_DEFAULT = BODY_LIMIT_MAX_DEFAULT;
+exports.bodyLimit = bodyLimit;
+//# sourceMappingURL=body-limit.js.map

package/dist/body-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"body-limit.js","names":["code: ResponseErrorCode","ResponseErrorCode","createJsonResponse","getResponseErrorMessage"],"sources":["../src/middlewares/body-limit.ts"],"sourcesContent":["/**\n * Body limit module\n * @module middlewares/body-limit\n */\n\nimport type { Context, MiddlewareHandler } from \"hono\";\n\nimport { bodyLimit as _bodyLimit } from \"hono/body-limit\";\n\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\nimport { createJsonResponse } from \"#/response/json\";\n\n/** Default maximum body size in bytes. */\nconst BODY_LIMIT_MAX_DEFAULT = (10 * 1024 * 1024) as 10485760;\n\n/** Options for `bodyLimit` middleware. */\ntype BodyLimitOptions = {\n    /**\n     * Maximum body size in bytes.\n     *\n     * By default, it is `BODY_LIMIT_MAX_DEFAULT`.\n     */\n    max?: number;\n};\n\n/**\n * Body limit middleware.\n *\n * Following error will be returned if the body size is over the limit:\n *\n * ```jsonc\n * // Status: 413\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"too_large\",\n *             \"path\": [\n *                 \"request\",\n *                 \"body\"\n *             ],\n *             \"message\": \"Request body is too large\"\n *         }\n *     ]\n * }\n * ```\n *\n * For more information, please refer to\n * [Body Limit](https://hono.dev/docs/middleware/builtin/body-limit).\n *\n * ### Examples\n *\n * A example of using `bodyLimit` middleware:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { bodyLimit } from \"@jderstd/hono/body-limit\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(bodyLimit());\n * ```\n *\n * A example of using `bodyLimit` middleware with options:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { bodyLimit } from \"@jderstd/hono/body-limit\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(bodyLimit({\n *     max: 20 * 1024 * 1024, // 20MiB\n * }));\n * ```\n */\nconst bodyLimit = (options?: BodyLimitOptions): MiddlewareHandler => {\n    const code: ResponseErrorCode = ResponseErrorCode.TooLarge;\n\n    return _bodyLimit({\n        maxSize: options?.max ?? BODY_LIMIT_MAX_DEFAULT,\n        onError: (c: Context): Response => {\n            return createJsonResponse(c, {\n                status: 413,\n                errors: [\n                    {\n                        code,\n                        path: [\n                            \"request\",\n                            \"body\",\n                        ],\n                        message: getResponseErrorMessage(code),\n                    },\n                ],\n            });\n        },\n    });\n};\n\nexport type { BodyLimitOptions };\nexport { bodyLimit, BODY_LIMIT_MAX_DEFAULT };\n"],"mappings":";;;;;;;AAaA,MAAM,yBAA0B,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+D5C,MAAM,aAAa,YAAkD;CACjE,MAAMA,OAA0BC,yCAAkB;AAElD,uCAAkB;EACd,SAAS,SAAS,OAAO;EACzB,UAAU,MAAyB;AAC/B,UAAOC,iCAAmB,GAAG;IACzB,QAAQ;IACR,QAAQ,CACJ;KACI;KACA,MAAM,CACF,WACA,OACH;KACD,SAASC,+CAAwB,KAAK;KACzC,CACJ;IACJ,CAAC;;EAET,CAAC"}

package/dist/body-limit.mjs

@@ -0,0 +1,76 @@
+import { createJsonResponse } from "./response/json/index.mjs";
+import { ResponseErrorCode, getResponseErrorMessage } from "./response/error.mjs";
+import { bodyLimit as bodyLimit$1 } from "hono/body-limit";
+
+/** Default maximum body size in bytes. */
+const BODY_LIMIT_MAX_DEFAULT = 10 * 1024 * 1024;
+/**
+* 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
+* }));
+* ```
+*/
+const bodyLimit = (options) => {
+	const code = ResponseErrorCode.TooLarge;
+	return bodyLimit$1({
+		maxSize: options?.max ?? BODY_LIMIT_MAX_DEFAULT,
+		onError: (c) => {
+			return createJsonResponse(c, {
+				status: 413,
+				errors: [{
+					code,
+					path: ["request", "body"],
+					message: getResponseErrorMessage(code)
+				}]
+			});
+		}
+	});
+};
+
+export { BODY_LIMIT_MAX_DEFAULT, bodyLimit };
+//# sourceMappingURL=body-limit.mjs.map

package/dist/body-limit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"body-limit.mjs","names":["code: ResponseErrorCode","_bodyLimit"],"sources":["../src/middlewares/body-limit.ts"],"sourcesContent":["/**\n * Body limit module\n * @module middlewares/body-limit\n */\n\nimport type { Context, MiddlewareHandler } from \"hono\";\n\nimport { bodyLimit as _bodyLimit } from \"hono/body-limit\";\n\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\nimport { createJsonResponse } from \"#/response/json\";\n\n/** Default maximum body size in bytes. */\nconst BODY_LIMIT_MAX_DEFAULT = (10 * 1024 * 1024) as 10485760;\n\n/** Options for `bodyLimit` middleware. */\ntype BodyLimitOptions = {\n    /**\n     * Maximum body size in bytes.\n     *\n     * By default, it is `BODY_LIMIT_MAX_DEFAULT`.\n     */\n    max?: number;\n};\n\n/**\n * Body limit middleware.\n *\n * Following error will be returned if the body size is over the limit:\n *\n * ```jsonc\n * // Status: 413\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"too_large\",\n *             \"path\": [\n *                 \"request\",\n *                 \"body\"\n *             ],\n *             \"message\": \"Request body is too large\"\n *         }\n *     ]\n * }\n * ```\n *\n * For more information, please refer to\n * [Body Limit](https://hono.dev/docs/middleware/builtin/body-limit).\n *\n * ### Examples\n *\n * A example of using `bodyLimit` middleware:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { bodyLimit } from \"@jderstd/hono/body-limit\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(bodyLimit());\n * ```\n *\n * A example of using `bodyLimit` middleware with options:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { bodyLimit } from \"@jderstd/hono/body-limit\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(bodyLimit({\n *     max: 20 * 1024 * 1024, // 20MiB\n * }));\n * ```\n */\nconst bodyLimit = (options?: BodyLimitOptions): MiddlewareHandler => {\n    const code: ResponseErrorCode = ResponseErrorCode.TooLarge;\n\n    return _bodyLimit({\n        maxSize: options?.max ?? BODY_LIMIT_MAX_DEFAULT,\n        onError: (c: Context): Response => {\n            return createJsonResponse(c, {\n                status: 413,\n                errors: [\n                    {\n                        code,\n                        path: [\n                            \"request\",\n                            \"body\",\n                        ],\n                        message: getResponseErrorMessage(code),\n                    },\n                ],\n            });\n        },\n    });\n};\n\nexport type { BodyLimitOptions };\nexport { bodyLimit, BODY_LIMIT_MAX_DEFAULT };\n"],"mappings":";;;;;AAaA,MAAM,yBAA0B,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+D5C,MAAM,aAAa,YAAkD;CACjE,MAAMA,OAA0B,kBAAkB;AAElD,QAAOC,YAAW;EACd,SAAS,SAAS,OAAO;EACzB,UAAU,MAAyB;AAC/B,UAAO,mBAAmB,GAAG;IACzB,QAAQ;IACR,QAAQ,CACJ;KACI;KACA,MAAM,CACF,WACA,OACH;KACD,SAAS,wBAAwB,KAAK;KACzC,CACJ;IACJ,CAAC;;EAET,CAAC"}

package/dist/ip-limit.d.ts

@@ -0,0 +1,99 @@
+import { Context, MiddlewareHandler } from "hono";
+import { AddressType, ConnInfo, GetConnInfo, NetAddrInfo } from "hono/conninfo";
+import { IPRestrictionRule } from "hono/ip-restriction";
+import { Format } from "ts-vista";
+type GetIPAddr = GetConnInfo | ((c: Context) => string);
+/** Base options for `ipLimit` middleware. */
+type IpLimitBaseOptions = {
+  /** Allowed IP addresses. */
+  allowList?: IPRestrictionRule[];
+  /** Denied IP addresses. */
+  denyList?: IPRestrictionRule[];
+  /**
+   * Whether show more information.
+   * By default, it's `false`.
+   */
+  verbose?: boolean;
+};
+/** Options for `ipLimit` middleware. */
+type IpLimitOptions = Format<{
+  /** Function to get IP address. */
+  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: [],
+ *     })
+ * );
+ * ```
+ */
+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.
+ */
+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/ip-limit.js

@@ -0,0 +1,30 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_index = require('./response/json/index.js');
+require('./response.js');
+const require_response_error = require('./response/error.js');
+let hono_ip_restriction = require("hono/ip-restriction");
+hono_ip_restriction = require_rolldown_runtime.__toESM(hono_ip_restriction);
+
+function ipLimit(getConnInfoOrOptions, options) {
+	const code = require_response_error.ResponseErrorCode.Forbidden;
+	const getConnInfo = typeof getConnInfoOrOptions === "function" ? getConnInfoOrOptions : getConnInfoOrOptions.getConnInfo;
+	const { denyList, allowList, verbose } = (typeof getConnInfoOrOptions === "function" ? options : getConnInfoOrOptions) ?? {};
+	return (0, hono_ip_restriction.ipRestriction)(getConnInfo, {
+		denyList,
+		allowList
+	}, ({ addr }, c) => {
+		return require_index.createJsonResponse(c, {
+			status: 403,
+			errors: [{
+				code,
+				...verbose ? {
+					path: ["request", "ip"],
+					message: `${require_response_error.getResponseErrorMessage(code)}: ${addr}`
+				} : {}
+			}]
+		});
+	});
+}
+
+exports.ipLimit = ipLimit;
+//# sourceMappingURL=ip-limit.js.map

package/dist/ip-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip-limit.js","names":["code: ResponseErrorCode","ResponseErrorCode","getConnInfo: GetIPAddr","createJsonResponse","getResponseErrorMessage"],"sources":["../src/middlewares/ip-limit.ts"],"sourcesContent":["/**\n * IP limit module\n * @module middlewares/ip-limit\n */\n\nimport type { Context, MiddlewareHandler } from \"hono\";\nimport type {\n    AddressType,\n    ConnInfo,\n    GetConnInfo,\n    NetAddrInfo,\n} from \"hono/conninfo\";\nimport type { IPRestrictionRule } from \"hono/ip-restriction\";\nimport type { Format } from \"ts-vista\";\n\nimport { ipRestriction } from \"hono/ip-restriction\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\n\ntype GetIPAddr = GetConnInfo | ((c: Context) => string);\n\n/** Base options for `ipLimit` middleware. */\ntype IpLimitBaseOptions = {\n    /** Allowed IP addresses. */\n    allowList?: IPRestrictionRule[];\n    /** Denied IP addresses. */\n    denyList?: IPRestrictionRule[];\n    /**\n     * Whether show more information.\n     * By default, it's `false`.\n     */\n    verbose?: boolean;\n};\n\n/** Options for `ipLimit` middleware. */\ntype IpLimitOptions = Format<\n    {\n        /** Function to get IP address. */\n        getConnInfo: GetIPAddr;\n    } & IpLimitBaseOptions\n>;\n\n/**\n * IP limit middleware.\n *\n * Following error will be returned if the IP address is not allowed:\n *\n * ```jsonc\n * // Status: 403\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"forbidden\"\n *         }\n *     ]\n * }\n * ```\n *\n * When `verbose` is `true`, the error will be like:\n *\n * ```jsonc\n * // Status: 403\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"forbidden\",\n *             \"path\": [\n *                 \"request\",\n *                 \"ip\"\n *             ],\n *             \"message\": \"Forbidden IP address: x.x.x.x\"\n *         }\n *     ]\n * }\n * ```\n *\n * For more information, please refer to\n * [IP Restriction](https://hono.dev/docs/middleware/builtin/ip-restriction).\n *\n * For `getConnInfo`, please refer to\n * [ConnInfo helper](https://hono.dev/docs/helpers/conninfo).\n *\n * ### Example\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { ipLimit } from \"@jderstd/hono/ip-limit\";\n *\n * // getConnInfo helper for Node.js\n * import { getConnInfo } from \"@hono/node-server/conninfo\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(\n *     ipLimit({\n *         getConnInfo,\n *         allowList: [],\n *         denyList: [],\n *     })\n * );\n * ```\n */\nfunction ipLimit(options: IpLimitOptions): MiddlewareHandler;\n\n/**\n * IP limit middleware for compatibility with `hono/ip-restriction`.\n *\n * This is functionally equivalent to:\n *\n * ```ts\n * ipLimit({ getConnInfo, ...options });\n * ```\n *\n * And it behaves the same as the main `ipLimit` function.\n */\nfunction ipLimit(\n    getConnInfo: GetIPAddr,\n    options?: IpLimitBaseOptions,\n): MiddlewareHandler;\n\nfunction ipLimit(\n    getConnInfoOrOptions: GetIPAddr | IpLimitOptions,\n    options?: IpLimitBaseOptions,\n): MiddlewareHandler {\n    const code: ResponseErrorCode = ResponseErrorCode.Forbidden;\n\n    const getConnInfo: GetIPAddr =\n        typeof getConnInfoOrOptions === \"function\"\n            ? getConnInfoOrOptions\n            : getConnInfoOrOptions.getConnInfo;\n\n    const { denyList, allowList, verbose }: IpLimitBaseOptions =\n        (typeof getConnInfoOrOptions === \"function\"\n            ? options\n            : getConnInfoOrOptions) ?? {};\n\n    return ipRestriction(\n        getConnInfo,\n        {\n            denyList,\n            allowList,\n        },\n        ({ addr }, c: Context): Response => {\n            return createJsonResponse(c, {\n                status: 403,\n                errors: [\n                    {\n                        code,\n                        ...(verbose\n                            ? {\n                                  path: [\n                                      \"request\",\n                                      \"ip\",\n                                  ],\n                                  message: `${getResponseErrorMessage(code)}: ${addr}`,\n                              }\n                            : {}),\n                    },\n                ],\n            });\n        },\n    );\n}\n\nexport type {\n    AddressType,\n    NetAddrInfo,\n    ConnInfo,\n    GetConnInfo,\n    GetIPAddr,\n    IPRestrictionRule,\n};\nexport type { IpLimitBaseOptions, IpLimitOptions };\nexport { ipLimit };\n"],"mappings":";;;;;;;AA2HA,SAAS,QACL,sBACA,SACiB;CACjB,MAAMA,OAA0BC,yCAAkB;CAElD,MAAMC,cACF,OAAO,yBAAyB,aAC1B,uBACA,qBAAqB;CAE/B,MAAM,EAAE,UAAU,WAAW,aACxB,OAAO,yBAAyB,aAC3B,UACA,yBAAyB,EAAE;AAErC,+CACI,aACA;EACI;EACA;EACH,GACA,EAAE,QAAQ,MAAyB;AAChC,SAAOC,iCAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI;IACA,GAAI,UACE;KACI,MAAM,CACF,WACA,KACH;KACD,SAAS,GAAGC,+CAAwB,KAAK,CAAC,IAAI;KACjD,GACD,EAAE;IACX,CACJ;GACJ,CAAC;GAET"}

package/dist/ip-limit.mjs

@@ -0,0 +1,28 @@
+import { createJsonResponse } from "./response/json/index.mjs";
+import "./response.mjs";
+import { ResponseErrorCode, getResponseErrorMessage } from "./response/error.mjs";
+import { ipRestriction } from "hono/ip-restriction";
+
+function ipLimit(getConnInfoOrOptions, options) {
+	const code = ResponseErrorCode.Forbidden;
+	const getConnInfo = typeof getConnInfoOrOptions === "function" ? getConnInfoOrOptions : getConnInfoOrOptions.getConnInfo;
+	const { denyList, allowList, verbose } = (typeof getConnInfoOrOptions === "function" ? options : getConnInfoOrOptions) ?? {};
+	return ipRestriction(getConnInfo, {
+		denyList,
+		allowList
+	}, ({ addr }, c) => {
+		return createJsonResponse(c, {
+			status: 403,
+			errors: [{
+				code,
+				...verbose ? {
+					path: ["request", "ip"],
+					message: `${getResponseErrorMessage(code)}: ${addr}`
+				} : {}
+			}]
+		});
+	});
+}
+
+export { ipLimit };
+//# sourceMappingURL=ip-limit.mjs.map

package/dist/ip-limit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip-limit.mjs","names":["code: ResponseErrorCode","getConnInfo: GetIPAddr"],"sources":["../src/middlewares/ip-limit.ts"],"sourcesContent":["/**\n * IP limit module\n * @module middlewares/ip-limit\n */\n\nimport type { Context, MiddlewareHandler } from \"hono\";\nimport type {\n    AddressType,\n    ConnInfo,\n    GetConnInfo,\n    NetAddrInfo,\n} from \"hono/conninfo\";\nimport type { IPRestrictionRule } from \"hono/ip-restriction\";\nimport type { Format } from \"ts-vista\";\n\nimport { ipRestriction } from \"hono/ip-restriction\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\n\ntype GetIPAddr = GetConnInfo | ((c: Context) => string);\n\n/** Base options for `ipLimit` middleware. */\ntype IpLimitBaseOptions = {\n    /** Allowed IP addresses. */\n    allowList?: IPRestrictionRule[];\n    /** Denied IP addresses. */\n    denyList?: IPRestrictionRule[];\n    /**\n     * Whether show more information.\n     * By default, it's `false`.\n     */\n    verbose?: boolean;\n};\n\n/** Options for `ipLimit` middleware. */\ntype IpLimitOptions = Format<\n    {\n        /** Function to get IP address. */\n        getConnInfo: GetIPAddr;\n    } & IpLimitBaseOptions\n>;\n\n/**\n * IP limit middleware.\n *\n * Following error will be returned if the IP address is not allowed:\n *\n * ```jsonc\n * // Status: 403\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"forbidden\"\n *         }\n *     ]\n * }\n * ```\n *\n * When `verbose` is `true`, the error will be like:\n *\n * ```jsonc\n * // Status: 403\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"forbidden\",\n *             \"path\": [\n *                 \"request\",\n *                 \"ip\"\n *             ],\n *             \"message\": \"Forbidden IP address: x.x.x.x\"\n *         }\n *     ]\n * }\n * ```\n *\n * For more information, please refer to\n * [IP Restriction](https://hono.dev/docs/middleware/builtin/ip-restriction).\n *\n * For `getConnInfo`, please refer to\n * [ConnInfo helper](https://hono.dev/docs/helpers/conninfo).\n *\n * ### Example\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { ipLimit } from \"@jderstd/hono/ip-limit\";\n *\n * // getConnInfo helper for Node.js\n * import { getConnInfo } from \"@hono/node-server/conninfo\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(\n *     ipLimit({\n *         getConnInfo,\n *         allowList: [],\n *         denyList: [],\n *     })\n * );\n * ```\n */\nfunction ipLimit(options: IpLimitOptions): MiddlewareHandler;\n\n/**\n * IP limit middleware for compatibility with `hono/ip-restriction`.\n *\n * This is functionally equivalent to:\n *\n * ```ts\n * ipLimit({ getConnInfo, ...options });\n * ```\n *\n * And it behaves the same as the main `ipLimit` function.\n */\nfunction ipLimit(\n    getConnInfo: GetIPAddr,\n    options?: IpLimitBaseOptions,\n): MiddlewareHandler;\n\nfunction ipLimit(\n    getConnInfoOrOptions: GetIPAddr | IpLimitOptions,\n    options?: IpLimitBaseOptions,\n): MiddlewareHandler {\n    const code: ResponseErrorCode = ResponseErrorCode.Forbidden;\n\n    const getConnInfo: GetIPAddr =\n        typeof getConnInfoOrOptions === \"function\"\n            ? getConnInfoOrOptions\n            : getConnInfoOrOptions.getConnInfo;\n\n    const { denyList, allowList, verbose }: IpLimitBaseOptions =\n        (typeof getConnInfoOrOptions === \"function\"\n            ? options\n            : getConnInfoOrOptions) ?? {};\n\n    return ipRestriction(\n        getConnInfo,\n        {\n            denyList,\n            allowList,\n        },\n        ({ addr }, c: Context): Response => {\n            return createJsonResponse(c, {\n                status: 403,\n                errors: [\n                    {\n                        code,\n                        ...(verbose\n                            ? {\n                                  path: [\n                                      \"request\",\n                                      \"ip\",\n                                  ],\n                                  message: `${getResponseErrorMessage(code)}: ${addr}`,\n                              }\n                            : {}),\n                    },\n                ],\n            });\n        },\n    );\n}\n\nexport type {\n    AddressType,\n    NetAddrInfo,\n    ConnInfo,\n    GetConnInfo,\n    GetIPAddr,\n    IPRestrictionRule,\n};\nexport type { IpLimitBaseOptions, IpLimitOptions };\nexport { ipLimit };\n"],"mappings":";;;;;AA2HA,SAAS,QACL,sBACA,SACiB;CACjB,MAAMA,OAA0B,kBAAkB;CAElD,MAAMC,cACF,OAAO,yBAAyB,aAC1B,uBACA,qBAAqB;CAE/B,MAAM,EAAE,UAAU,WAAW,aACxB,OAAO,yBAAyB,aAC3B,UACA,yBAAyB,EAAE;AAErC,QAAO,cACH,aACA;EACI;EACA;EACH,GACA,EAAE,QAAQ,MAAyB;AAChC,SAAO,mBAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI;IACA,GAAI,UACE;KACI,MAAM,CACF,WACA,KACH;KACD,SAAS,GAAG,wBAAwB,KAAK,CAAC,IAAI;KACjD,GACD,EAAE;IACX,CACJ;GACJ,CAAC;GAET"}

package/dist/not-found.d.ts

@@ -0,0 +1,33 @@
+import { Context } from "hono";
+/**
+ * Not found handler.
+ *
+ * Following response will be reurned 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/not-found.js

@@ -0,0 +1,48 @@
+const require_index = require('./response/json/index.js');
+require('./response.js');
+const require_response_error = require('./response/error.js');
+
+/**
+* Not found handler.
+*
+* Following response will be reurned 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());
+* ```
+*/
+const notFoundHandler = () => {
+	const code = require_response_error.ResponseErrorCode.NotFound;
+	return (c) => {
+		return require_index.createJsonResponse(c, {
+			status: 404,
+			errors: [{
+				code,
+				message: require_response_error.getResponseErrorMessage(code)
+			}]
+		});
+	};
+};
+
+exports.notFoundHandler = notFoundHandler;
+//# sourceMappingURL=not-found.js.map

package/dist/not-found.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-found.js","names":["code: ResponseErrorCode","ResponseErrorCode","createJsonResponse","getResponseErrorMessage"],"sources":["../src/handlers/not-found.ts"],"sourcesContent":["import type { Context } from \"hono\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\n\n/**\n * Not found handler.\n *\n * Following response will be reurned on route not found:\n *\n * ```jsonc\n * // Status: 404\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"not_found\",\n *             \"message\": \"Content not found\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { notFoundHandler } from \"@jderstd/hono/not-found\";\n *\n * const app: Hono = new Hono();\n *\n * app.notFound(notFoundHandler());\n * ```\n */\nconst notFoundHandler = (): ((c: Context) => Response) => {\n    const code: ResponseErrorCode = ResponseErrorCode.NotFound;\n\n    return (c: Context): Response => {\n        return createJsonResponse(c, {\n            status: 404,\n            errors: [\n                {\n                    code,\n                    message: getResponseErrorMessage(code),\n                },\n            ],\n        });\n    };\n};\n\nexport { notFoundHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAM,wBAAoD;CACtD,MAAMA,OAA0BC,yCAAkB;AAElD,SAAQ,MAAyB;AAC7B,SAAOC,iCAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI;IACA,SAASC,+CAAwB,KAAK;IACzC,CACJ;GACJ,CAAC"}

package/dist/not-found.mjs

@@ -0,0 +1,48 @@
+import { createJsonResponse } from "./response/json/index.mjs";
+import "./response.mjs";
+import { ResponseErrorCode, getResponseErrorMessage } from "./response/error.mjs";
+
+/**
+* Not found handler.
+*
+* Following response will be reurned 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());
+* ```
+*/
+const notFoundHandler = () => {
+	const code = ResponseErrorCode.NotFound;
+	return (c) => {
+		return createJsonResponse(c, {
+			status: 404,
+			errors: [{
+				code,
+				message: getResponseErrorMessage(code)
+			}]
+		});
+	};
+};
+
+export { notFoundHandler };
+//# sourceMappingURL=not-found.mjs.map

package/dist/not-found.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-found.mjs","names":["code: ResponseErrorCode"],"sources":["../src/handlers/not-found.ts"],"sourcesContent":["import type { Context } from \"hono\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\n\n/**\n * Not found handler.\n *\n * Following response will be reurned on route not found:\n *\n * ```jsonc\n * // Status: 404\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"not_found\",\n *             \"message\": \"Content not found\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { notFoundHandler } from \"@jderstd/hono/not-found\";\n *\n * const app: Hono = new Hono();\n *\n * app.notFound(notFoundHandler());\n * ```\n */\nconst notFoundHandler = (): ((c: Context) => Response) => {\n    const code: ResponseErrorCode = ResponseErrorCode.NotFound;\n\n    return (c: Context): Response => {\n        return createJsonResponse(c, {\n            status: 404,\n            errors: [\n                {\n                    code,\n                    message: getResponseErrorMessage(code),\n                },\n            ],\n        });\n    };\n};\n\nexport { notFoundHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAM,wBAAoD;CACtD,MAAMA,OAA0B,kBAAkB;AAElD,SAAQ,MAAyB;AAC7B,SAAO,mBAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI;IACA,SAAS,wBAAwB,KAAK;IACzC,CACJ;GACJ,CAAC"}