@shivaedev/form 0.10.0 → 0.12.0

package/src/adapters/persistence.ts

@@ -0,0 +1,87 @@
+import { Schema, SchemaParser } from "effect";
+import type { PersistedDraftConfig, Persistence } from "#persistence.ts";
+
+export function persistence<TSchema extends Schema.Constraint>(schema: TSchema, config: PersistedDraftConfig): Persistence<TSchema["Encoded"]> {
+	const encoded = Schema.toEncoded(schema);
+	const StoredDraft = Schema.Struct({
+		baseline: Schema.Unknown,
+		edited: Schema.Array(Schema.String),
+		session: Schema.String,
+		updatedAt: Schema.Number,
+		values: Schema.Unknown,
+		version: Schema.Literal(1),
+	});
+	const valid = Schema.is(StoredDraft);
+	const decode = SchemaParser.decodeUnknownSync(encoded, { disableChecks: true });
+	const maxAgeMs = config.maxAgeMs ?? 7 * 24 * 60 * 60 * 1000;
+	const maxBytes = config.maxBytes ?? 256 * 1024;
+	function bytes(value: string) {
+		return new TextEncoder().encode(value).byteLength;
+	}
+	const storage = config.storage;
+	const session = config.session?.id ?? "";
+	function active() {
+		return config.session?.active !== false;
+	}
+	function attempt<A>(run: () => A, failed?: () => void): A | undefined {
+		try {
+			return run();
+		} catch {
+			failed?.();
+			return undefined;
+		}
+	}
+	function clear() {
+		attempt(() => storage().removeItem(config.key));
+	}
+	config.session?.track(config.key, clear);
+	return {
+		clear: () => {
+			if (active()) {
+				clear();
+			}
+		},
+		read: () =>
+			attempt(() => {
+				if (!active()) {
+					return undefined;
+				}
+				const raw = storage().getItem(config.key);
+				if (raw === null) {
+					return undefined;
+				}
+				const value: unknown = bytes(raw) <= maxBytes ? JSON.parse(raw) : undefined;
+				const now = config.now();
+				if (
+					valid(value)
+					&& value.session === session
+					&& Number.isFinite(maxAgeMs)
+					&& Number.isFinite(maxBytes)
+					&& maxAgeMs > 0
+					&& maxBytes > 0
+					&& now - value.updatedAt <= maxAgeMs
+					&& value.updatedAt <= now
+				) {
+					return { baseline: decode(value.baseline), edited: value.edited, values: decode(value.values) };
+				}
+				clear();
+				return undefined;
+			}, clear),
+		write: (baseline, values, edited) => {
+			if (!active()) {
+				return;
+			}
+			attempt(() => {
+				const raw = JSON.stringify({ baseline, edited, session, updatedAt: config.now(), values, version: 1 });
+				const parsed: unknown = JSON.parse(raw);
+				if (!(maxAgeMs > 0 && Number.isFinite(maxAgeMs) && Number.isFinite(maxBytes) && bytes(raw) <= maxBytes && valid(parsed))) {
+					clear();
+					return;
+				}
+				decode(parsed.baseline);
+				decode(parsed.values);
+				storage().setItem(config.key, raw);
+			}, clear);
+		},
+	};
+}

package/src/{client → adapters}/react.ts

@@ -2,20 +2,14 @@ import { useAtomRef, useAtomSet, useAtomValue } from "@effect/atom-react";
 import type * as AsyncResult from "effect/reactivity/AsyncResult";
 import { createContext, useCallback, useContext, useMemo } from "react";
 import type { DraftSession } from "#draftSession.ts";
-import type { DraftStorage, PersistedDraftConfig } from "#persistence.ts";
+import type { PersistedDraftConfig } from "#persistence.ts";
 import type { Encoded, FieldFailure, Fields, Form, Invalid, Name } from "#shape.ts";
 export const DraftSessionContext = createContext<DraftSession | undefined>(undefined);
-export interface BrowserDraftConfig extends Omit<PersistedDraftConfig, "storage"> {
-	readonly storage?: () => DraftStorage;
-}
-function browserStorage(): DraftStorage {
-	return globalThis.localStorage;
-}
-export function usePersistedDraft(config: BrowserDraftConfig): PersistedDraftConfig;
-export function usePersistedDraft(config: BrowserDraftConfig | undefined): PersistedDraftConfig | undefined;
-export function usePersistedDraft(config: BrowserDraftConfig | undefined): PersistedDraftConfig | undefined {
+export function usePersistedDraft(config: PersistedDraftConfig): PersistedDraftConfig;
+export function usePersistedDraft(config: PersistedDraftConfig | undefined): PersistedDraftConfig | undefined;
+export function usePersistedDraft(config: PersistedDraftConfig | undefined): PersistedDraftConfig | undefined {
 	const session = useContext(DraftSessionContext);
-	return config ? { ...config, session: session ?? config.session, storage: config.storage ?? browserStorage } : undefined;
+	return config ? { ...config, session: session ?? config.session } : undefined;
 }
 export interface Field<TFields extends Fields, TKey extends Name<TFields>> {
 	readonly choices: readonly Encoded<TFields>[TKey][] | undefined;

package/src/checkFeedback.ts

@@ -0,0 +1,34 @@
+import { type Duration, Effect, Equal } from "effect";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Atom from "effect/reactivity/Atom";
+import type * as AtomRef from "effect/reactivity/AtomRef";
+import { fromRef } from "./refs.ts";
+import type { Encoded, Fields, Name, Services } from "./shape.ts";
+
+export function checkFeedback<TFields extends Fields, R, E>(
+	runtime: Atom.AtomRuntime<Services<TFields, R>, E>,
+	checks: ReadonlyMap<string, (value: Encoded<TFields>[Name<TFields>]) => Effect.Effect<string | undefined, never, R>>,
+	refFor: <TKey extends Name<TFields>>(name: TKey) => AtomRef.AtomRef<Encoded<TFields>[TKey]>,
+	debounce: Duration.Input,
+) {
+	return Atom.family((name: Name<TFields>): Atom.Atom<string | undefined> => {
+		const check = checks.get(name);
+		if (check === undefined) {
+			return Atom.make((): string | undefined => undefined);
+		}
+		const current = fromRef(refFor(name));
+		const settled = Atom.debounce(current, debounce);
+		const answered = runtime.atom((get) => {
+			const input = get(settled);
+			return Effect.map(check(input), (message) => ({
+				input,
+				message,
+			}));
+		});
+		return Atom.readable((get): string | undefined => {
+			const result = get(answered);
+			const value = get(current);
+			return AsyncResult.isSuccess(result) && !result.waiting && Equal.equals(result.value.input, value) ? result.value.message : undefined;
+		});
+	});
+}

package/src/draft.ts

@@ -85,10 +85,18 @@ export function draft<TValues extends Entries>(initial: TValues, persistence?: P
 		submission: () => {
 			const { baseline, current: submitted } = state.value;
 			return {
-				accept: (): void => {
-					state.update((held) =>
-						held.baseline === baseline ? { ...held, baseline: submitted, settled: none } : { ...held, settled: matching(held.current, submitted) },
-					);
+				accept: (incoming?: TValues): void => {
+					state.update((held) => {
+						if (held.baseline !== baseline) {
+							return { ...held, settled: matching(held.current, submitted) };
+						}
+						return {
+							...held,
+							baseline: incoming ?? submitted,
+							current: incoming === undefined ? held.current : merged({ ...held, baseline: submitted, settled: none }, incoming),
+							settled: none,
+						};
+					});
 				},
 				values: submitted,
 			};

package/src/fieldRejection.ts

@@ -0,0 +1,47 @@
+import { Effect, Option, type Schema } from "effect";
+import { rejectedField } from "@shivaedev/errors/rejectedField.ts";
+import type { FieldFailure, Fields, Name, Path, Submitter } from "#shape.ts";
+
+export interface FieldRejection<TName extends string> {
+	readonly field: TName | Path<TName>;
+	readonly message: string;
+}
+
+export type RejectField<TFields extends Fields, TError> = (error: TError) => FieldRejection<Name<TFields>> | undefined;
+
+type Unmatched<TFields extends Fields, TError> = TError extends { readonly _tag: string; readonly message: string }
+	? "field" extends keyof TError
+		? Exclude<TError["field"], Name<TFields> | undefined>
+		: never
+	: never;
+
+export type FieldRejectionMapping<TFields extends Fields, TError> = { readonly rejectField?: RejectField<TFields, TError> } & ([
+	Unmatched<TFields, TError>,
+] extends [never]
+	? unknown
+	: { readonly rejectField: RejectField<TFields, TError> });
+
+export function fieldRejectionOf<TFields extends Fields>(schema: Schema.Struct<TFields>) {
+	return (error: unknown): FieldRejection<Name<TFields>> | undefined => {
+		function isName(name: string): name is Name<TFields> {
+			return Object.hasOwn(schema.fields, name);
+		}
+		return Option.match(rejectedField(error), {
+			onNone: () => undefined,
+			onSome: ({ field, message }) => (isName(field) ? { field, message } : undefined),
+		});
+	};
+}
+
+export function rejecting<TFields extends Fields, TValues, TResult, TError, TRequirements>(
+	schema: Schema.Struct<TFields>,
+	save: (values: TValues) => Effect.Effect<TResult, TError, TRequirements>,
+	reject: RejectField<TFields, TError> | undefined,
+) {
+	const rejection = reject ?? fieldRejectionOf(schema);
+	return (values: TValues, submitter: Submitter<Name<TFields>>): Effect.Effect<TResult, TError | FieldFailure, TRequirements> =>
+		Effect.catch(save(values), (error): Effect.Effect<never, TError | FieldFailure> => {
+			const found = rejection(error);
+			return found === undefined ? Effect.fail(error) : submitter.fail(found.field, found.message);
+		});
+}

package/src/form.ts

@@ -1,26 +1,17 @@
-import { Effect, Equal, Layer, Result, Schema, type SchemaIssue, SchemaParser } from "effect";
+import { Effect, Layer, Result, Schema, type SchemaIssue, SchemaParser } from "effect";
 import * as AsyncResult from "effect/reactivity/AsyncResult";
 import * as Atom from "effect/reactivity/Atom";
 import type * as AtomRef from "effect/reactivity/AtomRef";
+import { persistence } from "#adapters/persistence.ts";
+import { checkFeedback } from "./checkFeedback.ts";
 import { draft } from "./draft.ts";
-import { literalChoices, messageAt, messagesByField, schemaFeedback } from "./messages.ts";
+import { literalChoices, messageAt, schemaFeedback } from "./messages.ts";
 import { pathMessageAt } from "./paths.ts";
-import { persistence } from "./persistence.ts";
 import { fromRef, propertyRef } from "./refs.ts";
-import {
-	type Config,
-	type Decoded,
-	type Encoded,
-	FieldFailure,
-	type Fields,
-	type Form,
-	Invalid,
-	type Name,
-	type Services,
-	type Submitter,
-} from "./shape.ts";
+import { type Config, type Decoded, type Encoded, FieldFailure, type Fields, type Form, type Name, type Services, type Submitter } from "./shape.ts";
 import { statusOf } from "./statusOf.ts";
 import { trackRejections } from "./trackRejections.ts";
+import { validation } from "./validation.ts";
 
 const emptyRuntime = Atom.runtime(Layer.empty);
 
@@ -41,7 +32,7 @@ export function form<TFields extends Fields, TValue, TError, TServices = never,
 	const checks: ReadonlyMap<string, (value: Encoded<TFields>[Name<TFields>]) => Effect.Effect<string | undefined, never, TServices>> = new Map(
 		Object.entries(config.checks ?? {}),
 	);
-	const decode = SchemaParser.decodeUnknownEffect(schema, { errors: "all" });
+	const { decode, snapshot } = validation(schema, config.requiredMessages);
 
 	const editing = draft(initialValues, config.persistedDraft ? persistence(schema, config.persistedDraft) : undefined);
 	const { values } = editing;
@@ -71,26 +62,7 @@ export function form<TFields extends Fields, TValue, TError, TServices = never,
 
 	const schemaErrors = schemaFeedback(decoded, config.requiredMessages);
 
-	const checkError = Atom.family((name: Name<TFields>): Atom.Atom<string | undefined> => {
-		const check = checks.get(name);
-		if (check === undefined) {
-			return Atom.make((): string | undefined => undefined);
-		}
-		const current = fromRef(refFor(name));
-		const settled = Atom.debounce(current, debounce);
-		const answered = runtime.atom((get) => {
-			const input = get(settled);
-			return Effect.map(check(input), (message) => ({
-				input,
-				message,
-			}));
-		});
-		return Atom.readable((get): string | undefined => {
-			const result = get(answered);
-			const value = get(current);
-			return AsyncResult.isSuccess(result) && !result.waiting && Equal.equals(result.value.input, value) ? result.value.message : undefined;
-		});
-	});
+	const checkError = checkFeedback<TFields, TServices, TRuntimeError>(runtime, checks, refFor, debounce);
 
 	const error = Atom.family((name: Name<TFields>) =>
 		Atom.readable((get): string | undefined => {
@@ -105,17 +77,20 @@ export function form<TFields extends Fields, TValue, TError, TServices = never,
 		fail: (path, message) => Effect.fail(new FieldFailure(typeof path === "string" ? { message, path } : { message, path: path[0], segments: path })),
 	};
 
+	const validate = runtime.fn<void>()(() => {
+		status.attempt();
+		return snapshot(values.value);
+	});
+
 	const submit = runtime.fn<void>()(() =>
 		Effect.gen(function* () {
 			status.attempt();
 			const submission = editing.submission();
 			const submitted = submission.values;
-			const value = yield* decode(submitted).pipe(
-				Effect.mapError((issue) => new Invalid({ messages: messagesByField(issue, config.requiredMessages) })),
-			);
+			const { decoded: value } = yield* snapshot(submitted);
 			return yield* onSubmit(value, submitter, submitted).pipe(
 				Effect.tapError(noted(submitted)),
-				Effect.tap(() => Effect.sync(submission.accept)),
+				Effect.tap((saved) => Effect.sync(() => submission.accept(config.savedValues?.(saved)))),
 			);
 		}),
 	);
@@ -133,10 +108,14 @@ export function form<TFields extends Fields, TValue, TError, TServices = never,
 		},
 		dirty: editing.dirty,
 		error,
-		errorAt: Atom.family((path: readonly [Name<TFields>, ...PropertyKey[]]) => {
+		errorAt: Atom.family((path: readonly [Name<TFields>, ...PropertyKey[]] | readonly []) => {
 			const message = schemaErrors.at(path);
+			const name = path[0];
+			if (name === undefined) {
+				return Atom.readable((get) => (get(status.submitted) ? get(message) : undefined));
+			}
 			return Atom.readable((get) =>
-				get(status.touched)[path[0]] === true || get(status.submitted) ? (pathMessageAt(get(status.paths), path) ?? get(message)) : undefined,
+				get(status.touched)[name] === true || get(status.submitted) ? (pathMessageAt(get(status.paths), path) ?? get(message)) : undefined,
 			);
 		}),
 		field: refFor,
@@ -144,6 +123,7 @@ export function form<TFields extends Fields, TValue, TError, TServices = never,
 		revert: editing.revert,
 		submit,
 		submitting: Atom.map(submit, AsyncResult.isWaiting),
+		validate,
 		values,
 	};
 }

package/src/messages.ts

@@ -1,4 +1,4 @@
-import { Option, Result, SchemaAST, SchemaIssue, type StandardSchema } from "effect";
+import { Result, SchemaAST, SchemaIssue, type StandardSchema } from "effect";
 import * as AsyncResult from "effect/reactivity/AsyncResult";
 import * as Atom from "effect/reactivity/Atom";
 
@@ -74,7 +74,8 @@ export function messageAtPath(
 ): string | undefined {
 	for (const entry of formattedIssues(issue, requiredMessages)) {
 		if (
-			path.every((segment, index) => {
+			(path.length > 0 || !entry.path?.length)
+			&& path.every((segment, index) => {
 				const found = entry.path?.[index];
 				return found !== undefined && segment === (typeof found === "object" ? found.key : found);
 			})
@@ -121,23 +122,13 @@ export function schemaFeedback<A, E>(
 	decoded: Atom.Atom<AsyncResult.AsyncResult<Result.Result<A, SchemaIssue.Issue>, E>>,
 	requiredMessages: Readonly<Partial<Record<string, string>>> = noMessages,
 ) {
-	const messages = Atom.map(decoded, (result) =>
-		Option.match(AsyncResult.value(result), {
-			onNone: () => noMessages,
-			onSome: (value) => (Result.isFailure(value) ? messagesByField(value.failure, requiredMessages) : noMessages),
-		}),
+	const issue = Atom.map(decoded, (result) =>
+		AsyncResult.isSuccess(result) && !result.waiting && Result.isFailure(result.value) ? result.value.failure : undefined,
 	);
+	const messages = Atom.map(issue, (value) => (value === undefined ? noMessages : messagesByField(value, requiredMessages)));
 	return {
 		at: (path: readonly PropertyKey[]) =>
-			Atom.map(decoded, (result): string | undefined => {
-				if (result.waiting) {
-					return undefined;
-				}
-				return Option.match(AsyncResult.value(result), {
-					onNone: () => undefined,
-					onSome: (value) => (Result.isFailure(value) ? messageAtPath(value.failure, path, requiredMessages) : undefined),
-				});
-			}),
+			Atom.map(issue, (value) => (value === undefined ? undefined : messageAtPath(value, path, requiredMessages))),
 		field: Atom.family((name: string) => Atom.map(messages, (value) => messageAt(value, name))),
 	};
 }

package/src/persistence.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaParser } from "effect";
+import { Context } from "effect";
 import type { DraftSession } from "./draftSession.ts";
 
 export interface DraftStorage {
@@ -7,6 +7,8 @@ export interface DraftStorage {
 	readonly setItem: (key: string, value: string) => void;
 }
 
+export class DraftStorageProvider extends Context.Service<DraftStorageProvider, () => DraftStorage>()("@shivaedev/form/DraftStorageProvider") {}
+
 export interface PersistedDraftConfig {
 	readonly key: string;
 	readonly maxAgeMs?: number;
@@ -21,88 +23,3 @@ export interface Persistence<TValues> {
 	readonly read: () => { readonly baseline: TValues; readonly edited: readonly string[]; readonly values: TValues } | undefined;
 	readonly write: (baseline: TValues, values: TValues, edited: readonly string[]) => void;
 }
-
-export function persistence<TSchema extends Schema.Constraint>(schema: TSchema, config: PersistedDraftConfig): Persistence<TSchema["Encoded"]> {
-	const encoded = Schema.toEncoded(schema);
-	const StoredDraft = Schema.Struct({
-		baseline: Schema.Unknown,
-		edited: Schema.Array(Schema.String),
-		session: Schema.String,
-		updatedAt: Schema.Number,
-		values: Schema.Unknown,
-		version: Schema.Literal(1),
-	});
-	const valid = Schema.is(StoredDraft);
-	const decode = SchemaParser.decodeUnknownSync(encoded, { disableChecks: true });
-	const maxAgeMs = config.maxAgeMs ?? 7 * 24 * 60 * 60 * 1000;
-	const maxBytes = config.maxBytes ?? 256 * 1024;
-	function bytes(value: string) {
-		return new TextEncoder().encode(value).byteLength;
-	}
-	const storage = config.storage;
-	const session = config.session?.id ?? "";
-	function active() {
-		return config.session?.active !== false;
-	}
-	function attempt<A>(run: () => A, failed?: () => void): A | undefined {
-		try {
-			return run();
-		} catch {
-			failed?.();
-			return undefined;
-		}
-	}
-	function clear() {
-		attempt(() => storage().removeItem(config.key));
-	}
-	config.session?.track(config.key, clear);
-	return {
-		clear: () => {
-			if (active()) {
-				clear();
-			}
-		},
-		read: () =>
-			attempt(() => {
-				if (!active()) {
-					return undefined;
-				}
-				const raw = storage().getItem(config.key);
-				if (raw === null) {
-					return undefined;
-				}
-				const value: unknown = bytes(raw) <= maxBytes ? JSON.parse(raw) : undefined;
-				const now = config.now();
-				if (
-					valid(value)
-					&& value.session === session
-					&& Number.isFinite(maxAgeMs)
-					&& Number.isFinite(maxBytes)
-					&& maxAgeMs > 0
-					&& maxBytes > 0
-					&& now - value.updatedAt <= maxAgeMs
-					&& value.updatedAt <= now
-				) {
-					return { baseline: decode(value.baseline), edited: value.edited, values: decode(value.values) };
-				}
-				clear();
-				return undefined;
-			}, clear),
-		write: (baseline, values, edited) => {
-			if (!active()) {
-				return;
-			}
-			attempt(() => {
-				const raw = JSON.stringify({ baseline, edited, session, updatedAt: config.now(), values, version: 1 });
-				const parsed: unknown = JSON.parse(raw);
-				if (!(maxAgeMs > 0 && Number.isFinite(maxAgeMs) && Number.isFinite(maxBytes) && bytes(raw) <= maxBytes && valid(parsed))) {
-					clear();
-					return;
-				}
-				decode(parsed.baseline);
-				decode(parsed.values);
-				storage().setItem(config.key, raw);
-			}, clear);
-		},
-	};
-}

package/src/refs.ts

@@ -12,7 +12,6 @@ export function fromRef<TValue>(ref: AtomRef.ReadonlyRef<TValue>): Atom.Atom<TVa
 // Native prop refs retain removed keys; form fields must observe their absence.
 export function propertyRef<TValue, TKey extends keyof TValue>(parent: AtomRef.AtomRef<TValue>, name: TKey): AtomRef.AtomRef<TValue[TKey]> {
 	const read = parent.map((value) => value[name]);
-	const write = parent.prop(name);
 	const ref: AtomRef.AtomRef<TValue[TKey]> = {
 		[AtomRef.TypeId]: AtomRef.TypeId,
 		[Equal.symbol]: (other) => Equal.equals(read, other),
@@ -21,7 +20,9 @@ export function propertyRef<TValue, TKey extends keyof TValue>(parent: AtomRef.A
 		map: (transform) => read.map(transform),
 		prop: (key) => propertyRef(ref, key),
 		set: (value) => {
-			write.set(value);
+			parent.update((current) =>
+				Array.isArray(current) ? Object.assign(current.slice(), current, { [name]: value }) : { ...current, [name]: value },
+			);
 			return ref;
 		},
 		subscribe: (listener) => read.subscribe(listener),

package/src/shape.ts

@@ -31,6 +31,7 @@ export class FieldFailure extends Data.TaggedError("FieldFailure")<{
 }> {}
 
 export class Invalid extends Data.TaggedError("Invalid")<{
+	readonly formMessage?: string | undefined;
 	readonly messages: FieldMessages;
 }> {}
 
@@ -53,23 +54,30 @@ export type Config<TFields extends Fields, A, E, R, TRuntimeError> = {
 		submitted: Encoded<TFields>,
 	) => Effect.Effect<A, E, R | Scope.Scope | AtomRegistry | Reactivity>;
 	readonly persistedDraft?: PersistedDraftConfig | undefined;
+	readonly savedValues?: (value: A) => Encoded<TFields>;
 	readonly requiredMessages?: { readonly [TKey in Name<TFields>]?: NonNullable<Encoded<TFields>[TKey]> extends string ? string : never };
 } & ([Exclude<Services<TFields, R>, Scope.Scope | AtomRegistry | Reactivity>] extends [never]
 	? { readonly runtime?: Atom.AtomRuntime<Services<TFields, R>, TRuntimeError> }
 	: { readonly runtime: Atom.AtomRuntime<Services<TFields, R>, TRuntimeError> });
 
+export interface Snapshot<TFields extends Fields> {
+	readonly decoded: Decoded<TFields>;
+	readonly encoded: Encoded<TFields>;
+}
+
 export interface Form<TFields extends Fields, A, E, TRuntimeError> {
 	readonly blur: (name: Name<TFields>) => void;
 	readonly change: <TKey extends Name<TFields>>(name: TKey, value: Encoded<TFields>[TKey]) => void;
 	readonly choices: <TKey extends Name<TFields>>(name: TKey) => readonly Encoded<TFields>[TKey][] | undefined;
 	readonly dirty: Atom.Atom<boolean>;
 	readonly error: (name: Name<TFields>) => Atom.Atom<string | undefined>;
-	readonly errorAt: (path: Path<Name<TFields>>) => Atom.Atom<string | undefined>;
+	readonly errorAt: (path: Path<Name<TFields>> | readonly []) => Atom.Atom<string | undefined>;
 	readonly field: <TKey extends Name<TFields>>(name: TKey) => AtomRef.AtomRef<Encoded<TFields>[TKey]>;
 	readonly receive: (values: Encoded<TFields>) => void;
 	readonly revert: () => void;
 	readonly submit: Atom.AtomResultFn<void, A, E | TRuntimeError | FieldFailure | Invalid>;
 	readonly submitting: Atom.Atom<boolean>;
+	readonly validate: Atom.AtomResultFn<void, Snapshot<TFields>, TRuntimeError | Invalid>;
 	readonly values: AtomRef.AtomRef<Encoded<TFields>>;
 }
 

package/src/statusOf.ts

@@ -56,11 +56,10 @@ export function statusOf() {
 		submitted: fromRef(state.prop("submitted")),
 		touch: (name: string): void => {
 			state.update((current) =>
-				current.touched[name] === true && !current.failures.some((entry) => entry.path.length === 1 && entry.path[0] === name)
+				current.touched[name] === true
 					? current
 					: {
 							...current,
-							failures: current.failures.filter((entry) => entry.path.length !== 1 || entry.path[0] !== name),
 							touched: { ...current.touched, [name]: true },
 						},
 			);

package/src/validation.ts

@@ -0,0 +1,18 @@
+import { Effect, type Schema, SchemaParser } from "effect";
+import { messageAtPath, messagesByField } from "./messages.ts";
+import { type Encoded, type Fields, Invalid, type Name, type Snapshot } from "./shape.ts";
+
+export function validation<TFields extends Fields>(
+	schema: Schema.Struct<TFields>,
+	requiredMessages: Readonly<Partial<Record<Name<TFields>, string>>> | undefined,
+) {
+	const decode = SchemaParser.decodeUnknownEffect(schema, { errors: "all" });
+	return {
+		decode,
+		snapshot: (encoded: Encoded<TFields>) =>
+			decode(encoded).pipe(
+				Effect.map((decoded): Snapshot<TFields> => ({ decoded, encoded })),
+				Effect.mapError((issue) => new Invalid({ formMessage: messageAtPath(issue, []), messages: messagesByField(issue, requiredMessages) })),
+			),
+	};
+}

package/dist/client/react.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/client/react.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,WAAW,MAAM,+BAA+B,CAAC;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACpF,eAAO,MAAM,mBAAmB,mDAAqD,CAAC;AACtF,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC;IAChF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,YAAY,CAAC;CACtC;AAID,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,oBAAoB,CAAC;AACpF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAAC;AAK5G,MAAM,WAAW,KAAK,CAAC,OAAO,SAAS,MAAM,EAAE,IAAI,SAAS,IAAI,CAAC,OAAO,CAAC;IACxE,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,SAAS,CAAC;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;IAC3D,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;CACvC;AACD,wBAAgB,QAAQ,CAAC,OAAO,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,EAAE,IAAI,SAAS,IAAI,CAAC,OAAO,CAAC,EAC/F,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,EACxC,IAAI,EAAE,IAAI,GACR,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,CAOtB;AACD,MAAM,WAAW,MAAM,CAAC,CAAC,EAAE,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,IAAI,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC7B;AACD,wBAAgB,SAAS,CAAC,OAAO,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,EACpE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,GACtC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,aAAa,GAAG,YAAY,GAAG,OAAO,CAAC,CAKvD;AACD,wBAAgB,QAAQ,CAAC,OAAO,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,GAAG,OAAO,CAEvH"}

package/dist/client/react.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react.js","sourceRoot":"","sources":["../../src/client/react.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAE1E,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIxE,MAAM,CAAC,MAAM,mBAAmB,GAAG,aAAa,CAA2B,SAAS,CAAC,CAAC;AAItF,SAAS,cAAc;IACtB,OAAO,UAAU,CAAC,YAAY,CAAC;AAChC,CAAC;AAGD,MAAM,UAAU,iBAAiB,CAAC,MAAsC;IACvE,MAAM,OAAO,GAAG,UAAU,CAAC,mBAAmB,CAAC,CAAC;IAChD,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,cAAc,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AAC1H,CAAC;AASD,MAAM,UAAU,QAAQ,CACvB,IAAwC,EACxC,IAAU;IAEV,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,MAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,IAA4B,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACtG,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAChE,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAChE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AAC1D,CAAC;AAMD,MAAM,UAAU,SAAS,CACxB,IAAwC;IAExC,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACzC,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;AACpD,CAAC;AACD,MAAM,UAAU,QAAQ,CAA8C,IAAwC;IAC7G,OAAO,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACjC,CAAC"}