@jderstd/hono 0.6.0

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

@@ -0,0 +1,110 @@
+import { Context } from "hono";
+import { Format, Omit } from "ts-vista";
+import { StatusCode } from "hono/utils/http-status";
+import { CreateJsonResponseStructOptions } from "@jderstd/core/response/json/struct";
+/** 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?: 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",
+ *             },
+ *         ],
+ *     });
+ * };
+ * ```
+ */
+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",
+ *             },
+ *         ],
+ *     });
+ * };
+ * ```
+ */
+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

@@ -0,0 +1,23 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+let __jderstd_core_response_json_struct = require("@jderstd/core/response/json/struct");
+__jderstd_core_response_json_struct = require_rolldown_runtime.__toESM(__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);
+	if (isContext(contextOrOptions)) {
+		const c = contextOrOptions;
+		c.status(status);
+		for (const [key, value] of headers) c.header(key, value);
+		return c.json(json);
+	}
+	return new Response(JSON.stringify(json), {
+		status,
+		headers
+	});
+}
+
+exports.createJsonResponse = createJsonResponse;
+exports.isContext = isContext;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +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"}

package/dist/response/json/index.mjs

@@ -0,0 +1,20 @@
+import { createJsonResponseStruct } from "@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) ? createJsonResponseStruct(options) : createJsonResponseStruct(contextOrOptions);
+	if (isContext(contextOrOptions)) {
+		const c = contextOrOptions;
+		c.status(status);
+		for (const [key, value] of headers) c.header(key, value);
+		return c.json(json);
+	}
+	return new Response(JSON.stringify(json), {
+		status,
+		headers
+	});
+}
+
+export { createJsonResponse, isContext };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","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,GACvD,yBAAyB,QAAQ,GACjC,yBAAyB,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

@@ -0,0 +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 };

package/dist/response.js

@@ -0,0 +1,5 @@
+const require_index = require('./response/json/index.js');
+const require_index$1 = require('./response/common/index.js');
+
+exports.createJsonResponse = require_index.createJsonResponse;
+exports.createResponse = require_index$1.createResponse;

package/dist/response.mjs

@@ -0,0 +1,4 @@
+import { createJsonResponse } from "./response/json/index.mjs";
+import { createResponse } from "./response/common/index.mjs";
+
+export { createJsonResponse, createResponse };

package/dist/time-limit.d.ts

@@ -0,0 +1,62 @@
+import { MiddlewareHandler } from "hono";
+/** Default maximum time in milliseconds. */
+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`.
+   */
+  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
+ * }));
+ * ```
+ */
+declare const timeLimit: (options?: TimeLimitOptions) => MiddlewareHandler;
+export { TIME_LIMIT_MAX_DEFAULT, type TimeLimitOptions, timeLimit };
+//# sourceMappingURL=time-limit.d.ts.map

package/dist/time-limit.js

@@ -0,0 +1,74 @@
+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_http_exception = require("hono/http-exception");
+hono_http_exception = require_rolldown_runtime.__toESM(hono_http_exception);
+let hono_timeout = require("hono/timeout");
+hono_timeout = require_rolldown_runtime.__toESM(hono_timeout);
+
+/** Default maximum time in milliseconds. */
+const TIME_LIMIT_MAX_DEFAULT = 5 * 1e3;
+/**
+* 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
+* }));
+* ```
+*/
+const timeLimit = (options) => {
+	const status = 504;
+	const code = require_response_error.ResponseErrorCode.Timeout;
+	return (0, hono_timeout.timeout)(options?.max ?? 5 * 1e3, (c) => {
+		return new hono_http_exception.HTTPException(status, { res: require_index.createJsonResponse(c, {
+			status,
+			errors: [{
+				code,
+				message: require_response_error.getResponseErrorMessage(code)
+			}]
+		}) });
+	});
+};
+
+exports.TIME_LIMIT_MAX_DEFAULT = TIME_LIMIT_MAX_DEFAULT;
+exports.timeLimit = timeLimit;
+//# sourceMappingURL=time-limit.js.map

package/dist/time-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-limit.js","names":["status: StatusCode","code: ResponseErrorCode","ResponseErrorCode","HTTPException","createJsonResponse","getResponseErrorMessage"],"sources":["../src/middlewares/time-limit.ts"],"sourcesContent":["/**\n * Time limit module\n * @module middlewares/time-limit\n */\n\nimport type { Context, MiddlewareHandler } from \"hono\";\nimport type { StatusCode } from \"hono/utils/http-status\";\n\nimport { HTTPException } from \"hono/http-exception\";\nimport { timeout } from \"hono/timeout\";\n\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\nimport { createJsonResponse } from \"#/response/json\";\n\n/** Default maximum time in milliseconds. */\nconst TIME_LIMIT_MAX_DEFAULT = (5 * 1000) as 5000;\n\n/** Options for `timeLimit` middleware. */\ntype TimeLimitOptions = {\n    /**\n     * Maximum time in milliseconds.\n     *\n     * By default, it is `TIME_LIMIT_MAX_DEFAULT`.\n     */\n    max?: number;\n};\n\n/**\n * Time limit middleware.\n *\n * Following error will be returned if the request takes longer than the limit:\n *\n * ```jsonc\n * // Status: 504\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"timeout\",\n *             \"message\": \"Request timeout\"\n *         }\n *     ]\n * }\n * ```\n *\n * For more information, please refer to\n * [Timeout](https://hono.dev/docs/middleware/builtin/timeout).\n *\n * ### Examples\n *\n * A example of using `timeLimit` middleware:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { timeLimit } from \"@jderstd/hono/time-limit\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(timeLimit());\n * ```\n *\n * A example of using `timeLimit` middleware with options:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { timeLimit } from \"@jderstd/hono/time-limit\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(timeLimit({\n *     max: 10 * 1000, // 10s\n * }));\n * ```\n */\nconst timeLimit = (options?: TimeLimitOptions): MiddlewareHandler => {\n    const status: StatusCode = 504;\n    const code: ResponseErrorCode = ResponseErrorCode.Timeout;\n\n    return timeout(options?.max ?? 5 * 1000, (c: Context): HTTPException => {\n        return new HTTPException(status, {\n            res: createJsonResponse(c, {\n                status,\n                errors: [\n                    {\n                        code,\n                        message: getResponseErrorMessage(code),\n                    },\n                ],\n            }),\n        });\n    });\n};\n\nexport type { TimeLimitOptions };\nexport { timeLimit, TIME_LIMIT_MAX_DEFAULT };\n"],"mappings":";;;;;;;;;AAeA,MAAM,yBAA0B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DpC,MAAM,aAAa,YAAkD;CACjE,MAAMA,SAAqB;CAC3B,MAAMC,OAA0BC,yCAAkB;AAElD,kCAAe,SAAS,OAAO,IAAI,MAAO,MAA8B;AACpE,SAAO,IAAIC,kCAAc,QAAQ,EAC7B,KAAKC,iCAAmB,GAAG;GACvB;GACA,QAAQ,CACJ;IACI;IACA,SAASC,+CAAwB,KAAK;IACzC,CACJ;GACJ,CAAC,EACL,CAAC;GACJ"}

package/dist/time-limit.mjs

@@ -0,0 +1,70 @@
+import { createJsonResponse } from "./response/json/index.mjs";
+import { ResponseErrorCode, getResponseErrorMessage } from "./response/error.mjs";
+import { HTTPException } from "hono/http-exception";
+import { timeout } from "hono/timeout";
+
+/** Default maximum time in milliseconds. */
+const TIME_LIMIT_MAX_DEFAULT = 5 * 1e3;
+/**
+* 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
+* }));
+* ```
+*/
+const timeLimit = (options) => {
+	const status = 504;
+	const code = ResponseErrorCode.Timeout;
+	return timeout(options?.max ?? 5 * 1e3, (c) => {
+		return new HTTPException(status, { res: createJsonResponse(c, {
+			status,
+			errors: [{
+				code,
+				message: getResponseErrorMessage(code)
+			}]
+		}) });
+	});
+};
+
+export { TIME_LIMIT_MAX_DEFAULT, timeLimit };
+//# sourceMappingURL=time-limit.mjs.map

package/dist/time-limit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-limit.mjs","names":["status: StatusCode","code: ResponseErrorCode"],"sources":["../src/middlewares/time-limit.ts"],"sourcesContent":["/**\n * Time limit module\n * @module middlewares/time-limit\n */\n\nimport type { Context, MiddlewareHandler } from \"hono\";\nimport type { StatusCode } from \"hono/utils/http-status\";\n\nimport { HTTPException } from \"hono/http-exception\";\nimport { timeout } from \"hono/timeout\";\n\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\nimport { createJsonResponse } from \"#/response/json\";\n\n/** Default maximum time in milliseconds. */\nconst TIME_LIMIT_MAX_DEFAULT = (5 * 1000) as 5000;\n\n/** Options for `timeLimit` middleware. */\ntype TimeLimitOptions = {\n    /**\n     * Maximum time in milliseconds.\n     *\n     * By default, it is `TIME_LIMIT_MAX_DEFAULT`.\n     */\n    max?: number;\n};\n\n/**\n * Time limit middleware.\n *\n * Following error will be returned if the request takes longer than the limit:\n *\n * ```jsonc\n * // Status: 504\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"timeout\",\n *             \"message\": \"Request timeout\"\n *         }\n *     ]\n * }\n * ```\n *\n * For more information, please refer to\n * [Timeout](https://hono.dev/docs/middleware/builtin/timeout).\n *\n * ### Examples\n *\n * A example of using `timeLimit` middleware:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { timeLimit } from \"@jderstd/hono/time-limit\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(timeLimit());\n * ```\n *\n * A example of using `timeLimit` middleware with options:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { timeLimit } from \"@jderstd/hono/time-limit\";\n *\n * const app: Hono = new Hono();\n *\n * app.use(timeLimit({\n *     max: 10 * 1000, // 10s\n * }));\n * ```\n */\nconst timeLimit = (options?: TimeLimitOptions): MiddlewareHandler => {\n    const status: StatusCode = 504;\n    const code: ResponseErrorCode = ResponseErrorCode.Timeout;\n\n    return timeout(options?.max ?? 5 * 1000, (c: Context): HTTPException => {\n        return new HTTPException(status, {\n            res: createJsonResponse(c, {\n                status,\n                errors: [\n                    {\n                        code,\n                        message: getResponseErrorMessage(code),\n                    },\n                ],\n            }),\n        });\n    });\n};\n\nexport type { TimeLimitOptions };\nexport { timeLimit, TIME_LIMIT_MAX_DEFAULT };\n"],"mappings":";;;;;;AAeA,MAAM,yBAA0B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DpC,MAAM,aAAa,YAAkD;CACjE,MAAMA,SAAqB;CAC3B,MAAMC,OAA0B,kBAAkB;AAElD,QAAO,QAAQ,SAAS,OAAO,IAAI,MAAO,MAA8B;AACpE,SAAO,IAAI,cAAc,QAAQ,EAC7B,KAAK,mBAAmB,GAAG;GACvB;GACA,QAAQ,CACJ;IACI;IACA,SAAS,wBAAwB,KAAK;IACzC,CACJ;GACJ,CAAC,EACL,CAAC;GACJ"}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@jderstd/hono",
+  "version": "0.6.0",
+  "description": "A response builder for Hono",
+  "keywords": [
+    "jder",
+    "hono",
+    "response",
+    "ts",
+    "typescript",
+    "js",
+    "javascript"
+  ],
+  "homepage": "https://github.com/jderstd/hono",
+  "bugs": "https://github.com/jderstd/hono/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jderstd/hono.git",
+    "directory": "packages/hono"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Alpheus",
+    "email": "contact@alphe.us"
+  },
+  "exports": {
+    "./response": {
+      "types": "./dist/response.d.ts",
+      "import": "./dist/response.mjs",
+      "require": "./dist/response.js"
+    },
+    "./response/error": {
+      "types": "./dist/response/error.d.ts",
+      "import": "./dist/response/error.mjs",
+      "require": "./dist/response/error.js"
+    },
+    "./body-limit": {
+      "types": "./dist/body-limit.d.ts",
+      "import": "./dist/body-limit.mjs",
+      "require": "./dist/body-limit.js"
+    },
+    "./ip-limit": {
+      "types": "./dist/ip-limit.d.ts",
+      "import": "./dist/ip-limit.mjs",
+      "require": "./dist/ip-limit.js"
+    },
+    "./time-limit": {
+      "types": "./dist/time-limit.d.ts",
+      "import": "./dist/time-limit.mjs",
+      "require": "./dist/time-limit.js"
+    },
+    "./not-found": {
+      "types": "./dist/not-found.d.ts",
+      "import": "./dist/not-found.mjs",
+      "require": "./dist/not-found.js"
+    },
+    "./on-error": {
+      "types": "./dist/on-error.d.ts",
+      "import": "./dist/on-error.mjs",
+      "require": "./dist/on-error.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/response.js",
+  "module": "./dist/response.mjs",
+  "types": "./dist/response.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@jderstd/core": "~0.4.0",
+    "ts-vista": "~0.2.2"
+  },
+  "devDependencies": {
+    "hono": "4.5.0"
+  },
+  "peerDependencies": {
+    "hono": "^4.5.0"
+  }
+}