@jderstd/hono-zod-validator 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,9 @@
+# JDER Hono Zod Validator
+
+A Zod validator for Hono.
+
+This package includes a Zod validator based on the JSON response structure specified in [JSON Data Errors Response (JDER)](https://github.com/jderstd/spec). With the validator, various kinds of requests can be validated easily and send JSON responses instead of plain text responses.
+
+## 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/hook.d.ts

@@ -0,0 +1,21 @@
+import { Context, Env, TypedResponse, ValidationTargets } from "hono";
+import * as v3 from "zod/v3";
+import * as v4 from "zod/v4/core";
+/** Zod schema for both v3 and v4. */
+type ZodSchema = v3.ZodType | v4.$ZodType;
+/** Zod error for both v3 and v4. */
+type ZodError<T extends ZodSchema> = T extends v4.$ZodType ? v4.$ZodError : v3.ZodError;
+/**
+ * Zod validator hook.
+ */
+declare const zValidatorHook: <T, E extends Env, P extends string, Target extends keyof ValidationTargets = keyof ValidationTargets, O = {}, Schema extends ZodSchema = any>(result: ({
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: ZodError<Schema>;
+}) & {
+  target: Target;
+}, c: Context<E, P>) => Response | void | TypedResponse<O> | Promise<Response | void | TypedResponse<O>>;
+export { type ZodError, type ZodSchema, zValidatorHook };
+//# sourceMappingURL=hook.d.ts.map

package/dist/hook.js

@@ -0,0 +1,29 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let __jderstd_hono_response = require("@jderstd/hono/response");
+__jderstd_hono_response = require_rolldown_runtime.__toESM(__jderstd_hono_response);
+let __jderstd_hono_response_error = require("@jderstd/hono/response/error");
+__jderstd_hono_response_error = require_rolldown_runtime.__toESM(__jderstd_hono_response_error);
+let hono_http_exception = require("hono/http-exception");
+hono_http_exception = require_rolldown_runtime.__toESM(hono_http_exception);
+
+/**
+* Zod validator hook.
+*/
+const zValidatorHook = (result, c) => {
+	if (result.success) return void 0;
+	const errors = [];
+	const errs = result.error.issues;
+	for (let i = 0; i < errs.length; i++) {
+		const err = errs[i];
+		if (!err) continue;
+		errors.push({
+			code: __jderstd_hono_response_error.ResponseErrorCode.Parse,
+			path: err.path.map((p) => String(p)),
+			message: err.message
+		});
+	}
+	throw new hono_http_exception.HTTPException(400, { res: (0, __jderstd_hono_response.createJsonResponse)(c, { errors }) });
+};
+
+exports.zValidatorHook = zValidatorHook;
+//# sourceMappingURL=hook.js.map

package/dist/hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.js","names":["errors: JsonResponseError[]","errs: v4.$ZodIssue[] | v3.ZodIssue[]","i: number","err: v4.$ZodIssue | v3.ZodIssue | undefined","ResponseErrorCode","HTTPException"],"sources":["../src/hook.ts"],"sourcesContent":["import type { JsonResponseError } from \"@jderstd/hono/response\";\nimport type { Context, Env, TypedResponse, ValidationTargets } from \"hono\";\nimport type * as v3 from \"zod/v3\";\nimport type * as v4 from \"zod/v4/core\";\n\nimport { createJsonResponse } from \"@jderstd/hono/response\";\nimport { ResponseErrorCode } from \"@jderstd/hono/response/error\";\nimport { HTTPException } from \"hono/http-exception\";\n\n/** Zod schema for both v3 and v4. */\ntype ZodSchema = v3.ZodType | v4.$ZodType;\n\n/** Zod error for both v3 and v4. */\ntype ZodError<T extends ZodSchema> = T extends v4.$ZodType\n    ? v4.$ZodError\n    : v3.ZodError;\n\n/**\n * Zod validator hook.\n */\nconst zValidatorHook = <\n    T,\n    E extends Env,\n    P extends string,\n    Target extends keyof ValidationTargets = keyof ValidationTargets,\n    // biome-ignore lint/complexity/noBannedTypes: any non-nullable value\n    O = {},\n    Schema extends ZodSchema = any,\n>(\n    result: (\n        | {\n              success: true;\n              data: T;\n          }\n        | {\n              success: false;\n              error: ZodError<Schema>;\n          }\n    ) & {\n        target: Target;\n    },\n    c: Context<E, P>,\n):\n    | Response\n    | void\n    | TypedResponse<O>\n    // biome-ignore lint/suspicious/noConfusingVoidType: return type\n    | Promise<Response | void | TypedResponse<O>> => {\n    if (result.success) return void 0;\n\n    const errors: JsonResponseError[] = [];\n\n    const errs: v4.$ZodIssue[] | v3.ZodIssue[] = result.error.issues;\n\n    for (let i: number = 0; i < errs.length; i++) {\n        const err: v4.$ZodIssue | v3.ZodIssue | undefined = errs[i];\n\n        if (!err) continue;\n\n        errors.push({\n            code: ResponseErrorCode.Parse,\n            path: err.path.map((p): string => String(p)),\n            message: err.message,\n        });\n    }\n\n    throw new HTTPException(400, {\n        res: createJsonResponse(c, {\n            errors,\n        }),\n    });\n};\n\nexport type { ZodSchema, ZodError };\nexport { zValidatorHook };\n"],"mappings":";;;;;;;;;;;AAoBA,MAAM,kBASF,QAYA,MAMiD;AACjD,KAAI,OAAO,QAAS,QAAO,KAAK;CAEhC,MAAMA,SAA8B,EAAE;CAEtC,MAAMC,OAAuC,OAAO,MAAM;AAE1D,MAAK,IAAIC,IAAY,GAAG,IAAI,KAAK,QAAQ,KAAK;EAC1C,MAAMC,MAA8C,KAAK;AAEzD,MAAI,CAAC,IAAK;AAEV,SAAO,KAAK;GACR,MAAMC,gDAAkB;GACxB,MAAM,IAAI,KAAK,KAAK,MAAc,OAAO,EAAE,CAAC;GAC5C,SAAS,IAAI;GAChB,CAAC;;AAGN,OAAM,IAAIC,kCAAc,KAAK,EACzB,qDAAwB,GAAG,EACvB,QACH,CAAC,EACL,CAAC"}

package/dist/hook.mjs

@@ -0,0 +1,25 @@
+import { createJsonResponse } from "@jderstd/hono/response";
+import { ResponseErrorCode } from "@jderstd/hono/response/error";
+import { HTTPException } from "hono/http-exception";
+
+/**
+* Zod validator hook.
+*/
+const zValidatorHook = (result, c) => {
+	if (result.success) return void 0;
+	const errors = [];
+	const errs = result.error.issues;
+	for (let i = 0; i < errs.length; i++) {
+		const err = errs[i];
+		if (!err) continue;
+		errors.push({
+			code: ResponseErrorCode.Parse,
+			path: err.path.map((p) => String(p)),
+			message: err.message
+		});
+	}
+	throw new HTTPException(400, { res: createJsonResponse(c, { errors }) });
+};
+
+export { zValidatorHook };
+//# sourceMappingURL=hook.mjs.map

package/dist/hook.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.mjs","names":["errors: JsonResponseError[]","errs: v4.$ZodIssue[] | v3.ZodIssue[]","i: number","err: v4.$ZodIssue | v3.ZodIssue | undefined"],"sources":["../src/hook.ts"],"sourcesContent":["import type { JsonResponseError } from \"@jderstd/hono/response\";\nimport type { Context, Env, TypedResponse, ValidationTargets } from \"hono\";\nimport type * as v3 from \"zod/v3\";\nimport type * as v4 from \"zod/v4/core\";\n\nimport { createJsonResponse } from \"@jderstd/hono/response\";\nimport { ResponseErrorCode } from \"@jderstd/hono/response/error\";\nimport { HTTPException } from \"hono/http-exception\";\n\n/** Zod schema for both v3 and v4. */\ntype ZodSchema = v3.ZodType | v4.$ZodType;\n\n/** Zod error for both v3 and v4. */\ntype ZodError<T extends ZodSchema> = T extends v4.$ZodType\n    ? v4.$ZodError\n    : v3.ZodError;\n\n/**\n * Zod validator hook.\n */\nconst zValidatorHook = <\n    T,\n    E extends Env,\n    P extends string,\n    Target extends keyof ValidationTargets = keyof ValidationTargets,\n    // biome-ignore lint/complexity/noBannedTypes: any non-nullable value\n    O = {},\n    Schema extends ZodSchema = any,\n>(\n    result: (\n        | {\n              success: true;\n              data: T;\n          }\n        | {\n              success: false;\n              error: ZodError<Schema>;\n          }\n    ) & {\n        target: Target;\n    },\n    c: Context<E, P>,\n):\n    | Response\n    | void\n    | TypedResponse<O>\n    // biome-ignore lint/suspicious/noConfusingVoidType: return type\n    | Promise<Response | void | TypedResponse<O>> => {\n    if (result.success) return void 0;\n\n    const errors: JsonResponseError[] = [];\n\n    const errs: v4.$ZodIssue[] | v3.ZodIssue[] = result.error.issues;\n\n    for (let i: number = 0; i < errs.length; i++) {\n        const err: v4.$ZodIssue | v3.ZodIssue | undefined = errs[i];\n\n        if (!err) continue;\n\n        errors.push({\n            code: ResponseErrorCode.Parse,\n            path: err.path.map((p): string => String(p)),\n            message: err.message,\n        });\n    }\n\n    throw new HTTPException(400, {\n        res: createJsonResponse(c, {\n            errors,\n        }),\n    });\n};\n\nexport type { ZodSchema, ZodError };\nexport { zValidatorHook };\n"],"mappings":";;;;;;;AAoBA,MAAM,kBASF,QAYA,MAMiD;AACjD,KAAI,OAAO,QAAS,QAAO,KAAK;CAEhC,MAAMA,SAA8B,EAAE;CAEtC,MAAMC,OAAuC,OAAO,MAAM;AAE1D,MAAK,IAAIC,IAAY,GAAG,IAAI,KAAK,QAAQ,KAAK;EAC1C,MAAMC,MAA8C,KAAK;AAEzD,MAAI,CAAC,IAAK;AAEV,SAAO,KAAK;GACR,MAAM,kBAAkB;GACxB,MAAM,IAAI,KAAK,KAAK,MAAc,OAAO,EAAE,CAAC;GAC5C,SAAS,IAAI;GAChB,CAAC;;AAGN,OAAM,IAAI,cAAc,KAAK,EACzB,KAAK,mBAAmB,GAAG,EACvB,QACH,CAAC,EACL,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+import { ZodSchema } from "./hook.js";
+import * as hono0 from "hono";
+import { ValidationTargets } from "hono";
+import * as zod_v4_core0 from "zod/v4/core";
+import * as zod0 from "zod";
+import * as zod_v40 from "zod/v4";
+/**
+ * Validate the request with Zod.
+ *
+ * Following error may returned if the request is invalid:
+ *
+ * ```jsonc
+ * // Status: 400
+ * {
+ *     "success": false,
+ *     "errors": [
+ *         {
+ *             "code": "parse",
+ *             "path": ["xxx"],
+ *             "message": "xxx"
+ *         }
+ *     ]
+ * }
+ * ```
+ *
+ * ### Example
+ *
+ * ```ts
+ * import type { Context, Env } from "hono";
+ *
+ * import { Hono } from "hono";
+ * import { z } from "zod";
+ * import { zValidator } from "@jderstd/hono-zod-validator";
+ *
+ * const app: Hono = new Hono();
+ *
+ * const json = z.object({
+ *     name: z.string(),
+ *     age: z.number()
+ * });
+ *
+ * type Json = z.infer<typeof json>;
+ *
+ * type RouteContext = Context<
+ *     Env,
+ *     "/",
+ *     {
+ *         in: {
+ *             json: Json;
+ *         },
+ *         out: {
+ *             json: Json;
+ *         },
+ *     },
+ * >;
+ *
+ * app.post(
+ *     "/",
+ *     zValidator("json", json),
+ *     (c: RouteContext): Response => {
+ *         const data: Json = c.req.valid("json");
+ *         return c.json(data);
+ *     }
+ * );
+ * ```
+ */
+declare const zValidator: <T extends ZodSchema, Target extends keyof ValidationTargets>(target: Target, schema: T) => hono0.MiddlewareHandler<hono0.Env, string, {
+  in: (undefined extends (T extends zod0.ZodType<any, zod0.ZodTypeDef, any> ? zod0.input<T> : T extends zod_v4_core0.$ZodType<unknown, unknown> ? zod_v40.input<T> : never) ? true : false) extends true ? { [K in Target]?: ((T extends zod0.ZodType<any, zod0.ZodTypeDef, any> ? zod0.input<T> : T extends zod_v4_core0.$ZodType<unknown, unknown> ? zod_v40.input<T> : never) extends infer T_1 ? T_1 extends (T extends zod0.ZodType<any, zod0.ZodTypeDef, any> ? zod0.input<T> : T extends zod_v4_core0.$ZodType<unknown, unknown> ? zod_v40.input<T> : never) ? T_1 extends ValidationTargets[K] ? T_1 : { [K2 in keyof T_1]?: ValidationTargets[K][K2] | undefined } : never : never) | undefined } : { [K_1 in Target]: (T extends zod0.ZodType<any, zod0.ZodTypeDef, any> ? zod0.input<T> : T extends zod_v4_core0.$ZodType<unknown, unknown> ? zod_v40.input<T> : never) extends infer T_1 ? T_1 extends (T extends zod0.ZodType<any, zod0.ZodTypeDef, any> ? zod0.input<T> : T extends zod_v4_core0.$ZodType<unknown, unknown> ? zod_v40.input<T> : never) ? T_1 extends ValidationTargets[K_1] ? T_1 : { [K2 in keyof T_1]: ValidationTargets[K_1][K2] } : never : never };
+  out: { [K_2 in Target]: T extends zod0.ZodType<any, zod0.ZodTypeDef, any> ? zod0.output<T> : T extends zod_v4_core0.$ZodType<unknown, unknown> ? zod_v40.infer<T> : never };
+}>;
+export { zValidator };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,71 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_hook = require('./hook.js');
+let __hono_zod_validator = require("@hono/zod-validator");
+__hono_zod_validator = require_rolldown_runtime.__toESM(__hono_zod_validator);
+
+/**
+* Validate the request with Zod.
+*
+* Following error may returned if the request is invalid:
+*
+* ```jsonc
+* // Status: 400
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "parse",
+*             "path": ["xxx"],
+*             "message": "xxx"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Example
+*
+* ```ts
+* import type { Context, Env } from "hono";
+*
+* import { Hono } from "hono";
+* import { z } from "zod";
+* import { zValidator } from "@jderstd/hono-zod-validator";
+*
+* const app: Hono = new Hono();
+*
+* const json = z.object({
+*     name: z.string(),
+*     age: z.number()
+* });
+*
+* type Json = z.infer<typeof json>;
+*
+* type RouteContext = Context<
+*     Env,
+*     "/",
+*     {
+*         in: {
+*             json: Json;
+*         },
+*         out: {
+*             json: Json;
+*         },
+*     },
+* >;
+*
+* app.post(
+*     "/",
+*     zValidator("json", json),
+*     (c: RouteContext): Response => {
+*         const data: Json = c.req.valid("json");
+*         return c.json(data);
+*     }
+* );
+* ```
+*/
+const zValidator = (target, schema) => {
+	return (0, __hono_zod_validator.zValidator)(target, schema, require_hook.zValidatorHook);
+};
+
+exports.zValidator = zValidator;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["zValidatorHook"],"sources":["../src/index.ts"],"sourcesContent":["import type { ValidationTargets } from \"hono\";\n\nimport type { ZodSchema } from \"#/hook\";\n\nimport { zValidator as zv } from \"@hono/zod-validator\";\n\nimport { zValidatorHook } from \"#/hook\";\n\n/**\n * Validate the request with Zod.\n *\n * Following error may returned if the request is invalid:\n *\n * ```jsonc\n * // Status: 400\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"parse\",\n *             \"path\": [\"xxx\"],\n *             \"message\": \"xxx\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import type { Context, Env } from \"hono\";\n *\n * import { Hono } from \"hono\";\n * import { z } from \"zod\";\n * import { zValidator } from \"@jderstd/hono-zod-validator\";\n *\n * const app: Hono = new Hono();\n *\n * const json = z.object({\n *     name: z.string(),\n *     age: z.number()\n * });\n *\n * type Json = z.infer<typeof json>;\n *\n * type RouteContext = Context<\n *     Env,\n *     \"/\",\n *     {\n *         in: {\n *             json: Json;\n *         },\n *         out: {\n *             json: Json;\n *         },\n *     },\n * >;\n *\n * app.post(\n *     \"/\",\n *     zValidator(\"json\", json),\n *     (c: RouteContext): Response => {\n *         const data: Json = c.req.valid(\"json\");\n *         return c.json(data);\n *     }\n * );\n * ```\n */\nconst zValidator = <\n    T extends ZodSchema,\n    Target extends keyof ValidationTargets,\n>(\n    target: Target,\n    schema: T,\n) => {\n    return zv(target, schema, zValidatorHook);\n};\n\nexport { zValidator };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,MAAM,cAIF,QACA,WACC;AACD,6CAAU,QAAQ,QAAQA,4BAAe"}

package/dist/index.mjs

@@ -0,0 +1,69 @@
+import { zValidatorHook } from "./hook.mjs";
+import { zValidator as zValidator$1 } from "@hono/zod-validator";
+
+/**
+* Validate the request with Zod.
+*
+* Following error may returned if the request is invalid:
+*
+* ```jsonc
+* // Status: 400
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "parse",
+*             "path": ["xxx"],
+*             "message": "xxx"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Example
+*
+* ```ts
+* import type { Context, Env } from "hono";
+*
+* import { Hono } from "hono";
+* import { z } from "zod";
+* import { zValidator } from "@jderstd/hono-zod-validator";
+*
+* const app: Hono = new Hono();
+*
+* const json = z.object({
+*     name: z.string(),
+*     age: z.number()
+* });
+*
+* type Json = z.infer<typeof json>;
+*
+* type RouteContext = Context<
+*     Env,
+*     "/",
+*     {
+*         in: {
+*             json: Json;
+*         },
+*         out: {
+*             json: Json;
+*         },
+*     },
+* >;
+*
+* app.post(
+*     "/",
+*     zValidator("json", json),
+*     (c: RouteContext): Response => {
+*         const data: Json = c.req.valid("json");
+*         return c.json(data);
+*     }
+* );
+* ```
+*/
+const zValidator = (target, schema) => {
+	return zValidator$1(target, schema, zValidatorHook);
+};
+
+export { zValidator };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["zv"],"sources":["../src/index.ts"],"sourcesContent":["import type { ValidationTargets } from \"hono\";\n\nimport type { ZodSchema } from \"#/hook\";\n\nimport { zValidator as zv } from \"@hono/zod-validator\";\n\nimport { zValidatorHook } from \"#/hook\";\n\n/**\n * Validate the request with Zod.\n *\n * Following error may returned if the request is invalid:\n *\n * ```jsonc\n * // Status: 400\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"parse\",\n *             \"path\": [\"xxx\"],\n *             \"message\": \"xxx\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import type { Context, Env } from \"hono\";\n *\n * import { Hono } from \"hono\";\n * import { z } from \"zod\";\n * import { zValidator } from \"@jderstd/hono-zod-validator\";\n *\n * const app: Hono = new Hono();\n *\n * const json = z.object({\n *     name: z.string(),\n *     age: z.number()\n * });\n *\n * type Json = z.infer<typeof json>;\n *\n * type RouteContext = Context<\n *     Env,\n *     \"/\",\n *     {\n *         in: {\n *             json: Json;\n *         },\n *         out: {\n *             json: Json;\n *         },\n *     },\n * >;\n *\n * app.post(\n *     \"/\",\n *     zValidator(\"json\", json),\n *     (c: RouteContext): Response => {\n *         const data: Json = c.req.valid(\"json\");\n *         return c.json(data);\n *     }\n * );\n * ```\n */\nconst zValidator = <\n    T extends ZodSchema,\n    Target extends keyof ValidationTargets,\n>(\n    target: Target,\n    schema: T,\n) => {\n    return zv(target, schema, zValidatorHook);\n};\n\nexport { zValidator };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,MAAM,cAIF,QACA,WACC;AACD,QAAOA,aAAG,QAAQ,QAAQ,eAAe"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@jderstd/hono-zod-validator",
+  "version": "0.6.0",
+  "description": "A Zod validator for Hono",
+  "keywords": [
+    "jder",
+    "hono",
+    "zod",
+    "validator",
+    "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-zod-validator"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Alpheus",
+    "email": "contact@alphe.us"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./hook": {
+      "types": "./dist/hook.d.ts",
+      "import": "./dist/hook.mjs",
+      "require": "./dist/hook.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@hono/zod-validator": "~0.7.0"
+  },
+  "devDependencies": {
+    "hono": "4.5.0",
+    "zod": "3.25.6",
+    "@jderstd/hono": "0.6.0"
+  },
+  "peerDependencies": {
+    "@jderstd/hono": "~0.6.0",
+    "hono": "^4.5.0",
+    "zod": "^3.25.6 || ^4.0.0"
+  }
+}