@formisch/preact 0.1.0 → 0.3.0

package/README.md

@@ -2,6 +2,8 @@
 
 Formisch is a schema-based, headless form library for Preact. It manages form state and validation. It is type-safe, fast by default and its bundle size is small due to its modular design. Try it out in our [playground](https://stackblitz.com/edit/formisch-playground-preact)!
 
+Formisch is also available for [Qwik][formisch-qwik], [SolidJS][formisch-solid], and [Vue][formisch-vue]. Svelte will follow soon.
+
 ## Highlights
 
 - Small bundle size starting at 2.5 kB
@@ -13,10 +15,10 @@ Formisch is a schema-based, headless form library for Preact. It manages form st
 
 ## Example
 
-Every form starts with the `useForm$` hook. It initializes your form's store based on the provided Valibot schema and infers its types. Next, wrap your form in the `<Form />` component. It's a thin layer around the native `<form />` element that handles form validation and submission. Then, you can access the state of a field with the `useField` hook or the `<Field />` component to connect your inputs.
+Every form starts with the `useForm` hook. It initializes your form's store based on the provided Valibot schema and infers its types. Next, wrap your form in the `<Form />` component. It's a thin layer around the native `<form />` element that handles form validation and submission. Then, you can access the state of a field with the `useField` hook or the `<Field />` component to connect your inputs.
 
 ```tsx
-import { Field, Form, useForm$ } from '@formisch/preact';
+import { Field, Form, useForm } from '@formisch/preact';
 import * as v from 'valibot';
 
 const LoginSchema = v.object({
@@ -31,26 +33,22 @@ export default function LoginPage() {
 
   return (
     <Form of={loginForm} onSubmit={(output) => console.log(output)}>
-      <Field
-        of={loginForm}
-        path={['email']}
-        render={(field) => (
+      <Field of={loginForm} path={['email']}>
+        {(field) => (
           <div>
             <input {...field.props} value={field.input} type="email" />
             {field.errors.value && <div>{field.errors.value[0]}</div>}
           </div>
         )}
-      />
-      <Field
-        of={loginForm}
-        path={['password']}
-        render={(field) => (
+      </Field>
+      <Field of={loginForm} path={['password']}>
+        {(field) => (
           <div>
             <input {...field.props} value={field.input} type="password" />
             {field.errors.value && <div>{field.errors.value[0]}</div>}
           </div>
         )}
-      />
+      </Field>
       <button type="submit">Login</button>
     </Form>
   );
@@ -59,6 +57,16 @@ export default function LoginPage() {
 
 In addition, Formisch offers several functions (we call them "methods") that can be used to read and manipulate the form state. These include `focus`, `getErrors`, `getAllErrors`, `getInput`, `insert`, `move`, `remove`, `replace`, `reset`, `setErrors`, `setInput`, `submit`, `swap` and `validate`. These methods allow you to control the form programmatically.
 
+## Comparison
+
+What makes Formisch unique is its framework-agnostic core, which is fully native to the framework you are using. It works by inserting framework-specific reactivity blocks when the core package is built. The result is a small bundle size and native performance for any UI update. This feature, along with a few others, distinguishes Formisch from other form libraries. My vision for Formisch is to create a framework-agnostic platform similar to [Vite](https://vite.dev/), but for forms.
+
+## Partners
+
+Thanks to our partners who support the development! [Join them](https://github.com/sponsors/fabian-hiller) and contribute to the sustainability of open source software!
+
+![Partners of Formisch](https://github.com/fabian-hiller/formisch/blob/main/partners.webp?raw=true)
+
 ## Feedback
 
 Find a bug or have an idea how to improve the library? Please fill out an [issue](https://github.com/fabian-hiller/formisch/issues/new). Together we can make forms even better!
@@ -66,3 +74,7 @@ Find a bug or have an idea how to improve the library? Please fill out an [issue
 ## License
 
 This project is available free of charge and licensed under the [MIT license](https://github.com/fabian-hiller/formisch/blob/main/LICENSE.md).
+
+[formisch-qwik]: https://github.com/fabian-hiller/formisch/tree/main/frameworks/qwik
+[formisch-solid]: https://github.com/fabian-hiller/formisch/tree/main/frameworks/solid
+[formisch-vue]: https://github.com/fabian-hiller/formisch/tree/main/frameworks/vue

package/dist/index.d.ts

@@ -77,15 +77,15 @@ type ValidationMode = "initial" | "touch" | "input" | "change" | "blur" | "submi
 interface FormConfig<TSchema extends Schema = Schema> {
   readonly schema: TSchema;
   readonly initialInput?: DeepPartial<v.InferInput<TSchema>> | undefined;
-  readonly validateOn?: ValidationMode | undefined;
-  readonly revalidateOn?: Exclude<ValidationMode, "initial"> | undefined;
+  readonly validate?: ValidationMode | undefined;
+  readonly revalidate?: Exclude<ValidationMode, "initial"> | undefined;
 }
 interface InternalFormStore<TSchema extends Schema = Schema> extends InternalObjectStore {
   element?: HTMLFormElement;
   validators: number;
-  validateOn: ValidationMode;
-  revalidateOn: Exclude<ValidationMode, "initial">;
-  validate: (input: unknown) => Promise<v.SafeParseResult<TSchema>>;
+  validate: ValidationMode;
+  revalidate: Exclude<ValidationMode, "initial">;
+  parse: (input: unknown) => Promise<v.SafeParseResult<TSchema>>;
   isSubmitting: Signal<boolean>;
   isSubmitted: Signal<boolean>;
   isValidating: Signal<boolean>;
@@ -93,7 +93,7 @@ interface InternalFormStore<TSchema extends Schema = Schema> extends InternalObj
 interface BaseFormStore<TSchema extends Schema = Schema> {
   [INTERNAL]: InternalFormStore<TSchema>;
 }
-type SubmitHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>, event: SubmitEvent) => MaybePromise<void>;
+type SubmitHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>, event: SubmitEvent) => MaybePromise<unknown>;
 //#endregion
 //#region src/types/path.d.ts
 /**
@@ -123,16 +123,16 @@ type MergeUnion<T> = { [K in KeyOf<T>]: T extends Record<K, infer V> ? V : never
 /**
 * Lazily evaluate only the first valid path segment based on the given value.
 */
-type LazyPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValidPath : TPathToCheck extends readonly [infer TFirstKey extends KeyOf<TValue>, ...infer TPathRest extends Path] ? LazyPath<MergeUnion<TValue>[TFirstKey], TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOf<TValue>> extends false ? readonly [...TValidPath, KeyOf<TValue>] : TValidPath;
+type LazyPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValidPath : TPathToCheck extends readonly [infer TFirstKey extends KeyOf<TValue>, ...infer TPathRest extends Path] ? LazyPath<Required<MergeUnion<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOf<TValue>> extends false ? readonly [...TValidPath, KeyOf<TValue>] : TValidPath;
 /**
 * Returns the path if valid, otherwise the first possible valid path based on
 * the given value.
 */
-type ValidPath<TValue, TPath extends RequiredPath> = TPath extends LazyPath<TValue, TPath> ? TPath : LazyPath<TValue, TPath>;
+type ValidPath<TValue, TPath extends RequiredPath> = TPath extends LazyPath<Required<TValue>, TPath> ? TPath : LazyPath<Required<TValue>, TPath>;
 /**
 * Extracts the value type at the given path.
 */
-type PathValue<TValue, TPath extends Path> = TPath extends readonly [infer TKey, ...infer TRest extends Path] ? TKey extends KeyOf<TValue> ? PathValue<MergeUnion<TValue>[TKey], TRest> : unknown : TValue;
+type PathValue<TValue, TPath extends Path> = TPath extends readonly [infer TKey, ...infer TRest extends Path] ? TKey extends KeyOf<Required<TValue>> ? PathValue<MergeUnion<Required<TValue>>[TKey], TRest> : unknown : TValue;
 /**
 * Checks if a value is an array or contains one.
 */
@@ -140,16 +140,16 @@ type IsOrHasArray<TValue> = IsAny<TValue> extends true ? false : TValue extends
 /**
 * Extracts the exact keys of a tuple, array or object that contain arrays.
 */
-type KeyOfArrayPath<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? IsOrHasArray<TItem> extends true ? number : never : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? IsOrHasArray<TValue[TKey]> extends true ? TIndex : never : never }[number] : TValue extends Record<string, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> extends true ? TKey : never }[keyof TValue] & PathKey : never;
+type KeyOfArrayPath<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? IsOrHasArray<TItem> extends true ? number : never : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TIndex : never : never }[number] : TValue extends Record<string, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TKey : never }[keyof TValue] & PathKey : never;
 /**
 * Lazily evaluate only the first valid array path segment based on the given value.
 */
-type LazyArrayPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValue extends readonly unknown[] ? TValidPath : readonly [...TValidPath, KeyOfArrayPath<TValue>] : TPathToCheck extends readonly [infer TFirstKey extends KeyOfArrayPath<TValue>, ...infer TPathRest extends Path] ? LazyArrayPath<MergeUnion<TValue>[TFirstKey], TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOfArrayPath<TValue>> extends false ? readonly [...TValidPath, KeyOfArrayPath<TValue>] : never;
+type LazyArrayPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValue extends readonly unknown[] ? TValidPath : readonly [...TValidPath, KeyOfArrayPath<TValue>] : TPathToCheck extends readonly [infer TFirstKey extends KeyOfArrayPath<TValue>, ...infer TPathRest extends Path] ? LazyArrayPath<Required<MergeUnion<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOfArrayPath<TValue>> extends false ? readonly [...TValidPath, KeyOfArrayPath<TValue>] : never;
 /**
 * Returns the path if valid, otherwise the first possible valid array path based on
 * the given value.
 */
-type ValidArrayPath<TValue, TPath extends RequiredPath> = TPath extends LazyArrayPath<TValue, TPath> ? TPath : LazyArrayPath<TValue, TPath>;
+type ValidArrayPath<TValue, TPath extends RequiredPath> = TPath extends LazyArrayPath<Required<TValue>, TPath> ? TPath : LazyArrayPath<Required<TValue>, TPath>;
 //#endregion
 //#region src/array/copyItemState/copyItemState.d.ts
 /**
@@ -193,6 +193,9 @@ interface GetFieldInputConfig<TSchema extends Schema, TFieldPath extends Require
 declare function getInput<TSchema extends Schema>(form: BaseFormStore<TSchema>): PartialValues<v.InferInput<TSchema>>;
 declare function getInput<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldInputConfig<TSchema, TFieldPath> : GetFormInputConfig): PartialValues<TFieldPath extends RequiredPath ? PathValue<v.InferInput<TSchema>, TFieldPath> : v.InferInput<TSchema>>;
 //#endregion
+//#region src/handleSubmit/handleSubmit.d.ts
+declare function handleSubmit<TSchema extends Schema>(form: BaseFormStore<TSchema>, handler: SubmitHandler<TSchema>): (event: SubmitEvent) => void;
+//#endregion
 //#region src/insert/insert.d.ts
 interface InsertConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
   readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
@@ -339,7 +342,7 @@ interface FormStore<TSchema extends Schema = Schema> extends BaseFormStore<TSche
 interface FieldProps<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
   readonly of: FormStore<TSchema>;
   readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
-  readonly render: (store: FieldStore<TSchema, TFieldPath>) => JSX.Element;
+  readonly children: (store: FieldStore<TSchema, TFieldPath>) => JSX.Element;
 }
 /**
 * Headless form field that provides reactive properties and state.
@@ -347,7 +350,7 @@ interface FieldProps<TSchema extends Schema = Schema, TFieldPath extends Require
 declare function Field<TSchema extends Schema, TFieldPath extends RequiredPath>({
   of,
   path,
-  render
+  children
 }: FieldProps<TSchema, TFieldPath>): JSX.Element;
 //#endregion
 //#region src/components/FieldArray/FieldArray.d.ts
@@ -357,7 +360,7 @@ declare function Field<TSchema extends Schema, TFieldPath extends RequiredPath>(
 interface FieldArrayProps<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
   readonly of: FormStore<TSchema>;
   readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
-  readonly render: (store: FieldArrayStore<TSchema, TFieldArrayPath>) => JSX.Element;
+  readonly children: (store: FieldArrayStore<TSchema, TFieldArrayPath>) => JSX.Element;
 }
 /**
 * Headless field array that provides reactive properties and state.
@@ -365,7 +368,7 @@ interface FieldArrayProps<TSchema extends Schema = Schema, TFieldArrayPath exten
 declare function FieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>({
   of,
   path,
-  render
+  children
 }: FieldArrayProps<TSchema, TFieldArrayPath>): JSX.Element;
 //#endregion
 //#region src/components/Form/Form.d.ts
@@ -390,4 +393,4 @@ declare function useFieldArray<TSchema extends Schema, TFieldArrayPath extends R
 //#region src/hooks/useForm/useForm.d.ts
 declare function useForm<TSchema extends Schema>(config: FormConfig<TSchema>): FormStore<TSchema>;
 //#endregion
-export { Field, FieldArray, FieldArrayProps, FieldArrayStore, FieldElementProps, FieldProps, FieldStore, FocusFieldConfig, Form, FormProps, FormStore, GetFieldErrorsConfig, GetFieldInputConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, RemoveConfig, ReplaceConfig, ResetFieldConfig, ResetFormConfig, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, SwapConfig, UseFieldArrayConfig, UseFieldConfig, ValidateFormConfig, focus, getAllErrors, getErrors, getInput, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };
+export { Field, FieldArray, FieldArrayProps, FieldArrayStore, FieldElementProps, FieldProps, FieldStore, FocusFieldConfig, Form, FormProps, FormStore, GetFieldErrorsConfig, GetFieldInputConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, RemoveConfig, ReplaceConfig, ResetFieldConfig, ResetFormConfig, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, type SubmitHandler, SwapConfig, UseFieldArrayConfig, UseFieldConfig, ValidateFormConfig, focus, getAllErrors, getErrors, getInput, handleSubmit, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };

package/dist/index.js

@@ -121,6 +121,7 @@ function copyItemState(fromInternalFieldStore, toInternalFieldStore) {
 */
 function resetItemState(internalFieldStore, initialInput) {
 	batch(() => {
+		internalFieldStore.errors.value = null;
 		if (internalFieldStore.kind === "array") {
 			internalFieldStore.isTouched.value = false;
 			internalFieldStore.isDirty.value = false;
@@ -293,6 +294,7 @@ function setFieldInput(internalFieldStore, input) {
 		} else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) setFieldInput(internalFieldStore.children[key], input[key]);
 		else {
 			internalFieldStore.input.value = input;
+			internalFieldStore.isTouched.value = true;
 			const startInput = untrack(() => internalFieldStore.startInput.value);
 			internalFieldStore.isDirty.value = startInput !== input && (startInput !== void 0 || input !== "" && !Number.isNaN(input));
 		}
@@ -321,12 +323,12 @@ function walkFieldStore(internalFieldStore, callback) {
 	if (internalFieldStore.kind === "array") for (let index = 0; index < untrack(() => internalFieldStore.items.value).length; index++) walkFieldStore(internalFieldStore.children[index], callback);
 	else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) walkFieldStore(internalFieldStore.children[key], callback);
 }
-function createFormStore(config, validate$1) {
+function createFormStore(config, parse) {
 	const store = {};
 	initializeFieldStore(store, config.schema, config.initialInput, []);
-	store.validateOn = config.validateOn ?? "submit";
-	store.revalidateOn = config.revalidateOn ?? "input";
-	store.validate = validate$1;
+	store.validate = config.validate ?? "submit";
+	store.revalidate = config.revalidate ?? "input";
+	store.parse = parse;
 	store.isSubmitting = createSignal(false);
 	store.isSubmitted = createSignal(false);
 	store.isValidating = createSignal(false);
@@ -335,7 +337,7 @@ function createFormStore(config, validate$1) {
 async function validateFormInput(internalFormStore, config) {
 	internalFormStore.validators++;
 	internalFormStore.isValidating.value = true;
-	const result = await internalFormStore.validate(untrack(() => getFieldInput(internalFormStore)));
+	const result = await internalFormStore.parse(untrack(() => getFieldInput(internalFormStore)));
 	let rootErrors;
 	let nestedErrors;
 	if (result.issues) {
@@ -375,7 +377,7 @@ async function validateFormInput(internalFormStore, config) {
 	return result;
 }
 function validateIfRequired(internalFormStore, internalFieldStore, validationModes) {
-	if (validationModes === (internalFormStore.validateOn === "initial" || (internalFormStore.validateOn === "submit" ? untrack(() => internalFormStore.isSubmitted.value) : untrack(() => getFieldBool(internalFieldStore, "errors"))) ? internalFormStore.revalidateOn : internalFormStore.validateOn)) validateFormInput(internalFormStore);
+	if (validationModes === (internalFormStore.validate === "initial" || (internalFormStore.validate === "submit" ? untrack(() => internalFormStore.isSubmitted.value) : untrack(() => getFieldBool(internalFieldStore, "errors"))) ? internalFormStore.revalidate : internalFormStore.validate)) validateFormInput(internalFormStore);
 }
 const INTERNAL = "~internal";
 
@@ -399,6 +401,22 @@ function getErrors(form, config) {
 function getInput(form, config) {
 	return getFieldInput(config?.path ? getFieldStore(form[INTERNAL], config.path) : form[INTERNAL]);
 }
+function handleSubmit(form, handler) {
+	return async (event) => {
+		event.preventDefault();
+		const internalFormStore = form[INTERNAL];
+		internalFormStore.isSubmitted.value = true;
+		internalFormStore.isSubmitting.value = true;
+		try {
+			const result = await validateFormInput(internalFormStore, { shouldFocus: true });
+			if (result.success) await handler(result.output, event);
+		} catch (error) {
+			internalFormStore.errors.value = [error instanceof Error ? error.message : "An unknown error has occurred."];
+		} finally {
+			internalFormStore.isSubmitting.value = false;
+		}
+	};
+}
 function insert(form, config) {
 	const internalFormStore = form[INTERNAL];
 	const internalArrayStore = getFieldStore(internalFormStore, config.path);
@@ -490,7 +508,7 @@ function reset(form, config) {
 			});
 			if (!config?.path) {
 				if (!config?.keepSubmitted) internalFormStore.isSubmitted.value = false;
-				if (internalFormStore.validateOn === "initial") validateFormInput(internalFormStore);
+				if (internalFormStore.validate === "initial") validateFormInput(internalFormStore);
 			}
 		});
 	});
@@ -502,7 +520,6 @@ function setInput(form, config) {
 	batch(() => {
 		const internalFormStore = form[INTERNAL];
 		const internalFieldStore = config.path ? getFieldStore(internalFormStore, config.path) : internalFormStore;
-		setFieldBool(internalFieldStore, "isTouched", true);
 		setFieldInput(internalFieldStore, config.input);
 		validateIfRequired(internalFormStore, internalFieldStore, "input");
 	});
@@ -566,15 +583,14 @@ function useField(form, config) {
 			},
 			autofocus: !!internalFieldStore.value.errors.value,
 			ref(element) {
-				internalFieldStore.value.elements.push(element);
+				if (element) internalFieldStore.value.elements.push(element);
 			},
 			onFocus() {
 				setFieldBool(internalFieldStore.value, "isTouched", true);
 				validateIfRequired(form[INTERNAL], internalFieldStore.value, "touch");
 			},
 			onInput(event) {
-				const nextValue = getElementInput(event.currentTarget, internalFieldStore.value);
-				setFieldInput(internalFieldStore.value, nextValue);
+				setFieldInput(internalFieldStore.value, getElementInput(event.currentTarget, internalFieldStore.value));
 				validateIfRequired(form[INTERNAL], internalFieldStore.value, "input");
 			},
 			onChange() {
@@ -619,7 +635,7 @@ function useForm(config) {
 		};
 	}, []);
 	useLayoutEffect(() => {
-		if (config.validateOn === "initial") validateFormInput(form[INTERNAL]);
+		if (config.validate === "initial") validateFormInput(form[INTERNAL]);
 	}, []);
 	return form;
 }
@@ -629,9 +645,9 @@ function useForm(config) {
 /**
 * Headless form field that provides reactive properties and state.
 */
-function Field({ of, path, render }) {
+function Field({ of, path, children }) {
 	const field = useField(of, { path });
-	return render(field);
+	return children(field);
 }
 
 //#endregion
@@ -639,9 +655,9 @@ function Field({ of, path, render }) {
 /**
 * Headless field array that provides reactive properties and state.
 */
-function FieldArray({ of, path, render }) {
+function FieldArray({ of, path, children }) {
 	const field = useFieldArray(of, { path });
-	return render(field);
+	return children(field);
 }
 
 //#endregion
@@ -653,22 +669,9 @@ function Form({ of, onSubmit,...other }) {
 		ref: (element) => {
 			of[INTERNAL].element = element;
 		},
-		onSubmit: async (event) => {
-			event.preventDefault();
-			const internalFormStore = of[INTERNAL];
-			internalFormStore.isSubmitted.value = true;
-			internalFormStore.isSubmitting.value = true;
-			try {
-				const result = await validateFormInput(internalFormStore, { shouldFocus: true });
-				if (result.success) await onSubmit(result.output, event);
-			} catch (error) {
-				internalFormStore.errors.value = [error instanceof Error ? error.message : "An unknown error has occurred."];
-			} finally {
-				internalFormStore.isSubmitting.value = false;
-			}
-		}
+		onSubmit: handleSubmit(of, onSubmit)
 	});
 }
 
 //#endregion
-export { Field, FieldArray, Form, focus, getAllErrors, getErrors, getInput, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };
+export { Field, FieldArray, Form, focus, getAllErrors, getErrors, getInput, handleSubmit, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formisch/preact",
   "description": "The modular and type-safe form library for Preact",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "license": "MIT",
   "author": "Fabian Hiller",
   "homepage": "https://formisch.dev",
@@ -11,13 +11,10 @@
   },
   "keywords": [
     "preact",
-    "modular",
+    "form",
     "typescript",
     "schema",
-    "validation",
-    "parsing",
-    "bundle-size",
-    "type-safe"
+    "validation"
   ],
   "type": "module",
   "main": "./dist/index.js",
@@ -37,7 +34,10 @@
   },
   "scripts": {
     "build": "tsdown",
-    "lint": "eslint \"src/**/*.ts*\""
+    "lint": "eslint \"src/**/*.ts*\" && tsc --noEmit",
+    "lint.fix": "eslint \"src/**/*.ts*\" --fix",
+    "format": "prettier --write ./src",
+    "format.check": "prettier --check ./src"
   },
   "devDependencies": {
     "@eslint/js": "^9.31.0",