@pyreon/validation 0.0.1

package/lib/zod.js

@@ -0,0 +1,84 @@
+//#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.js.map

package/lib/zod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.js","names":[],"sources":["../src/utils.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 {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} 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)\n        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":";;;;;;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;;;;;ACaT,SAAS,mBAAmB,QAAuC;AACjE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACtC,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;AAsBL,SAAgB,UACd,QAC2B;AAC3B,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,OAAO;AAClD,OAAI,OAAO,QACT,QAAO,EAAE;AACX,UAAO,eAAwB,mBAAmB,OAAO,MAAO,OAAO,CAAC;WACjE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;;AAqBP,SAAgB,SAAY,QAAqC;AAC/D,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,MAAM;AACjD,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,MAAO,OAAO,IAAI;WACzB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@pyreon/validation",
+  "version": "0.0.1",
+  "description": "Schema validation adapters for Pyreon forms (Zod, Valibot, ArkType)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pyreon/fundamentals.git",
+    "directory": "packages/validation"
+  },
+  "homepage": "https://github.com/pyreon/fundamentals/tree/main/packages/validation#readme",
+  "bugs": {
+    "url": "https://github.com/pyreon/fundamentals/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./lib/index.js",
+      "types": "./lib/types/index.d.ts"
+    },
+    "./zod": {
+      "bun": "./src/zod.ts",
+      "import": "./lib/zod.js",
+      "types": "./lib/types/zod.d.ts"
+    },
+    "./valibot": {
+      "bun": "./src/valibot.ts",
+      "import": "./lib/valibot.js",
+      "types": "./lib/types/valibot.d.ts"
+    },
+    "./arktype": {
+      "bun": "./src/arktype.ts",
+      "import": "./lib/arktype.js",
+      "types": "./lib/types/arktype.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "vl_rolldown_build",
+    "dev": "vl_rolldown_build-watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@pyreon/form": "workspace:^"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    },
+    "valibot": {
+      "optional": true
+    },
+    "arktype": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.8.3",
+    "@pyreon/core": "^0.2.1",
+    "@pyreon/form": "workspace:*",
+    "@pyreon/reactivity": "^0.2.1",
+    "@pyreon/runtime-dom": "^0.2.1",
+    "zod": "^4.3.6",
+    "valibot": "^1.2.0",
+    "arktype": "^2.2.0"
+  }
+}

package/src/arktype.ts

@@ -0,0 +1,103 @@
+import type {
+  SchemaValidateFn,
+  ValidateFn,
+  ValidationError,
+} from '@pyreon/form'
+import type { ValidationIssue } from './types'
+import { issuesToRecord } from './utils'
+
+/**
+ * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.
+ */
+interface ArkError {
+  path: PropertyKey[]
+  message: string
+}
+
+interface ArkErrors extends Array<ArkError> {
+  summary: string
+}
+
+/**
+ * Internal callable interface matching ArkType's Type.
+ * Not exposed publicly — consumers pass their ArkType schema directly.
+ */
+interface ArkTypeCallable {
+  (data: unknown): unknown
+}
+
+function isArkErrors(result: unknown): result is ArkErrors {
+  return Array.isArray(result) && 'summary' in (result as object)
+}
+
+function arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {
+  return errors.map((err) => ({
+    path: err.path.map(String).join('.'),
+    message: err.message,
+  }))
+}
+
+/**
+ * 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) => { ... },
+ * })
+ */
+export function arktypeSchema<TValues extends Record<string, unknown>>(
+  schema: ArkTypeCallable,
+): SchemaValidateFn<TValues> {
+  return (values: TValues) => {
+    try {
+      const result = schema(values)
+      if (!isArkErrors(result))
+        return {} as Partial<Record<keyof TValues, ValidationError>>
+      return issuesToRecord<TValues>(arkIssuesToGeneric(result))
+    } catch (err) {
+      return {
+        '': err instanceof Error ? err.message : String(err),
+      } as Partial<Record<keyof TValues, ValidationError>>
+    }
+  }
+}
+
+/**
+ * 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) => { ... },
+ * })
+ */
+export function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {
+  return (value: T) => {
+    try {
+      const result = schema(value)
+      if (!isArkErrors(result)) return undefined
+      return result[0]?.message
+    } catch (err) {
+      return err instanceof Error ? err.message : String(err)
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export { zodSchema, zodField } from './zod'
+export { valibotSchema, valibotField } from './valibot'
+export { arktypeSchema, arktypeField } from './arktype'
+export { issuesToRecord } from './utils'
+
+export type {
+  ValidationIssue,
+  SchemaValidateFn,
+  ValidateFn,
+  ValidationError,
+  SchemaAdapter,
+  FieldAdapter,
+} from './types'

package/src/tests/setup.ts

@@ -0,0 +1 @@
+import '@happy-dom/global-registrator'