@pyreon/validation 0.0.1

package/lib/types/index.d.ts

@@ -0,0 +1,195 @@
+import { SchemaValidateFn, SchemaValidateFn as SchemaValidateFn$1, ValidateFn, ValidateFn as ValidateFn$1, ValidationError, ValidationError as ValidationError$1 } from "@pyreon/form";
+
+//#region src/zod.d.ts
+/**
+ * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.
+ * These match Zod v3's public API surface.
+ */
+interface ZodIssue {
+  path: PropertyKey[];
+  message: string;
+}
+/**
+ * Duck-typed Zod schema interface — works with both Zod v3 and v4.
+ * Inlines the result shape to avoid version-specific type mismatches.
+ */
+interface ZodSchema<T = unknown> {
+  safeParse(data: unknown): {
+    success: boolean;
+    data?: T;
+    error?: {
+      issues: ZodIssue[];
+    };
+  };
+  safeParseAsync(data: unknown): Promise<{
+    success: boolean;
+    data?: T;
+    error?: {
+      issues: ZodIssue[];
+    };
+  }>;
+}
+/**
+ * Create a form-level schema validator from a Zod schema.
+ * Supports both sync and async Zod schemas (uses `safeParseAsync`).
+ *
+ * @example
+ * import { z } from 'zod'
+ * import { zodSchema } from '@pyreon/validation/zod'
+ *
+ * const schema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(8),
+ * })
+ *
+ * const form = useForm({
+ *   initialValues: { email: '', password: '' },
+ *   schema: zodSchema(schema),
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function zodSchema<TValues extends Record<string, unknown>>(schema: ZodSchema<TValues>): SchemaValidateFn$1<TValues>;
+/**
+ * Create a single-field validator from a Zod schema.
+ * Supports both sync and async Zod refinements.
+ *
+ * @example
+ * import { z } from 'zod'
+ * import { zodField } from '@pyreon/validation/zod'
+ *
+ * const form = useForm({
+ *   initialValues: { email: '' },
+ *   validators: {
+ *     email: zodField(z.string().email('Invalid email')),
+ *   },
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function zodField<T>(schema: ZodSchema<T>): ValidateFn$1<T>;
+//#endregion
+//#region src/valibot.d.ts
+/**
+ * Any function that takes (schema, input, ...rest) and returns a parse result.
+ * Valibot's safeParse/safeParseAsync have generic constraints on the schema
+ * parameter that can't be expressed without importing Valibot types. We accept
+ * any callable and cast internally.
+ */
+type GenericSafeParseFn = Function;
+/**
+ * Create a form-level schema validator from a Valibot schema.
+ *
+ * Valibot uses standalone functions rather than methods, so you must pass
+ * the `safeParseAsync` (or `safeParse`) function from valibot.
+ *
+ * @example
+ * import * as v from 'valibot'
+ * import { valibotSchema } from '@pyreon/validation/valibot'
+ *
+ * const schema = v.object({
+ *   email: v.pipe(v.string(), v.email()),
+ *   password: v.pipe(v.string(), v.minLength(8)),
+ * })
+ *
+ * const form = useForm({
+ *   initialValues: { email: '', password: '' },
+ *   schema: valibotSchema(schema, v.safeParseAsync),
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function valibotSchema<TValues extends Record<string, unknown>>(schema: unknown, safeParseFn: GenericSafeParseFn): SchemaValidateFn$1<TValues>;
+/**
+ * Create a single-field validator from a Valibot schema.
+ *
+ * @example
+ * import * as v from 'valibot'
+ * import { valibotField } from '@pyreon/validation/valibot'
+ *
+ * const form = useForm({
+ *   initialValues: { email: '' },
+ *   validators: {
+ *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),
+ *   },
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn$1<T>;
+//#endregion
+//#region src/arktype.d.ts
+/**
+ * Internal callable interface matching ArkType's Type.
+ * Not exposed publicly — consumers pass their ArkType schema directly.
+ */
+interface ArkTypeCallable {
+  (data: unknown): unknown;
+}
+/**
+ * Create a form-level schema validator from an ArkType schema.
+ *
+ * Accepts any callable ArkType `Type` instance. The schema is duck-typed —
+ * no ArkType import required.
+ *
+ * @example
+ * import { type } from 'arktype'
+ * import { arktypeSchema } from '@pyreon/validation/arktype'
+ *
+ * const schema = type({
+ *   email: 'string.email',
+ *   password: 'string >= 8',
+ * })
+ *
+ * const form = useForm({
+ *   initialValues: { email: '', password: '' },
+ *   schema: arktypeSchema(schema),
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function arktypeSchema<TValues extends Record<string, unknown>>(schema: ArkTypeCallable): SchemaValidateFn$1<TValues>;
+/**
+ * Create a single-field validator from an ArkType schema.
+ *
+ * @example
+ * import { type } from 'arktype'
+ * import { arktypeField } from '@pyreon/validation/arktype'
+ *
+ * const form = useForm({
+ *   initialValues: { email: '' },
+ *   validators: {
+ *     email: arktypeField(type('string.email')),
+ *   },
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function arktypeField<T>(schema: ArkTypeCallable): ValidateFn$1<T>;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Generic issue produced by any schema library.
+ * Adapters normalize library-specific errors into this shape.
+ */
+interface ValidationIssue {
+  /** Dot-separated field path (e.g. "address.city"). */
+  path: string;
+  /** Human-readable error message. */
+  message: string;
+}
+/**
+ * A generic schema adapter transforms library-specific parse results
+ * into a flat record of field → error message.
+ */
+type SchemaAdapter<TSchema> = <TValues extends Record<string, unknown>>(schema: TSchema) => SchemaValidateFn<TValues>;
+/**
+ * A generic field adapter transforms a library-specific schema
+ * into a single-field validator function.
+ */
+type FieldAdapter<TSchema> = <T>(schema: TSchema) => ValidateFn<T>;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Convert an array of validation issues into a flat field → error record.
+ * For nested paths like ["address", "city"], produces "address.city".
+ * When multiple issues exist for the same path, the first message wins.
+ */
+declare function issuesToRecord<TValues extends Record<string, unknown>>(issues: ValidationIssue[]): Partial<Record<keyof TValues, ValidationError$1>>;
+//#endregion
+export { type FieldAdapter, type SchemaAdapter, type SchemaValidateFn, type ValidateFn, type ValidationError, type ValidationIssue, arktypeField, arktypeSchema, issuesToRecord, valibotField, valibotSchema, zodField, zodSchema };
+//# sourceMappingURL=index2.d.ts.map

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index2.d.ts","names":[],"sources":["../../src/zod.ts","../../src/valibot.ts","../../src/arktype.ts","../../src/types.ts","../../src/utils.ts"],"mappings":";;;;;AAIqB;;UAQX,QAAA;EACR,IAAA,EAAM,WAAA;EACN,OAAA;AAAA;;;;AAAO;UAOC,SAAA;EACR,SAAA,CAAU,IAAA;IACR,OAAA;IACA,IAAA,GAAO,CAAA;IACP,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;EAEpB,cAAA,CACE,IAAA,YACC,OAAA;IAAU,OAAA;IAAkB,IAAA,GAAO,CAAA;IAAG,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;AAAA;;;;;;;;;;;;;;AA6B7D;;;;;;iBAAgB,SAAA,iBAA0B,MAAA,kBAAA,CACxC,MAAA,EAAQ,SAAA,CAAU,OAAA,IACjB,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;AA+BpB;;;;iBAAgB,QAAA,GAAA,CAAY,MAAA,EAAQ,SAAA,CAAU,CAAA,IAAK,YAAA,CAAW,CAAA;;;;;AAvFzC;;;;KC6BhB,kBAAA,GAAqB,QAAA;;;;;ADnBjB;;;;;;;;;;;;;;;;;iBCsDO,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;ADbpB;;;iBC8CgB,YAAA,GAAA,CACd,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,YAAA,CAAW,CAAA;;;;;ADvGO;;UEoBX,eAAA;EAAA,CACP,IAAA;AAAA;;;;;AFXM;;;;;;;;;;;;;;;;;iBE8CO,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,EAAQ,eAAA,GACP,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;AFJpB;;;iBEkCgB,YAAA,GAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,YAAA,CAAW,CAAA;;;AFxFhD;;;;AAAA,UGSJ,eAAA;EHAT;EGEN,IAAA;EHDO;EGGP,OAAA;AAAA;;;;;KAOU,aAAA,6BAA0C,MAAA,mBACpD,MAAA,EAAQ,OAAA,KACL,gBAAA,CAAiB,OAAA;;;;;KAMV,YAAA,gBAA4B,MAAA,EAAQ,OAAA,KAAY,UAAA,CAAW,CAAA;;;;AH5BlD;;;;iBIIL,cAAA,iBAA+B,MAAA,kBAAA,CAC7C,MAAA,EAAQ,eAAA,KACP,OAAA,CAAQ,MAAA,OAAa,OAAA,EAAS,iBAAA"}

package/lib/types/valibot.d.ts

@@ -0,0 +1,89 @@
+//#region src/utils.ts
+/**
+* Convert an array of validation issues into a flat field → error record.
+* For nested paths like ["address", "city"], produces "address.city".
+* When multiple issues exist for the same path, the first message wins.
+*/
+function issuesToRecord(issues) {
+  const errors = {};
+  for (const issue of issues) {
+    const key = issue.path;
+    if (errors[key] === void 0) errors[key] = issue.message;
+  }
+  return errors;
+}
+
+//#endregion
+//#region src/valibot.ts
+function valibotIssuesToGeneric(issues) {
+  return issues.map(issue => ({
+    path: issue.path?.map(p => String(p.key)).join(".") ?? "",
+    message: issue.message
+  }));
+}
+/**
+* Create a form-level schema validator from a Valibot schema.
+*
+* Valibot uses standalone functions rather than methods, so you must pass
+* the `safeParseAsync` (or `safeParse`) function from valibot.
+*
+* @example
+* import * as v from 'valibot'
+* import { valibotSchema } from '@pyreon/validation/valibot'
+*
+* const schema = v.object({
+*   email: v.pipe(v.string(), v.email()),
+*   password: v.pipe(v.string(), v.minLength(8)),
+* })
+*
+* const form = useForm({
+*   initialValues: { email: '', password: '' },
+*   schema: valibotSchema(schema, v.safeParseAsync),
+*   onSubmit: (values) => { ... },
+* })
+*/
+function valibotSchema(schema, safeParseFn) {
+  const parse = safeParseFn;
+  return async values => {
+    try {
+      const result = await parse(schema, values);
+      if (result.success) return {};
+      return issuesToRecord(valibotIssuesToGeneric(result.issues ?? []));
+    } catch (err) {
+      return {
+        "": err instanceof Error ? err.message : String(err)
+      };
+    }
+  };
+}
+/**
+* Create a single-field validator from a Valibot schema.
+*
+* @example
+* import * as v from 'valibot'
+* import { valibotField } from '@pyreon/validation/valibot'
+*
+* const form = useForm({
+*   initialValues: { email: '' },
+*   validators: {
+*     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),
+*   },
+*   onSubmit: (values) => { ... },
+* })
+*/
+function valibotField(schema, safeParseFn) {
+  const parse = safeParseFn;
+  return async value => {
+    try {
+      const result = await parse(schema, value);
+      if (result.success) return void 0;
+      return result.issues?.[0]?.message;
+    } catch (err) {
+      return err instanceof Error ? err.message : String(err);
+    }
+  };
+}
+
+//#endregion
+export { valibotField, valibotSchema };
+//# sourceMappingURL=valibot.d.ts.map

package/lib/types/valibot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valibot.d.ts","names":[],"sources":["../../src/utils.ts","../../src/valibot.ts"],"mappings":";;;;;;AAQA,SAAgB,cAAA,CACd,MAAA,EACiD;EACjD,MAAM,MAAA,GAAS,CAAA,CAAE;EACjB,KAAK,MAAM,KAAA,IAAS,MAAA,EAAQ;IAC1B,MAAM,GAAA,GAAM,KAAA,CAAM,IAAA;IAElB,IAAI,MAAA,CAAO,GAAA,CAAA,KAAS,KAAA,CAAA,EAClB,MAAA,CAAO,GAAA,CAAA,GAAO,KAAA,CAAM,OAAA;;EAGxB,OAAO,MAAA;;;;;ACgBT,SAAS,sBAAA,CAAuB,MAAA,EAA2C;EACzE,OAAO,MAAA,CAAO,GAAA,CAAK,KAAA,KAAW;IAC5B,IAAA,EAAM,KAAA,CAAM,IAAA,EAAM,GAAA,CAAK,CAAA,IAAM,MAAA,CAAO,CAAA,CAAE,GAAA,CAAI,CAAC,CAAC,IAAA,CAAK,GAAA,CAAI,IAAI,EAAA;IACzD,OAAA,EAAS,KAAA,CAAM;GAChB,CAAA,CAAE;;;;;;;;;;;;;;;;;;;;;;;AA6BL,SAAgB,aAAA,CACd,MAAA,EACA,WAAA,EAC2B;EAC3B,MAAM,KAAA,GAAQ,WAAA;EACd,OAAO,MAAO,MAAA,IAAoB;IAChC,IAAI;MACF,MAAM,MAAA,GAAS,MAAM,KAAA,CAAM,MAAA,EAAQ,MAAA,CAAO;MAC1C,IAAI,MAAA,CAAO,OAAA,EACT,OAAO,CAAA,CAAE;MACX,OAAO,cAAA,CACL,sBAAA,CAAuB,MAAA,CAAO,MAAA,IAAU,EAAE,CAAC,CAC5C;aACM,GAAA,EAAK;MACZ,OAAO;QACL,EAAA,EAAI,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA;MAAI,CACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,YAAA,CACd,MAAA,EACA,WAAA,EACe;EACf,MAAM,KAAA,GAAQ,WAAA;EACd,OAAO,MAAO,KAAA,IAAa;IACzB,IAAI;MACF,MAAM,MAAA,GAAS,MAAM,KAAA,CAAM,MAAA,EAAQ,KAAA,CAAM;MACzC,IAAI,MAAA,CAAO,OAAA,EAAS,OAAO,KAAA,CAAA;MAC3B,OAAO,MAAA,CAAO,MAAA,GAAS,CAAA,CAAA,EAAI,OAAA;aACpB,GAAA,EAAK;MACZ,OAAO,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA,CAAI"}

package/lib/types/valibot2.d.ts

@@ -0,0 +1,51 @@
+import { SchemaValidateFn, ValidateFn } from "@pyreon/form";
+
+//#region src/valibot.d.ts
+/**
+ * Any function that takes (schema, input, ...rest) and returns a parse result.
+ * Valibot's safeParse/safeParseAsync have generic constraints on the schema
+ * parameter that can't be expressed without importing Valibot types. We accept
+ * any callable and cast internally.
+ */
+type GenericSafeParseFn = Function;
+/**
+ * Create a form-level schema validator from a Valibot schema.
+ *
+ * Valibot uses standalone functions rather than methods, so you must pass
+ * the `safeParseAsync` (or `safeParse`) function from valibot.
+ *
+ * @example
+ * import * as v from 'valibot'
+ * import { valibotSchema } from '@pyreon/validation/valibot'
+ *
+ * const schema = v.object({
+ *   email: v.pipe(v.string(), v.email()),
+ *   password: v.pipe(v.string(), v.minLength(8)),
+ * })
+ *
+ * const form = useForm({
+ *   initialValues: { email: '', password: '' },
+ *   schema: valibotSchema(schema, v.safeParseAsync),
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function valibotSchema<TValues extends Record<string, unknown>>(schema: unknown, safeParseFn: GenericSafeParseFn): SchemaValidateFn<TValues>;
+/**
+ * Create a single-field validator from a Valibot schema.
+ *
+ * @example
+ * import * as v from 'valibot'
+ * import { valibotField } from '@pyreon/validation/valibot'
+ *
+ * const form = useForm({
+ *   initialValues: { email: '' },
+ *   validators: {
+ *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),
+ *   },
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn<T>;
+//#endregion
+export { valibotField, valibotSchema };
+//# sourceMappingURL=valibot2.d.ts.map

package/lib/types/valibot2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valibot2.d.ts","names":[],"sources":["../../src/valibot.ts"],"mappings":";;;;;AAIqB;;;;KA6BhB,kBAAA,GAAqB,QAAA;AAmC1B;;;;;;;;;;;;;;;;;;AAoCA;;;AApCA,iBAAgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBAiCJ,YAAA,GAAA,CACd,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,UAAA,CAAW,CAAA"}

package/lib/types/zod.d.ts

@@ -0,0 +1,86 @@
+//#region src/utils.ts
+/**
+* Convert an array of validation issues into a flat field → error record.
+* For nested paths like ["address", "city"], produces "address.city".
+* When multiple issues exist for the same path, the first message wins.
+*/
+function issuesToRecord(issues) {
+  const errors = {};
+  for (const issue of issues) {
+    const key = issue.path;
+    if (errors[key] === void 0) errors[key] = issue.message;
+  }
+  return errors;
+}
+
+//#endregion
+//#region src/zod.ts
+function zodIssuesToGeneric(issues) {
+  return issues.map(issue => ({
+    path: issue.path.map(String).join("."),
+    message: issue.message
+  }));
+}
+/**
+* Create a form-level schema validator from a Zod schema.
+* Supports both sync and async Zod schemas (uses `safeParseAsync`).
+*
+* @example
+* import { z } from 'zod'
+* import { zodSchema } from '@pyreon/validation/zod'
+*
+* const schema = z.object({
+*   email: z.string().email(),
+*   password: z.string().min(8),
+* })
+*
+* const form = useForm({
+*   initialValues: { email: '', password: '' },
+*   schema: zodSchema(schema),
+*   onSubmit: (values) => { ... },
+* })
+*/
+function zodSchema(schema) {
+  return async values => {
+    try {
+      const result = await schema.safeParseAsync(values);
+      if (result.success) return {};
+      return issuesToRecord(zodIssuesToGeneric(result.error.issues));
+    } catch (err) {
+      return {
+        "": err instanceof Error ? err.message : String(err)
+      };
+    }
+  };
+}
+/**
+* Create a single-field validator from a Zod schema.
+* Supports both sync and async Zod refinements.
+*
+* @example
+* import { z } from 'zod'
+* import { zodField } from '@pyreon/validation/zod'
+*
+* const form = useForm({
+*   initialValues: { email: '' },
+*   validators: {
+*     email: zodField(z.string().email('Invalid email')),
+*   },
+*   onSubmit: (values) => { ... },
+* })
+*/
+function zodField(schema) {
+  return async value => {
+    try {
+      const result = await schema.safeParseAsync(value);
+      if (result.success) return void 0;
+      return result.error.issues[0]?.message;
+    } catch (err) {
+      return err instanceof Error ? err.message : String(err);
+    }
+  };
+}
+
+//#endregion
+export { zodField, zodSchema };
+//# sourceMappingURL=zod.d.ts.map

package/lib/types/zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","names":[],"sources":["../../src/utils.ts","../../src/zod.ts"],"mappings":";;;;;;AAQA,SAAgB,cAAA,CACd,MAAA,EACiD;EACjD,MAAM,MAAA,GAAS,CAAA,CAAE;EACjB,KAAK,MAAM,KAAA,IAAS,MAAA,EAAQ;IAC1B,MAAM,GAAA,GAAM,KAAA,CAAM,IAAA;IAElB,IAAI,MAAA,CAAO,GAAA,CAAA,KAAS,KAAA,CAAA,EAClB,MAAA,CAAO,GAAA,CAAA,GAAO,KAAA,CAAM,OAAA;;EAGxB,OAAO,MAAA;;;;;ACaT,SAAS,kBAAA,CAAmB,MAAA,EAAuC;EACjE,OAAO,MAAA,CAAO,GAAA,CAAK,KAAA,KAAW;IAC5B,IAAA,EAAM,KAAA,CAAM,IAAA,CAAK,GAAA,CAAI,MAAA,CAAO,CAAC,IAAA,CAAK,GAAA,CAAI;IACtC,OAAA,EAAS,KAAA,CAAM;GAChB,CAAA,CAAE;;;;;;;;;;;;;;;;;;;;;AAsBL,SAAgB,SAAA,CACd,MAAA,EAC2B;EAC3B,OAAO,MAAO,MAAA,IAAoB;IAChC,IAAI;MACF,MAAM,MAAA,GAAS,MAAM,MAAA,CAAO,cAAA,CAAe,MAAA,CAAO;MAClD,IAAI,MAAA,CAAO,OAAA,EACT,OAAO,CAAA,CAAE;MACX,OAAO,cAAA,CAAwB,kBAAA,CAAmB,MAAA,CAAO,KAAA,CAAO,MAAA,CAAO,CAAC;aACjE,GAAA,EAAK;MACZ,OAAO;QACL,EAAA,EAAI,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA;MAAI,CACrD;;;;;;;;;;;;;;;;;;;;AAqBP,SAAgB,QAAA,CAAY,MAAA,EAAqC;EAC/D,OAAO,MAAO,KAAA,IAAa;IACzB,IAAI;MACF,MAAM,MAAA,GAAS,MAAM,MAAA,CAAO,cAAA,CAAe,KAAA,CAAM;MACjD,IAAI,MAAA,CAAO,OAAA,EAAS,OAAO,KAAA,CAAA;MAC3B,OAAO,MAAA,CAAO,KAAA,CAAO,MAAA,CAAO,CAAA,CAAA,EAAI,OAAA;aACzB,GAAA,EAAK;MACZ,OAAO,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA,CAAI"}

package/lib/types/zod2.d.ts

@@ -0,0 +1,71 @@
+import { SchemaValidateFn, ValidateFn } from "@pyreon/form";
+
+//#region src/zod.d.ts
+/**
+ * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.
+ * These match Zod v3's public API surface.
+ */
+interface ZodIssue {
+  path: PropertyKey[];
+  message: string;
+}
+/**
+ * Duck-typed Zod schema interface — works with both Zod v3 and v4.
+ * Inlines the result shape to avoid version-specific type mismatches.
+ */
+interface ZodSchema<T = unknown> {
+  safeParse(data: unknown): {
+    success: boolean;
+    data?: T;
+    error?: {
+      issues: ZodIssue[];
+    };
+  };
+  safeParseAsync(data: unknown): Promise<{
+    success: boolean;
+    data?: T;
+    error?: {
+      issues: ZodIssue[];
+    };
+  }>;
+}
+/**
+ * Create a form-level schema validator from a Zod schema.
+ * Supports both sync and async Zod schemas (uses `safeParseAsync`).
+ *
+ * @example
+ * import { z } from 'zod'
+ * import { zodSchema } from '@pyreon/validation/zod'
+ *
+ * const schema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(8),
+ * })
+ *
+ * const form = useForm({
+ *   initialValues: { email: '', password: '' },
+ *   schema: zodSchema(schema),
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function zodSchema<TValues extends Record<string, unknown>>(schema: ZodSchema<TValues>): SchemaValidateFn<TValues>;
+/**
+ * Create a single-field validator from a Zod schema.
+ * Supports both sync and async Zod refinements.
+ *
+ * @example
+ * import { z } from 'zod'
+ * import { zodField } from '@pyreon/validation/zod'
+ *
+ * const form = useForm({
+ *   initialValues: { email: '' },
+ *   validators: {
+ *     email: zodField(z.string().email('Invalid email')),
+ *   },
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function zodField<T>(schema: ZodSchema<T>): ValidateFn<T>;
+//#endregion
+export { zodField, zodSchema };
+//# sourceMappingURL=zod2.d.ts.map

package/lib/types/zod2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod2.d.ts","names":[],"sources":["../../src/zod.ts"],"mappings":";;;;;AAIqB;;UAQX,QAAA;EACR,IAAA,EAAM,WAAA;EACN,OAAA;AAAA;;;;AAAO;UAOC,SAAA;EACR,SAAA,CAAU,IAAA;IACR,OAAA;IACA,IAAA,GAAO,CAAA;IACP,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;EAEpB,cAAA,CACE,IAAA,YACC,OAAA;IAAU,OAAA;IAAkB,IAAA,GAAO,CAAA;IAAG,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;AAAA;;;;;;;;;;;;;;AA6B7D;;;;;;iBAAgB,SAAA,iBAA0B,MAAA,kBAAA,CACxC,MAAA,EAAQ,SAAA,CAAU,OAAA,IACjB,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;AA+BpB;;;;iBAAgB,QAAA,GAAA,CAAY,MAAA,EAAQ,SAAA,CAAU,CAAA,IAAK,UAAA,CAAW,CAAA"}

package/lib/valibot.js

@@ -0,0 +1,87 @@
+//#region src/utils.ts
+/**
+* Convert an array of validation issues into a flat field → error record.
+* For nested paths like ["address", "city"], produces "address.city".
+* When multiple issues exist for the same path, the first message wins.
+*/
+function issuesToRecord(issues) {
+	const errors = {};
+	for (const issue of issues) {
+		const key = issue.path;
+		if (errors[key] === void 0) errors[key] = issue.message;
+	}
+	return errors;
+}
+
+//#endregion
+//#region src/valibot.ts
+function valibotIssuesToGeneric(issues) {
+	return issues.map((issue) => ({
+		path: issue.path?.map((p) => String(p.key)).join(".") ?? "",
+		message: issue.message
+	}));
+}
+/**
+* Create a form-level schema validator from a Valibot schema.
+*
+* Valibot uses standalone functions rather than methods, so you must pass
+* the `safeParseAsync` (or `safeParse`) function from valibot.
+*
+* @example
+* import * as v from 'valibot'
+* import { valibotSchema } from '@pyreon/validation/valibot'
+*
+* const schema = v.object({
+*   email: v.pipe(v.string(), v.email()),
+*   password: v.pipe(v.string(), v.minLength(8)),
+* })
+*
+* const form = useForm({
+*   initialValues: { email: '', password: '' },
+*   schema: valibotSchema(schema, v.safeParseAsync),
+*   onSubmit: (values) => { ... },
+* })
+*/
+function valibotSchema(schema, safeParseFn) {
+	const parse = safeParseFn;
+	return async (values) => {
+		try {
+			const result = await parse(schema, values);
+			if (result.success) return {};
+			return issuesToRecord(valibotIssuesToGeneric(result.issues ?? []));
+		} catch (err) {
+			return { "": err instanceof Error ? err.message : String(err) };
+		}
+	};
+}
+/**
+* Create a single-field validator from a Valibot schema.
+*
+* @example
+* import * as v from 'valibot'
+* import { valibotField } from '@pyreon/validation/valibot'
+*
+* const form = useForm({
+*   initialValues: { email: '' },
+*   validators: {
+*     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),
+*   },
+*   onSubmit: (values) => { ... },
+* })
+*/
+function valibotField(schema, safeParseFn) {
+	const parse = safeParseFn;
+	return async (value) => {
+		try {
+			const result = await parse(schema, value);
+			if (result.success) return void 0;
+			return result.issues?.[0]?.message;
+		} catch (err) {
+			return err instanceof Error ? err.message : String(err);
+		}
+	};
+}
+
+//#endregion
+export { valibotField, valibotSchema };
+//# sourceMappingURL=valibot.js.map

package/lib/valibot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valibot.js","names":[],"sources":["../src/utils.ts","../src/valibot.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join('.') ?? '',\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success)\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(\n        valibotIssuesToGeneric(result.issues ?? []),\n      )\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACgBT,SAAS,uBAAuB,QAA2C;AACzE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,IAAI;EACzD,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;;;AA6BL,SAAgB,cACd,QACA,aAC2B;CAC3B,MAAM,QAAQ;AACd,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,OAAO;AAC1C,OAAI,OAAO,QACT,QAAO,EAAE;AACX,UAAO,eACL,uBAAuB,OAAO,UAAU,EAAE,CAAC,CAC5C;WACM,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aACd,QACA,aACe;CACf,MAAM,QAAQ;AACd,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,MAAM;AACzC,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,SAAS,IAAI;WACpB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}