@formisch/solid 0.1.0 → 0.1.1

package/README.md

@@ -57,7 +57,7 @@ export default function LoginPage() {
 }
 ```
 
-In addition, Formisch offers several functions (we call them "methods") that can be used to manipulate the form state. These include `reset`, `setInput`, and `setErrors`. These methods allow you to control the form programmatically.
+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.
 
 ## Feedback
 

package/dist/index.d.ts

@@ -1,102 +1,393 @@
-export * from '@formisch/methods/solid';
-import { Schema, RequiredPath, ValidPath, PartialValues, PathValue, FieldElement, ValidArrayPath, BaseFormStore, SubmitHandler, FormConfig } from '@formisch/core/solid';
-import { JSX } from 'solid-js';
-import * as v from 'valibot';
+import * as v from "valibot";
+import { JSX } from "solid-js";
 
+//#region ../../packages/core/dist/index.solid.d.ts
+//#region src/types/schema.d.ts
+type Schema = v.GenericSchema | v.GenericSchemaAsync;
+//#endregion
+//#region src/types/signal.d.ts
+interface Signal<T> {
+  value: T;
+}
+//#endregion
+//#region src/types/field.d.ts
+/**
+* Value type of the field element.
+*/
+type FieldElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+interface InternalBaseStore {
+  kind: "array" | "object" | "value";
+  name: string;
+  schema: Schema;
+  elements: FieldElement[];
+  errors: Signal<[string, ...string[]] | null>;
+}
+interface InternalArrayStore extends InternalBaseStore {
+  kind: "array";
+  children: InternalFieldStore[];
+  initialItems: Signal<string[]>;
+  startItems: Signal<string[]>;
+  items: Signal<string[]>;
+  isTouched: Signal<boolean>;
+  isDirty: Signal<boolean>;
+}
+interface InternalObjectStore extends InternalBaseStore {
+  kind: "object";
+  children: Record<string, InternalFieldStore>;
+}
+interface InternalValueStore extends InternalBaseStore {
+  kind: "value";
+  initialInput: Signal<unknown>;
+  startInput: Signal<unknown>;
+  input: Signal<unknown>;
+  isTouched: Signal<boolean>;
+  isDirty: Signal<boolean>;
+}
+type InternalFieldStore = InternalArrayStore | InternalObjectStore | InternalValueStore;
+//#endregion
+//#region src/values.d.ts
+declare const INTERNAL: "~internal";
+//#endregion
+//#region src/types/utils.d.ts
+/**
+* Checks if a type is `any`.
+*/
+type IsAny<Type> = 0 extends 1 & Type ? true : false;
+/**
+* Checks if a type is `never`.
+*/
+type IsNever<Type> = [Type] extends [never] ? true : false;
+/**
+* Constructs a type that is maybe a promise.
+*/
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+/**
+* Makes all properties deeply optional.
+*/
+type DeepPartial<TValue> = TValue extends readonly unknown[] ? number extends TValue["length"] ? TValue : { [Key in keyof TValue]?: DeepPartial<TValue[Key]> | undefined } : TValue extends Record<PropertyKey, unknown> ? { [Key in keyof TValue]?: DeepPartial<TValue[Key]> | undefined } : TValue | undefined;
+/**
+* Makes all value properties optional.
+*/
+type PartialValues<TValue> = TValue extends readonly unknown[] ? number extends TValue["length"] ? TValue : { [Key in keyof TValue]: PartialValues<TValue[Key]> } : TValue extends Record<PropertyKey, unknown> ? { [Key in keyof TValue]: PartialValues<TValue[Key]> } : TValue | undefined;
+//#endregion
+//#region src/types/form.d.ts
+/**
+* Value type of the validation mode.
+*/
+type ValidationMode = "initial" | "touch" | "input" | "change" | "blur" | "submit";
+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;
+}
+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>>;
+  isSubmitting: Signal<boolean>;
+  isSubmitted: Signal<boolean>;
+  isValidating: Signal<boolean>;
+}
+interface BaseFormStore<TSchema extends Schema = Schema> {
+  [INTERNAL]: InternalFormStore<TSchema>;
+}
+type SubmitHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>, event: SubmitEvent) => MaybePromise<void>;
+//#endregion
+//#region src/types/path.d.ts
+/**
+* Path key type.
+*/
+type PathKey = string | number;
+/**
+* Path type.
+*/
+type Path = readonly PathKey[];
+/**
+* Required path type.
+*/
+type RequiredPath = readonly [PathKey, ...Path];
+/**
+* Extracts the exact keys of a tuple, array or object.
+*/
+type KeyOf<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly unknown[] ? number extends TValue["length"] ? number : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? TIndex : never }[number] : TValue extends Record<string, unknown> ? keyof TValue & PathKey : never;
+/**
+* Merges array and object unions into a single object.
+*
+* Hint: This is necessary to make any property accessible. By default,
+* properties that do not exist in all union options are not accessible
+* and result in "any" when accessed.
+*/
+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;
 /**
- * Value type of the field element props.
- */
+* 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>;
+/**
+* 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;
+/**
+* Checks if a value is an array or contains one.
+*/
+type IsOrHasArray<TValue> = IsAny<TValue> extends true ? false : TValue extends readonly unknown[] ? true : TValue extends Record<string, unknown> ? true extends { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> }[keyof TValue] ? true : false : false;
+/**
+* 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;
+/**
+* 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;
+/**
+* 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>;
+//#endregion
+//#region src/array/copyItemState/copyItemState.d.ts
+/**
+* Copies the deeply nested state (signal values) from one array item to another.
+* This includes the `isTouched`, `isDirty`, `startInput`, `input`, `startItems`, and `items` properties.
+* Recursively walks through the field stores and copies all signal values.
+*
+* @param internalArrayStore - The field store of the array (not the array item)
+* @param fromIndex - The source index to copy from
+* @param toIndex - The destination index to copy to
+*/
+//#endregion
+//#region ../../packages/methods/dist/index.solid.d.ts
+//#region src/focus/focus.d.ts
+interface FocusFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly form: BaseFormStore<TSchema>;
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+declare function focus<TSchema extends Schema, TFieldPath extends RequiredPath>(config: FocusFieldConfig<TSchema, TFieldPath>): void;
+//#endregion
+//#region src/getAllErrors/getAllErrors.d.ts
+declare function getAllErrors(form: BaseFormStore): [string, ...string[]] | null;
+//#endregion
+//#region src/getErrors/getErrors.d.ts
+interface GetFormErrorsConfig {
+  readonly path?: undefined;
+}
+interface GetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+declare function getErrors<TSchema extends Schema>(form: BaseFormStore<TSchema>): [string, ...string[]] | null;
+declare function getErrors<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldErrorsConfig<TSchema, TFieldPath> : GetFormErrorsConfig): [string, ...string[]] | null;
+//#endregion
+//#region src/getInput/getInput.d.ts
+interface GetFormInputConfig {
+  readonly path?: undefined;
+}
+interface GetFieldInputConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+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/insert/insert.d.ts
+interface InsertConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly at?: number | undefined;
+  readonly initialInput?: DeepPartial<PathValue<v.InferInput<TSchema>, [...TFieldArrayPath, number]>> | undefined;
+}
+declare function insert<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: InsertConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/move/move.d.ts
+interface MoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly from: number;
+  readonly to: number;
+}
+declare function move<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: MoveConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/remove/remove.d.ts
+interface RemoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly at: number;
+}
+declare function remove<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: RemoveConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/replace/replace.d.ts
+interface ReplaceConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly at: number;
+  readonly initialInput?: DeepPartial<PathValue<v.InferInput<TSchema>, [...TFieldArrayPath, number]>> | undefined;
+}
+declare function replace<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: ReplaceConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/reset/reset.d.ts
+interface ResetBaseConfig {
+  readonly keepInput?: boolean | undefined;
+  readonly keepTouched?: boolean | undefined;
+  readonly keepErrors?: boolean | undefined;
+}
+interface ResetFormConfig<TSchema extends Schema> extends ResetBaseConfig {
+  readonly path?: undefined;
+  readonly initialInput?: DeepPartial<v.InferInput<TSchema>> | undefined;
+  readonly keepSubmitCount?: boolean | undefined;
+  readonly keepSubmitted?: boolean | undefined;
+}
+interface ResetFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPath> extends ResetBaseConfig {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly initialInput?: DeepPartial<PathValue<v.InferInput<TSchema>, TFieldPath>>;
+}
+declare function reset(form: BaseFormStore): void;
+declare function reset<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? ResetFieldConfig<TSchema, TFieldPath> : ResetFormConfig<TSchema>): void;
+//#endregion
+//#region src/setErrors/setErrors.d.ts
+interface SetFormErrorsConfig {
+  readonly path?: undefined;
+  readonly errors: [string, ...string[]] | null;
+}
+interface SetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly errors: [string, ...string[]] | null;
+}
+declare function setErrors<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? SetFieldErrorsConfig<TSchema, TFieldPath> : SetFormErrorsConfig): void;
+//#endregion
+//#region src/setInput/setInput.d.ts
+interface SetFormInputConfig<TSchema extends Schema> {
+  readonly path?: undefined;
+  readonly input: v.InferInput<TSchema>;
+}
+interface SetFieldInputConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly input: PathValue<v.InferInput<TSchema>, TFieldPath>;
+}
+declare function setInput<TSchema extends Schema>(form: BaseFormStore<TSchema>, config: SetFormInputConfig<TSchema>): void;
+declare function setInput<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? SetFieldInputConfig<TSchema, TFieldPath> : SetFormInputConfig<TSchema>): void;
+//#endregion
+//#region src/submit/submit.d.ts
+declare function submit(form: BaseFormStore): void;
+//#endregion
+//#region src/swap/swap.d.ts
+interface SwapConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly at: number;
+  readonly and: number;
+}
+declare function swap<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: SwapConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/validate/validate.d.ts
+interface ValidateFormConfig {
+  readonly shouldFocus?: boolean | undefined;
+}
+declare function validate<TSchema extends Schema>(form: BaseFormStore<TSchema>, config?: ValidateFormConfig): Promise<v.SafeParseResult<TSchema>>;
+//#endregion
+//#endregion
+//#region src/types/field.d.ts
+/**
+* Value type of the field element props.
+*/
 interface FieldElementProps {
-    readonly name: string;
-    readonly autofocus: boolean;
-    readonly ref: (element: FieldElement) => void;
-    readonly onFocus: JSX.EventHandler<FieldElement, FocusEvent>;
-    readonly onInput: JSX.EventHandler<FieldElement, InputEvent>;
-    readonly onChange: JSX.EventHandler<FieldElement, Event>;
-    readonly onBlur: JSX.EventHandler<FieldElement, FocusEvent>;
+  readonly name: string;
+  readonly autofocus: boolean;
+  readonly ref: (element: FieldElement) => void;
+  readonly onFocus: JSX.EventHandler<FieldElement, FocusEvent>;
+  readonly onInput: JSX.EventHandler<FieldElement, InputEvent>;
+  readonly onChange: JSX.EventHandler<FieldElement, Event>;
+  readonly onBlur: JSX.EventHandler<FieldElement, FocusEvent>;
 }
 /**
- * Value type of the field store.
- */
+* Value type of the field store.
+*/
 interface FieldStore<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
-    readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
-    readonly input: PartialValues<PathValue<v.InferInput<TSchema>, TFieldPath>>;
-    readonly errors: [string, ...string[]] | null;
-    readonly isTouched: boolean;
-    readonly isDirty: boolean;
-    readonly isValid: boolean;
-    readonly props: FieldElementProps;
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly input: PartialValues<PathValue<v.InferInput<TSchema>, TFieldPath>>;
+  readonly errors: [string, ...string[]] | null;
+  readonly isTouched: boolean;
+  readonly isDirty: boolean;
+  readonly isValid: boolean;
+  readonly props: FieldElementProps;
 }
 /**
- * Value type of the field array store.
- */
+* Value type of the field array store.
+*/
 interface FieldArrayStore<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
-    readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
-    readonly items: string[];
-    readonly errors: [string, ...string[]] | null;
-    readonly isTouched: boolean;
-    readonly isDirty: boolean;
-    readonly isValid: boolean;
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly items: string[];
+  readonly errors: [string, ...string[]] | null;
+  readonly isTouched: boolean;
+  readonly isDirty: boolean;
+  readonly isValid: boolean;
 }
-
+//#endregion
+//#region src/types/form.d.ts
 interface FormStore<TSchema extends Schema = Schema> extends BaseFormStore<TSchema> {
-    readonly isSubmitting: boolean;
-    readonly isSubmitted: boolean;
-    readonly isValidating: boolean;
-    readonly isTouched: boolean;
-    readonly isDirty: boolean;
-    readonly isValid: boolean;
-    readonly errors: [string, ...string[]] | null;
+  readonly isSubmitting: boolean;
+  readonly isSubmitted: boolean;
+  readonly isValidating: boolean;
+  readonly isTouched: boolean;
+  readonly isDirty: boolean;
+  readonly isValid: boolean;
+  readonly errors: [string, ...string[]] | null;
 }
-
+//#endregion
+//#region src/types/utils.d.ts
 /**
- * Constructs a type that is maybe a getter function.
- */
+* Constructs a type that is maybe a getter function.
+*/
 type MaybeGetter<TValue> = TValue | (() => TValue);
-
+//#endregion
+//#region src/components/Field/Field.d.ts
 /**
- * Properties of the `Field` component.
- */
+* Properties of the `Field` component.
+*/
 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 of: FormStore<TSchema>;
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly render: (store: FieldStore<TSchema, TFieldPath>) => JSX.Element;
 }
 /**
- * Headless form field that provides reactive properties and state.
- */
+* Headless form field that provides reactive properties and state.
+*/
 declare function Field<TSchema extends Schema, TFieldPath extends RequiredPath>(props: FieldProps<TSchema, TFieldPath>): JSX.Element;
-
+//#endregion
+//#region src/components/FieldArray/FieldArray.d.ts
 /**
- * Properties of the `FieldArray` component.
- */
+* Properties of the `FieldArray` component.
+*/
 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 of: FormStore<TSchema>;
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly render: (store: FieldArrayStore<TSchema, TFieldArrayPath>) => JSX.Element;
 }
 /**
- * Headless field array that provides reactive properties and state.
- */
+* Headless field array that provides reactive properties and state.
+*/
 declare function FieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(props: FieldArrayProps<TSchema, TFieldArrayPath>): JSX.Element;
-
-type FormProps<TSchema extends Schema = Schema> = Omit<JSX.FormHTMLAttributes<HTMLFormElement>, 'onSubmit'> & {
-    of: FormStore<TSchema>;
-    children: JSX.Element;
-    onSubmit: SubmitHandler<TSchema>;
+//#endregion
+//#region src/components/Form/Form.d.ts
+type FormProps<TSchema extends Schema = Schema> = Omit<JSX.FormHTMLAttributes<HTMLFormElement>, "onSubmit"> & {
+  of: FormStore<TSchema>;
+  children: JSX.Element;
+  onSubmit: SubmitHandler<TSchema>;
 };
 declare function Form<TSchema extends Schema>(props: FormProps<TSchema>): JSX.Element;
-
+//#endregion
+//#region src/primitives/createForm/createForm.d.ts
 declare function createForm<TSchema extends Schema>(config: FormConfig<TSchema>): FormStore<TSchema>;
-
+//#endregion
+//#region src/primitives/useField/useField.d.ts
 interface UseFieldConfig<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
-    readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
 }
 declare function useField<TSchema extends Schema, TFieldPath extends RequiredPath>(form: MaybeGetter<FormStore<TSchema>>, config: MaybeGetter<UseFieldConfig<TSchema, TFieldPath>>): FieldStore<TSchema, TFieldPath>;
-
+//#endregion
+//#region src/primitives/useFieldArray/useFieldArray.d.ts
 interface UseFieldArrayConfig<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
-    readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
+  readonly path: ValidArrayPath<v.InferInput<TSchema>, TFieldArrayPath>;
 }
 declare function useFieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: MaybeGetter<FormStore<TSchema>>, config: MaybeGetter<UseFieldArrayConfig<TSchema, TFieldArrayPath>>): FieldArrayStore<TSchema, TFieldArrayPath>;
-
-export { Field, FieldArray, type FieldArrayProps, type FieldArrayStore, type FieldElementProps, type FieldProps, type FieldStore, Form, type FormProps, type FormStore, type MaybeGetter, type UseFieldArrayConfig, type UseFieldConfig, createForm, useField, useFieldArray };
+//#endregion
+export { Field, FieldArray, FieldArrayProps, FieldArrayStore, FieldElementProps, FieldProps, FieldStore, FocusFieldConfig, Form, FormProps, FormStore, GetFieldErrorsConfig, GetFieldInputConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MaybeGetter, MoveConfig, RemoveConfig, ReplaceConfig, ResetFieldConfig, ResetFormConfig, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, SwapConfig, UseFieldArrayConfig, UseFieldConfig, ValidateFormConfig, createForm, focus, getAllErrors, getErrors, getInput, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, validate };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formisch/solid",
   "description": "The modular and type-safe form library for SolidJS",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "author": "Fabian Hiller",
   "homepage": "https://formisch.dev",
@@ -53,7 +53,7 @@
     "lint.fix": "eslint \"src/**/*.ts*\" --fix",
     "format": "prettier --write ./src",
     "format.check": "prettier --check ./src",
-    "build": "tsup"
+    "build": "tsup && tsdown"
   },
   "devDependencies": {
     "@eslint/js": "^9.31.0",