solid-tiny-form 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 solid tiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# solid-tiny-form
+
+A tiny SolidJS form state manager inspired by `react-hook-form`, but designed around Solid's fine-grained reactivity and `createStore`.
+
+## Features
+
+- `createForm` API for registering fields, setting values, submitting, resetting, and validating.
+- Form state is stored in a Solid store from `solid-js/store`.
+- Pluggable resolver interface for schema validation libraries.
+- Built-in ArkType resolver via `arktypeResolver`.
+- Lightweight field-level rules for common cases.
+
+## Installation
+
+```sh
+pnpm add solid-tiny-form solid-js
+```
+
+Install ArkType when using the optional ArkType resolver:
+
+```sh
+pnpm add arktype
+```
+
+The ArkType adapter supports `arktype@^2.1.27` and is exposed from `solid-tiny-form/resolvers/arktype`.
+
+## Usage
+
+```tsx
+import { type } from "arktype";
+import { createForm } from "solid-tiny-form";
+import { arktypeResolver } from "solid-tiny-form/resolvers/arktype";
+
+const schema = type({
+  email: "string.email",
+  age: "number >= 18",
+});
+
+function Example() {
+  const form = createForm({
+    defaultValues: {
+      email: "",
+      age: 18,
+    },
+    resolver: arktypeResolver(schema),
+    mode: "onBlur",
+  });
+
+  const onSubmit = form.handleSubmit((values) => {
+    console.log(values);
+  });
+
+  return (
+    <form onSubmit={onSubmit}>
+      <input {...form.register("email")} />
+      <input type="number" {...form.register("age", { valueAsNumber: true })} />
+      <button disabled={form.formState.isSubmitting}>Submit</button>
+    </form>
+  );
+}
+```
+
+## API
+
+### `createForm(options)`
+
+Creates a form controller.
+
+```ts
+const form = createForm({
+  defaultValues,
+  resolver,
+  context,
+  mode: "onSubmit",
+});
+```
+
+Validation modes are `onSubmit`, `onBlur`, `onChange`, and `all`.
+
+### Resolver interface
+
+Resolvers receive current values and return parsed values plus field errors.
+
+```ts
+type Resolver<TValues, TContext> = (
+  values: TValues,
+  context: {
+    name?: string;
+    context?: TContext;
+  }
+) =>
+  | { values: TValues; errors: Record<string, FieldError> }
+  | Promise<{ values: TValues; errors: Record<string, FieldError> }>;
+```
+
+This keeps the core form independent from any validation library.

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { a as FieldPath, c as FieldValues, d as RegisterOptions, f as Resolver, g as ValidationMode, h as SetValueOptions, i as FieldFlags, l as Form, m as ResolverResult, n as FieldError, o as FieldPathValue, p as ResolverContext, r as FieldErrors, s as FieldRegistration, t as CreateFormOptions, u as FormState } from "./types-CzHtMISe.mjs";
+
+//#region src/create-form.d.ts
+/** Create a Solid-first form controller backed by createStore. */
+declare function createForm<TValues extends FieldValues = FieldValues, TContext = unknown>(options?: CreateFormOptions<TValues, TContext>): Form<TValues>;
+//#endregion
+export { type CreateFormOptions, type FieldError, type FieldErrors, type FieldFlags, type FieldPath, type FieldPathValue, type FieldRegistration, type FieldValues, type Form, type FormState, type RegisterOptions, type Resolver, type ResolverContext, type ResolverResult, type SetValueOptions, type ValidationMode, createForm };

package/dist/index.mjs

@@ -0,0 +1,329 @@
+import { createStore, produce, reconcile, unwrap } from "solid-js/store";
+//#region src/create-form/async.ts
+/** Run a promise from a synchronous event handler and surface failures globally. */
+function runAsync(task) {
+	task.catch((error) => {
+		queueMicrotask(() => {
+			throw error;
+		});
+	});
+}
+//#endregion
+//#region src/utils.ts
+/** Return a dot path split into store path segments. */
+function toPath(name) {
+	return name.split(".").filter(Boolean);
+}
+/** Read a nested value from an object by dot path. */
+function getPath(source, name) {
+	let value = source;
+	for (const key of toPath(name)) {
+		if (value == null || typeof value !== "object") return;
+		value = value[key];
+	}
+	return value;
+}
+/** Set a nested value on a cloned object by dot path. */
+function setPath(source, name, value) {
+	const root = cloneValue(source);
+	const path = toPath(name);
+	let cursor = root;
+	for (const [index, key] of path.entries()) {
+		if (index === path.length - 1) {
+			cursor[key] = value;
+			break;
+		}
+		const next = cursor[key];
+		if (next == null || typeof next !== "object" || Array.isArray(next)) cursor[key] = {};
+		cursor = cursor[key];
+	}
+	return root;
+}
+/** Create a JSON-compatible deep clone. */
+function cloneValue(value) {
+	if (value == null || typeof value !== "object") return value;
+	return JSON.parse(JSON.stringify(value));
+}
+/** Compare two JSON-compatible values. */
+function isEqual(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+/** Return true when an object has no own enumerable keys. */
+function isEmptyObject(value) {
+	return Object.keys(value).length === 0;
+}
+/** Extract a form value from a DOM event or raw value. */
+function getEventValue(valueOrEvent) {
+	if (!isEventLike(valueOrEvent)) return valueOrEvent;
+	const target = valueOrEvent.currentTarget ?? valueOrEvent.target;
+	if (!isValueTarget(target)) return;
+	if (target.type === "checkbox") return Boolean(target.checked);
+	if (target.type === "number") return target.value === "" ? void 0 : Number(target.value);
+	return target.value;
+}
+function isEventLike(value) {
+	return value != null && typeof value === "object" && ("target" in value || "currentTarget" in value);
+}
+function isValueTarget(target) {
+	return target != null && typeof target === "object" && ("value" in target || "checked" in target);
+}
+//#endregion
+//#region src/create-form/state.ts
+/** Create the initial form state object. */
+function createInitialFormState(defaultValues) {
+	return {
+		defaultValues,
+		dirtyFields: {},
+		errors: {},
+		isDirty: false,
+		isSubmitted: false,
+		isSubmitting: false,
+		isValid: true,
+		isValidating: false,
+		submitCount: 0,
+		touchedFields: {},
+		values: cloneValue(defaultValues)
+	};
+}
+/** Merge full or single-field validation errors into current form errors. */
+function mergeValidationErrors(currentErrors, name, errors) {
+	if (!name) return errors;
+	const nextErrors = {
+		...unwrap(currentErrors),
+		[name]: errors[name]
+	};
+	if (!errors[name]) delete nextErrors[name];
+	return nextErrors;
+}
+/** Calculate the next dirty field map after one field value changes. */
+function createNextDirtyFields(dirtyFields, values, defaultValues, name) {
+	const nextDirtyFields = { ...unwrap(dirtyFields) };
+	if (!isEqual(getPath(values, name), getPath(defaultValues, name))) nextDirtyFields[name] = true;
+	else delete nextDirtyFields[name];
+	return {
+		dirtyFields: nextDirtyFields,
+		isDirty: !isEmptyObject(nextDirtyFields)
+	};
+}
+//#endregion
+//#region src/validation/rules.ts
+/** Validate one field with built-in registration rules. */
+async function validateField(name, value, values, options) {
+	return validateRequired(name, value, options) ?? validateMin(name, value, options) ?? validateMax(name, value, options) ?? validatePattern(name, value, options) ?? await validateCustom(name, value, values, options);
+}
+function validateRequired(name, value, options) {
+	if (!(options.required && isEmpty(value))) return;
+	return {
+		message: typeof options.required === "string" ? options.required : `${name} is required`,
+		type: "required"
+	};
+}
+function validateMin(name, value, options) {
+	const min = readRule(options.min);
+	if (!min || isEmpty(value) || Number(value) >= min.value) return;
+	return {
+		message: min.message ?? `${name} must be at least ${min.value}`,
+		type: "min"
+	};
+}
+function validateMax(name, value, options) {
+	const max = readRule(options.max);
+	if (!max || isEmpty(value) || Number(value) <= max.value) return;
+	return {
+		message: max.message ?? `${name} must be at most ${max.value}`,
+		type: "max"
+	};
+}
+function validatePattern(name, value, options) {
+	const pattern = readPattern(options.pattern);
+	if (!pattern || typeof value !== "string" || pattern.value.test(value)) return;
+	return {
+		message: pattern.message ?? `${name} is invalid`,
+		type: "pattern"
+	};
+}
+async function validateCustom(name, value, values, options) {
+	if (!options.validate) return;
+	const result = await options.validate(value, values);
+	if (result === true) return;
+	if (typeof result === "string") return {
+		message: result,
+		type: "validate"
+	};
+	if (typeof result === "boolean") return {
+		message: `${name} is invalid`,
+		type: "validate"
+	};
+	return result;
+}
+function isEmpty(value) {
+	return value == null || value === "" || Array.isArray(value) && value.length === 0;
+}
+function readRule(rule) {
+	if (typeof rule === "number") return {
+		value: rule,
+		message: void 0
+	};
+	return rule;
+}
+function readPattern(rule) {
+	if (rule instanceof RegExp) return {
+		value: rule,
+		message: void 0
+	};
+	return rule;
+}
+//#endregion
+//#region src/create-form.ts
+/** Create a Solid-first form controller backed by createStore. */
+function createForm(options = {}) {
+	const mode = options.mode ?? "onSubmit";
+	const fieldOptions = /* @__PURE__ */ new Map();
+	const [formState, setFormState] = createStore(createInitialFormState(cloneValue(options.defaultValues ?? {})));
+	function register(name, options) {
+		if (options) fieldOptions.set(name, options);
+		return {
+			name,
+			get value() {
+				return getValue(name);
+			},
+			get checked() {
+				return Boolean(getValue(name));
+			},
+			onInput(event) {
+				runAsync(setValue(name, readInputValue(name, event), { shouldValidate: mode === "onChange" || mode === "all" }));
+			},
+			onChange(event) {
+				runAsync(setValue(name, readInputValue(name, event), { shouldValidate: mode === "onChange" || mode === "all" }));
+			},
+			onBlur() {
+				setFormState("touchedFields", produce((touchedFields) => {
+					touchedFields[name] = true;
+				}));
+				if (mode === "onBlur" || mode === "all") runAsync(trigger(name));
+			}
+		};
+	}
+	function getValues() {
+		return unwrap(formState.values);
+	}
+	function getValue(name) {
+		return getPath(formState.values, name);
+	}
+	async function setValue(name, value, setValueOptions = {}) {
+		setFormState("values", setPath(getValues(), name, value));
+		if (setValueOptions.shouldTouch) setFormState("touchedFields", produce((touchedFields) => {
+			touchedFields[name] = true;
+		}));
+		if (setValueOptions.shouldDirty ?? true) updateDirtyField(name);
+		if (setValueOptions.shouldValidate) await trigger(name);
+	}
+	function setError(name, error) {
+		setFormState("errors", produce((errors) => {
+			errors[name] = error;
+		}));
+		setFormState("isValid", false);
+	}
+	function clearErrors(name) {
+		if (name) setFormState("errors", produce((errors) => {
+			delete errors[name];
+		}));
+		else setFormState("errors", reconcile({}));
+		setFormState("isValid", isEmptyObject(formState.errors));
+	}
+	async function trigger(name) {
+		setFormState("isValidating", true);
+		const errors = await collectErrors(name, getValues());
+		const nextErrors = mergeValidationErrors(formState.errors, name, errors);
+		setFormState("errors", reconcile(nextErrors));
+		setFormState("isValid", isEmptyObject(nextErrors));
+		setFormState("isValidating", false);
+		return name ? !nextErrors[name] : isEmptyObject(errors);
+	}
+	async function collectErrors(name, values) {
+		const errors = {};
+		await collectRegisteredErrors(errors, name, values);
+		await collectResolverErrors(errors, name, values);
+		return errors;
+	}
+	async function collectRegisteredErrors(errors, name, values) {
+		for (const [fieldName, registerOptions] of fieldOptions) {
+			if (name && fieldName !== name) continue;
+			const error = await validateField(fieldName, getPath(values, fieldName), values, registerOptions);
+			if (error) errors[fieldName] = error;
+		}
+	}
+	async function collectResolverErrors(errors, name, values) {
+		if (!options.resolver) return;
+		const result = await options.resolver(values, {
+			name,
+			context: options.context
+		});
+		Object.assign(errors, name ? pickFieldErrors(result.errors, name) : result.errors);
+		if (isEmptyObject(result.errors)) setFormState("values", cloneValue(result.values));
+	}
+	function reset(values) {
+		const nextDefaultValues = cloneValue(values ?? options.defaultValues ?? {});
+		setFormState({
+			values: cloneValue(nextDefaultValues),
+			defaultValues: nextDefaultValues,
+			errors: {},
+			touchedFields: {},
+			dirtyFields: {},
+			isDirty: false,
+			isValid: true,
+			isValidating: false,
+			isSubmitting: false,
+			isSubmitted: false,
+			submitCount: 0
+		});
+	}
+	function handleSubmit(onValid, onInvalid) {
+		return async (event) => {
+			event?.preventDefault();
+			setFormState("submitCount", (count) => count + 1);
+			setFormState("isSubmitted", true);
+			setFormState("isSubmitting", true);
+			const isValid = await trigger();
+			try {
+				if (isValid) await onValid(getValues(), event);
+				else await onInvalid?.(formState.errors, event);
+			} finally {
+				setFormState("isSubmitting", false);
+			}
+		};
+	}
+	function updateDirtyField(name) {
+		const nextDirty = createNextDirtyFields(formState.dirtyFields, formState.values, formState.defaultValues, name);
+		setFormState("dirtyFields", reconcile(nextDirty.dirtyFields));
+		setFormState("isDirty", nextDirty.isDirty);
+	}
+	function readInputValue(name, event) {
+		return transformValue(name, getEventValue(event));
+	}
+	function transformValue(name, value) {
+		const options = fieldOptions.get(name);
+		if (options?.setValueAs) return options.setValueAs(value);
+		if (options?.valueAsNumber) return value === "" || value == null ? void 0 : Number(value);
+		return value;
+	}
+	return {
+		formState,
+		setFormState,
+		register,
+		getValues,
+		getValue,
+		setValue,
+		setError,
+		clearErrors,
+		trigger,
+		reset,
+		handleSubmit
+	};
+}
+function pickFieldErrors(errors, name) {
+	if (!errors[name]) return {};
+	return { [name]: errors[name] };
+}
+//#endregion
+export { createForm };

package/dist/resolvers/arktype.d.mts

@@ -0,0 +1,10 @@
+import { c as FieldValues, f as Resolver } from "../types-CzHtMISe.mjs";
+import { Type } from "arktype";
+
+//#region src/resolvers/arktype.d.ts
+/** A supported ArkType schema. */
+type ArkTypeSchema<TValues extends FieldValues = FieldValues> = Type<TValues>;
+/** Create a resolver for ArkType schemas. */
+declare function arktypeResolver<TValues extends FieldValues>(schema: ArkTypeSchema<TValues>): Resolver<TValues>;
+//#endregion
+export { ArkTypeSchema, arktypeResolver };

package/dist/resolvers/arktype.mjs

@@ -0,0 +1,41 @@
+//#region src/resolvers/arktype.ts
+/** Create a resolver for ArkType schemas. */
+function arktypeResolver(schema) {
+	return (values) => {
+		const result = schema(values);
+		const errors = readArkTypeErrors(result);
+		return {
+			errors: errors ?? {},
+			values: errors ? values : result
+		};
+	};
+}
+function readArkTypeErrors(result) {
+	if (!isArkErrors(result)) return;
+	const errors = {};
+	collectByPath(errors, result.byPath);
+	if (Object.keys(errors).length === 0) errors.root = {
+		message: result.summary ?? result.toString(),
+		type: "arktype"
+	};
+	return errors;
+}
+function isArkErrors(value) {
+	return Array.isArray(value) && "byPath" in value && typeof value.summary === "string";
+}
+function collectByPath(errors, byPath) {
+	for (const [path, value] of Object.entries(byPath)) errors[path || "root"] = {
+		message: readMessage(value),
+		type: "arktype"
+	};
+}
+function readMessage(value) {
+	if (typeof value === "string") return value;
+	if (value && typeof value === "object") {
+		const candidate = value;
+		return candidate.message ?? candidate.summary ?? candidate.toString?.() ?? "Invalid field value";
+	}
+	return "Invalid field value";
+}
+//#endregion
+export { arktypeResolver };

package/dist/types-CzHtMISe.d.mts

@@ -0,0 +1,153 @@
+import { SetStoreFunction, Store } from "solid-js/store";
+
+//#region src/types.d.ts
+/** The object shape managed by a form. */
+type FieldValues = object;
+/** A dot-separated field path. */
+type FieldPath<TValues extends FieldValues = FieldValues> = keyof TValues extends never ? string : ObjectPath<TValues>;
+/** The value type represented by a dot-separated field path. */
+type FieldPathValue<TValues extends FieldValues, TName extends FieldPath<TValues>> = PathValue<TValues, TName>;
+type ObjectPath<TValue> = TValue extends FieldValues ? { [TKey in Extract<keyof TValue, string>]: TValue[TKey] extends FieldValues ? TKey | `${TKey}.${ObjectPath<TValue[TKey]>}` : TKey }[Extract<keyof TValue, string>] : never;
+type PathValue<TValue, TName> = TName extends `${infer TKey}.${infer TRest}` ? TKey extends keyof TValue ? PathValue<TValue[TKey], TRest> : unknown : TName extends keyof TValue ? TValue[TName] : unknown;
+/** A validation error associated with a field path. */
+interface FieldError {
+  /** A human-readable error message. */
+  message: string;
+  /** The validation rule or source that produced the error. */
+  type?: string;
+}
+/** Validation errors keyed by dot-separated field path. */
+type FieldErrors<_TValues extends FieldValues = FieldValues> = Record<string, FieldError | undefined>;
+/** Field flags keyed by dot-separated field path. */
+type FieldFlags<_TValues extends FieldValues = FieldValues> = Record<string, boolean | undefined>;
+/** Current form state stored in a Solid store. */
+interface FormState<TValues extends FieldValues = FieldValues> {
+  /** Initial values used to calculate dirty fields and reset the form. */
+  defaultValues: TValues;
+  /** Fields whose value differs from the default value. */
+  dirtyFields: FieldFlags<TValues>;
+  /** Current field errors. */
+  errors: FieldErrors<TValues>;
+  /** Whether any field is dirty. */
+  isDirty: boolean;
+  /** Whether a submit has been attempted. */
+  isSubmitted: boolean;
+  /** Whether submit handling is currently running. */
+  isSubmitting: boolean;
+  /** Whether the latest validation result contains no errors. */
+  isValid: boolean;
+  /** Whether validation is currently running. */
+  isValidating: boolean;
+  /** Number of submit attempts. */
+  submitCount: number;
+  /** Fields that have received a blur event. */
+  touchedFields: FieldFlags<TValues>;
+  /** Current field values. */
+  values: TValues;
+}
+/** Data returned from a validation resolver. */
+interface ResolverResult<TValues extends FieldValues = FieldValues> {
+  /** Validation errors keyed by dot-separated field path. */
+  errors: FieldErrors<TValues>;
+  /** Parsed or transformed values. Use the input values when no transform is needed. */
+  values: TValues;
+}
+/** Context passed to a validation resolver. */
+interface ResolverContext<TValues extends FieldValues = FieldValues, TContext = unknown> {
+  /** User-provided context from createForm options. */
+  context?: TContext;
+  /** Optional field name that triggered validation. */
+  name?: FieldPath<TValues>;
+}
+/** Pluggable validation function for schema libraries or custom logic. */
+type Resolver<TValues extends FieldValues = FieldValues, TContext = unknown> = (values: TValues, context: ResolverContext<TValues, TContext>) => ResolverResult<TValues> | Promise<ResolverResult<TValues>>;
+/** Built-in field-level validation rules. */
+interface RegisterOptions<TValue = unknown, TValues extends FieldValues = FieldValues> {
+  /** Maximum string length or numeric value. */
+  max?: number | {
+    value: number;
+    message: string;
+  };
+  /** Minimum string length or numeric value. */
+  min?: number | {
+    value: number;
+    message: string;
+  };
+  /** Pattern that a string value must match. */
+  pattern?: RegExp | {
+    value: RegExp;
+    message: string;
+  };
+  /** Whether the field is required. */
+  required?: boolean | string;
+  /** Custom value transform before storing. */
+  setValueAs?: (value: unknown) => TValue;
+  /** Custom synchronous or asynchronous validation rule. */
+  validate?: (value: TValue, values: TValues) => boolean | string | FieldError | Promise<boolean | string | FieldError>;
+  /** Convert input values to numbers before storing them. */
+  valueAsNumber?: boolean;
+}
+/** Props and helpers returned by register. */
+interface FieldRegistration<TValue = unknown> {
+  /** Reactive checked getter for checkbox inputs. */
+  readonly checked: boolean;
+  /** Field name. */
+  name: string;
+  /** Solid blur handler that marks the field as touched. */
+  onBlur: () => void;
+  /** Solid change handler that updates form state. */
+  onChange: (event: Event) => void;
+  /** Solid input handler that updates form state. */
+  onInput: (event: Event) => void;
+  /** Reactive value getter suitable for spreading into Solid JSX. */
+  readonly value: TValue;
+}
+/** Validation trigger mode. */
+type ValidationMode = "onSubmit" | "onBlur" | "onChange" | "all";
+/** Options used to create a form. */
+interface CreateFormOptions<TValues extends FieldValues = FieldValues, TContext = unknown> {
+  /** Extra context passed to the resolver. */
+  context?: TContext;
+  /** Initial form values. */
+  defaultValues?: Partial<TValues>;
+  /** When validation should run automatically. Defaults to onSubmit. */
+  mode?: ValidationMode;
+  /** Schema or custom validation resolver. */
+  resolver?: Resolver<TValues, TContext>;
+}
+/** Public form object returned by createForm. */
+interface Form<TValues extends FieldValues = FieldValues> {
+  /** Clear all errors or one field error. */
+  clearErrors: (name?: FieldPath<TValues>) => void;
+  /** Reactive form state. */
+  formState: Store<FormState<TValues>>;
+  /** Read a single field value. */
+  getValue: <TName extends FieldPath<TValues>>(name: TName) => FieldPathValue<TValues, TName>;
+  /** Read a field value or all values. */
+  getValues: () => TValues;
+  /** Submit helper that validates before calling the valid handler. */
+  handleSubmit: (onValid: (values: TValues, event?: Event) => void | Promise<void>, onInvalid?: (errors: FieldErrors<TValues>, event?: Event) => void | Promise<void>) => (event?: Event) => Promise<void>;
+  /** Register a field and receive Solid-friendly input props. */
+  register: <TName extends FieldPath<TValues>>(name: TName, options?: RegisterOptions<FieldPathValue<TValues, TName>, TValues>) => FieldRegistration<FieldPathValue<TValues, TName>>;
+  /** Reset values and form state. */
+  reset: (values?: Partial<TValues>) => void;
+  /** Set a field error. */
+  setError: (name: FieldPath<TValues>, error: FieldError) => void;
+  /** Low-level setter for the form state store. */
+  setFormState: SetStoreFunction<FormState<TValues>>;
+  /** Set a field value. */
+  setValue: <TName extends FieldPath<TValues>>(name: TName, value: FieldPathValue<TValues, TName>, options?: SetValueOptions) => Promise<void>;
+  /** Validate all fields or a single field. */
+  trigger: (name?: FieldPath<TValues>) => Promise<boolean>;
+}
+/** Options for setValue. */
+interface SetValueOptions {
+  /** Recalculate dirty state. Defaults to true. */
+  shouldDirty?: boolean;
+  /** Mark the field as touched. */
+  shouldTouch?: boolean;
+  /** Trigger validation after the value is set. */
+  shouldValidate?: boolean;
+}
+//#endregion
+export { FieldPath as a, FieldValues as c, RegisterOptions as d, Resolver as f, ValidationMode as g, SetValueOptions as h, FieldFlags as i, Form as l, ResolverResult as m, FieldError as n, FieldPathValue as o, ResolverContext as p, FieldErrors as r, FieldRegistration as s, CreateFormOptions as t, FormState as u };

package/package.json

@@ -0,0 +1,72 @@
+{
+  "devDependencies": {
+    "@biomejs/biome": "2.4.16",
+    "@solidjs/testing-library": "^0.8.10",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@types/node": "^25.9.2",
+    "@typescript/native-preview": "7.0.0-dev.20260608.1",
+    "@vitest/ui": "^4.1.8",
+    "arktype": "^2.2.0",
+    "bumpp": "^11.1.0",
+    "jsdom": "^29.1.1",
+    "tsdown": "^0.22.2",
+    "typescript": "^5.9.3",
+    "ultracite": "7.8.2",
+    "vite": "^8.0.16",
+    "vite-plugin-solid": "^2.11.12",
+    "vitest": "^4.1.8"
+  },
+  "name": "solid-tiny-form",
+  "peerDependencies": {
+    "arktype": "^2.1.27",
+    "solid-js": "^1.9.7"
+  },
+  "type": "module",
+  "version": "0.1.0",
+  "peerDependenciesMeta": {
+    "arktype": {
+      "optional": true
+    }
+  },
+  "description": "A tiny SolidJS form state manager with pluggable validation",
+  "author": "solid tiny",
+  "license": "MIT",
+  "homepage": "https://github.com/sxl-cc/solid-tiny-form#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sxl-cc/solid-tiny-form.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sxl-cc/solid-tiny-form/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "solidjs",
+    "solid",
+    "form",
+    "reactive",
+    "validation",
+    "arktype"
+  ],
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./resolvers/arktype": "./dist/resolvers/arktype.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "vite -c ./playground/vite.config.ts",
+    "test": "vitest run",
+    "test:ui": "vitest --ui",
+    "tc": "tsgo --noEmit --skipLibCheck",
+    "bump": "pnpm bumpp --no-push",
+    "prepublish": "pnpm build",
+    "check": "ultracite check",
+    "check:error": "ultracite check --diagnostic-level error",
+    "fix": "ultracite fix"
+  }
+}