@pyreon/validation 0.11.9 → 0.12.0

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts","../src/valibot.ts","../src/zod.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 { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result)) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\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 an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } 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) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\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>(schema: unknown, safeParseFn: GenericSafeParseFn): 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","import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join('.'),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\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 Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts","../src/valibot.ts","../src/zod.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 { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result)) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\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 an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } 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 */\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) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\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>(schema: unknown, safeParseFn: GenericSafeParseFn): 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","import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join('.'),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\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 Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/arktype.ts","../../../src/types.ts","../../../src/utils.ts","../../../src/valibot.ts","../../../src/zod.ts"],"mappings":";;;;;AAAiF;;KAoB5E,eAAA,IAAmB,IAAA;;;AAkCxB;;;;;;;;;;;;;;;;;AA+BA;;iBA/BgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,EAAQ,eAAA,GACP,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA6BJ,YAAA,GAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,YAAA,CAAW,CAAA;;;AArFY;;;;AAAA,UCShE,eAAA;ED6CD;EC3Cd,IAAA;ED2C2B;ECzC3B,OAAA;AAAA;;;;;KAOU,aAAA,6BAA0C,MAAA,mBACpD,MAAA,EAAQ,OAAA,KACL,gBAAA,CAAiB,OAAA;;;;;KAMV,YAAA,gBAA4B,MAAA,EAAQ,OAAA,KAAY,UAAA,CAAW,CAAA;;;;AD5BU;;;;iBEQjE,cAAA,iBAA+B,MAAA,kBAAA,CAC7C,MAAA,EAAQ,eAAA,KACP,OAAA,CAAQ,MAAA,OAAa,OAAA,EAAS,iBAAA;;;;;AFVgD;;;;KG6B5E,kBAAA,GAAqB,QAAA;AHyB1B;;;;;;;;;;;;;;;;;AA+BA;;;;AA/BA,iBGUgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;AF1DpB;;iBEwFgB,YAAA,GAAA,CAAgB,MAAA,WAAiB,WAAA,EAAa,kBAAA,GAAqB,YAAA,CAAW,CAAA;;;;;AHjGb;;UIQvE,QAAA;EACR,IAAA,EAAM,WAAA;EACN,OAAA;AAAA;;;;;UAOQ,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;;;;;;;;;;;;;;;AHhB7D;;;;;iBG6CgB,SAAA,iBAA0B,MAAA,kBAAA,CACxC,MAAA,EAAQ,SAAA,CAAU,OAAA,IACjB,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;;iBA8BJ,QAAA,GAAA,CAAY,MAAA,EAAQ,SAAA,CAAU,CAAA,IAAK,YAAA,CAAW,CAAA"}
+{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/arktype.ts","../../../src/types.ts","../../../src/utils.ts","../../../src/valibot.ts","../../../src/zod.ts"],"mappings":";;;;;AAAiF;;KAoB5E,eAAA,IAAmB,IAAA;;;AAkCxB;;;;;;;;;;;;;;;;;AA+BA;;iBA/BgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,EAAQ,eAAA,GACP,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA6BJ,YAAA,GAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,YAAA,CAAW,CAAA;;;AArFY;;;;AAAA,UCShE,eAAA;ED6CD;EC3Cd,IAAA;ED2C2B;ECzC3B,OAAA;AAAA;;;;;KAOU,aAAA,6BAA0C,MAAA,mBACpD,MAAA,EAAQ,OAAA,KACL,gBAAA,CAAiB,OAAA;;;;;KAMV,YAAA,gBAA4B,MAAA,EAAQ,OAAA,KAAY,UAAA,CAAW,CAAA;;;;AD5BU;;;;iBEQjE,cAAA,iBAA+B,MAAA,kBAAA,CAC7C,MAAA,EAAQ,eAAA,KACP,OAAA,CAAQ,MAAA,OAAa,OAAA,EAAS,iBAAA;;;;;AFVgD;;;;KG4B5E,kBAAA,GAAqB,QAAA;AH0B1B;;;;;;;;;;;;;;;;;AA+BA;;;;AA/BA,iBGSgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;AFzDpB;;iBEuFgB,YAAA,GAAA,CAAgB,MAAA,WAAiB,WAAA,EAAa,kBAAA,GAAqB,YAAA,CAAW,CAAA;;;;;AHhGb;;UIQvE,QAAA;EACR,IAAA,EAAM,WAAA;EACN,OAAA;AAAA;;;;;UAOQ,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;;;;;;;;;;;;;;;AHhB7D;;;;;iBG6CgB,SAAA,iBAA0B,MAAA,kBAAA,CACxC,MAAA,EAAQ,SAAA,CAAU,OAAA,IACjB,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;;iBA8BJ,QAAA,GAAA,CAAY,MAAA,EAAQ,SAAA,CAAU,CAAA,IAAK,YAAA,CAAW,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"valibot2.d.ts","names":[],"sources":["../../../src/valibot.ts"],"mappings":";;;;;AAAiF;;;;KA6B5E,kBAAA,GAAqB,QAAA;AAmC1B;;;;;;;;;;;;;;;;;;AAiCA;;;AAjCA,iBAAgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA8BJ,YAAA,GAAA,CAAgB,MAAA,WAAiB,WAAA,EAAa,kBAAA,GAAqB,UAAA,CAAW,CAAA"}
+{"version":3,"file":"valibot2.d.ts","names":[],"sources":["../../../src/valibot.ts"],"mappings":";;;;;AAAiF;;;;KA4B5E,kBAAA,GAAqB,QAAA;AAmC1B;;;;;;;;;;;;;;;;;;AAiCA;;;AAjCA,iBAAgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA8BJ,YAAA,GAAA,CAAgB,MAAA,WAAiB,WAAA,EAAa,kBAAA,GAAqB,UAAA,CAAW,CAAA"}

package/lib/valibot.js.map

@@ -1 +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 { SchemaValidateFn, ValidateFn, ValidationError } 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) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\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>(schema: unknown, safeParseFn: GenericSafeParseFn): 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;;;;;ACYT,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,QAAS,QAAO,EAAE;AAC7B,UAAO,eAAwB,uBAAuB,OAAO,UAAU,EAAE,CAAC,CAAC;WACpE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAiB,aAAgD;CAC/F,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"}
+{"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 { SchemaValidateFn, ValidateFn, ValidationError } 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 */\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) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\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>(schema: unknown, safeParseFn: GenericSafeParseFn): 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;;;;;ACWT,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,QAAS,QAAO,EAAE;AAC7B,UAAO,eAAwB,uBAAuB,OAAO,UAAU,EAAE,CAAC,CAAC;WACpE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAiB,aAAgD;CAC/F,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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/validation",
-  "version": "0.11.9",
+  "version": "0.12.0",
   "description": "Schema validation adapters for Pyreon forms (Zod, Valibot, ArkType)",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/validation#readme",
   "bugs": {
@@ -57,16 +57,16 @@
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.8.3",
-    "@pyreon/core": "^0.11.9",
-    "@pyreon/form": "^0.11.9",
-    "@pyreon/reactivity": "^0.11.9",
-    "@pyreon/runtime-dom": "^0.11.9",
+    "@pyreon/core": "^0.12.0",
+    "@pyreon/form": "^0.12.0",
+    "@pyreon/reactivity": "^0.12.0",
+    "@pyreon/runtime-dom": "^0.12.0",
     "arktype": "^2.2.0",
     "valibot": "^1.2.0",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "@pyreon/form": "^0.11.9"
+    "@pyreon/form": "^0.12.0"
   },
   "peerDependenciesMeta": {
     "zod": {

package/src/valibot.ts

@@ -26,7 +26,6 @@ interface ValibotSafeParseResult {
  * parameter that can't be expressed without importing Valibot types. We accept
  * any callable and cast internally.
  */
-// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function
 type GenericSafeParseFn = Function
 
 function valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {