@tanstack/form-core 0.42.0 → 0.43.0

package/src/FormApi.ts

@@ -5,17 +5,22 @@ import {
   getAsyncValidatorArray,
   getBy,
   getSyncValidatorArray,
+  isGlobalFormValidationError,
   isNonEmptyArray,
   setBy,
   shallow,
 } from './utils'
 import {
   isStandardSchemaValidator,
-  standardSchemaValidator,
+  standardSchemaValidators,
 } from './standardSchemaValidator'
 import { metaHelper } from './metaHelper'
-import type { StandardSchemaV1 } from './standardSchemaValidator'
-import type { FieldApi, FieldMeta, FieldMetaBase } from './FieldApi'
+import type {
+  StandardSchemaV1,
+  StandardSchemaV1Issue,
+  TStandardSchemaValidatorValue,
+} from './standardSchemaValidator'
+import type { AnyFieldMeta, AnyFieldMetaBase, FieldApi } from './FieldApi'
 import type {
   FormValidationError,
   FormValidationErrorMap,
@@ -24,48 +29,90 @@ import type {
   ValidationError,
   ValidationErrorMap,
   ValidationErrorMapKeys,
-  ValidationSource,
-  Validator,
 } from './types'
 import type { DeepKeys, DeepValue } from './util-types'
 import type { Updater } from './utils'
 
-export type FieldsErrorMapFromValidator<TFormData> = Partial<
-  Record<DeepKeys<TFormData>, ValidationErrorMap>
+/**
+ * @private
+ */
+// TODO: Add the `Unwrap` type to the errors
+type FormErrorMapFromValidator<
+  TFormData,
+  TOnMount extends undefined | FormValidateOrFn<TFormData>,
+  TOnChange extends undefined | FormValidateOrFn<TFormData>,
+  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
+  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
+  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+> = Partial<
+  Record<
+    DeepKeys<TFormData>,
+    ValidationErrorMap<
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync
+    >
+  >
 >
 
-export type FormValidateFn<
-  TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
-> = (props: {
+export type FormValidateFn<TFormData> = (props: {
   value: TFormData
-  formApi: FormApi<TFormData, TFormValidator>
-}) => FormValidationError<TFormData>
+  formApi: FormApi<
+    TFormData,
+    // This is technically an edge-type; which we try to keep non-`any`, but in this case
+    // It's referring to an inaccessible type from the field validate function inner types, so it's not a big deal
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >
+}) => unknown
 
 /**
  * @private
  */
-export type FormValidateOrFn<
-  TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
-> =
-  TFormValidator extends Validator<TFormData, infer TFN>
-    ? TFN | FormValidateFn<TFormData, TFormValidator>
-    :
-        | FormValidateFn<TFormData, TFormValidator>
-        | StandardSchemaV1<TFormData, unknown>
+export type FormValidateOrFn<TFormData> =
+  | FormValidateFn<TFormData>
+  | StandardSchemaV1<TFormData, unknown>
+
+export type UnwrapFormValidateOrFn<
+  TValidateOrFn extends undefined | FormValidateOrFn<any>,
+> = [TValidateOrFn] extends [FormValidateFn<any>]
+  ? ReturnType<TValidateOrFn>
+  : [TValidateOrFn] extends [StandardSchemaV1<any, any>]
+    ? Record<string, StandardSchemaV1Issue[]>
+    : undefined
 
 /**
  * @private
  */
-export type FormValidateAsyncFn<
-  TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
-> = (props: {
+export type FormValidateAsyncFn<TFormData> = (props: {
   value: TFormData
-  formApi: FormApi<TFormData, TFormValidator>
+  formApi: FormApi<
+    TFormData,
+    // This is technically an edge-type; which we try to keep non-`any`, but in this case
+    // It's referring to an inaccessible type from the field validate function inner types, so it's not a big deal
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >
   signal: AbortSignal
-}) => FormValidationError<TFormData> | Promise<FormValidationError<TFormData>>
+}) => unknown | Promise<unknown>
 
 export type FormValidator<TFormData, TType, TFn = unknown> = {
   validate(options: { value: TType }, fn: TFn): ValidationError
@@ -85,32 +132,40 @@ type ValidationPromiseResult<TFormData> =
 /**
  * @private
  */
-export type FormAsyncValidateOrFn<
-  TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
-> =
-  TFormValidator extends Validator<TFormData, infer FFN>
-    ? FFN | FormValidateAsyncFn<TFormData, TFormValidator>
-    :
-        | FormValidateAsyncFn<TFormData, TFormValidator>
-        | StandardSchemaV1<TFormData, unknown>
+export type FormAsyncValidateOrFn<TFormData> =
+  | FormValidateAsyncFn<TFormData>
+  | StandardSchemaV1<TFormData, unknown>
+
+export type UnwrapFormAsyncValidateOrFn<
+  TValidateOrFn extends undefined | FormAsyncValidateOrFn<any>,
+> = [TValidateOrFn] extends [FormValidateAsyncFn<any>]
+  ? Awaited<ReturnType<TValidateOrFn>>
+  : [TValidateOrFn] extends [StandardSchemaV1<any, any>]
+    ? Record<string, StandardSchemaV1Issue[]>
+    : undefined
 
 export interface FormValidators<
   TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
+  TOnMount extends undefined | FormValidateOrFn<TFormData>,
+  TOnChange extends undefined | FormValidateOrFn<TFormData>,
+  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
+  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
+  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
 > {
   /**
    * Optional function that fires as soon as the component mounts.
    */
-  onMount?: FormValidateOrFn<TFormData, TFormValidator>
+  onMount?: TOnMount
   /**
    * Optional function that checks the validity of your data whenever a value changes
    */
-  onChange?: FormValidateOrFn<TFormData, TFormValidator>
+  onChange?: TOnChange
   /**
    * Optional onChange asynchronous counterpart to onChange. Useful for more complex validation logic that might involve server requests.
    */
-  onChangeAsync?: FormAsyncValidateOrFn<TFormData, TFormValidator>
+  onChangeAsync?: TOnChangeAsync
   /**
    * The default time in milliseconds that if set to a number larger than 0, will debounce the async validation event by this length of time in milliseconds.
    */
@@ -118,17 +173,17 @@ export interface FormValidators<
   /**
    * Optional function that validates the form data when a field loses focus, returns a `FormValidationError`
    */
-  onBlur?: FormValidateOrFn<TFormData, TFormValidator>
+  onBlur?: TOnBlur
   /**
    * Optional onBlur asynchronous validation method for when a field loses focus returns a ` FormValidationError` or a promise of `Promise<FormValidationError>`
    */
-  onBlurAsync?: FormAsyncValidateOrFn<TFormData, TFormValidator>
+  onBlurAsync?: TOnBlurAsync
   /**
    * The default time in milliseconds that if set to a number larger than 0, will debounce the async validation event by this length of time in milliseconds.
    */
   onBlurAsyncDebounceMs?: number
-  onSubmit?: FormValidateOrFn<TFormData, TFormValidator>
-  onSubmitAsync?: FormAsyncValidateOrFn<TFormData, TFormValidator>
+  onSubmit?: TOnSubmit
+  onSubmitAsync?: TOnSubmitAsync
 }
 
 /**
@@ -136,11 +191,38 @@ export interface FormValidators<
  */
 export interface FormTransform<
   TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
+  TOnMount extends undefined | FormValidateOrFn<TFormData>,
+  TOnChange extends undefined | FormValidateOrFn<TFormData>,
+  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
+  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
+  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>,
 > {
   fn: (
-    formBase: FormApi<TFormData, TFormValidator>,
-  ) => FormApi<TFormData, TFormValidator>
+    formBase: FormApi<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync,
+      TOnServer
+    >,
+  ) => FormApi<
+    TFormData,
+    TOnMount,
+    TOnChange,
+    TOnChangeAsync,
+    TOnBlur,
+    TOnBlurAsync,
+    TOnSubmit,
+    TOnSubmitAsync,
+    TOnServer
+  >
   deps: unknown[]
 }
 
@@ -149,7 +231,14 @@ export interface FormTransform<
  */
 export interface FormOptions<
   TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
+  TOnMount extends undefined | FormValidateOrFn<TFormData>,
+  TOnChange extends undefined | FormValidateOrFn<TFormData>,
+  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
+  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
+  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>,
 > {
   /**
    * Set initial values for your form.
@@ -158,7 +247,19 @@ export interface FormOptions<
   /**
    * The default state for the form.
    */
-  defaultState?: Partial<FormState<TFormData>>
+  defaultState?: Partial<
+    FormState<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync,
+      TOnServer
+    >
+  >
   /**
    * If true, always run async validation, even when sync validation has produced an error. Defaults to undefined.
    */
@@ -167,29 +268,64 @@ export interface FormOptions<
    * Optional time in milliseconds if you want to introduce a delay before firing off an async action.
    */
   asyncDebounceMs?: number
-  /**
-   * A validator adapter to support usage of extra validation types (IE: Zod, Yup, or Valibot usage)
-   */
-  validatorAdapter?: TFormValidator
   /**
    * A list of validators to pass to the form
    */
-  validators?: FormValidators<TFormData, TFormValidator>
+  validators?: FormValidators<
+    TFormData,
+    TOnMount,
+    TOnChange,
+    TOnChangeAsync,
+    TOnBlur,
+    TOnBlurAsync,
+    TOnSubmit,
+    TOnSubmitAsync
+  >
   /**
    * A function to be called when the form is submitted, what should happen once the user submits a valid form returns `any` or a promise `Promise<any>`
    */
   onSubmit?: (props: {
     value: TFormData
-    formApi: FormApi<TFormData, TFormValidator>
+    formApi: FormApi<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync,
+      TOnServer
+    >
   }) => any | Promise<any>
   /**
    * Specify an action for scenarios where the user tries to submit an invalid form.
    */
   onSubmitInvalid?: (props: {
     value: TFormData
-    formApi: FormApi<TFormData, TFormValidator>
+    formApi: FormApi<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync,
+      TOnServer
+    >
   }) => void
-  transform?: FormTransform<TFormData, TFormValidator>
+  transform?: FormTransform<
+    TFormData,
+    TOnMount,
+    TOnChange,
+    TOnChangeAsync,
+    TOnBlur,
+    TOnBlurAsync,
+    TOnSubmit,
+    TOnSubmitAsync,
+    TOnServer
+  >
 }
 
 /**
@@ -205,18 +341,29 @@ export type ValidationMeta = {
 /**
  * An object representing the field information for a specific field within the form.
  */
-export type FieldInfo<
-  TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
-> = {
+export type FieldInfo<TFormData> = {
   /**
    * An instance of the FieldAPI.
    */
   instance: FieldApi<
     TFormData,
     any,
-    Validator<unknown, unknown> | undefined,
-    TFormValidator
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
   > | null
   /**
    * A record of field validation internal handling.
@@ -227,7 +374,17 @@ export type FieldInfo<
 /**
  * An object representing the current state of the form.
  */
-export type BaseFormState<TFormData> = {
+export type BaseFormState<
+  TFormData,
+  TOnMount extends undefined | FormValidateOrFn<TFormData>,
+  TOnChange extends undefined | FormValidateOrFn<TFormData>,
+  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
+  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
+  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>,
+> = {
   /**
    * The current values of the form fields.
    */
@@ -235,7 +392,16 @@ export type BaseFormState<TFormData> = {
   /**
    * The error map for the form itself.
    */
-  errorMap: FormValidationErrorMap
+  errorMap: FormValidationErrorMap<
+    UnwrapFormValidateOrFn<TOnMount>,
+    UnwrapFormValidateOrFn<TOnChange>,
+    UnwrapFormAsyncValidateOrFn<TOnChangeAsync>,
+    UnwrapFormValidateOrFn<TOnBlur>,
+    UnwrapFormAsyncValidateOrFn<TOnBlurAsync>,
+    UnwrapFormValidateOrFn<TOnSubmit>,
+    UnwrapFormAsyncValidateOrFn<TOnSubmitAsync>,
+    UnwrapFormAsyncValidateOrFn<TOnServer>
+  >
   /**
    * An internal mechanism used for keeping track of validation logic in a form.
    */
@@ -243,7 +409,7 @@ export type BaseFormState<TFormData> = {
   /**
    * A record of field metadata for each field in the form, not including the derived properties, like `errors` and such
    */
-  fieldMetaBase: Record<DeepKeys<TFormData>, FieldMetaBase>
+  fieldMetaBase: Record<DeepKeys<TFormData>, AnyFieldMetaBase>
   /**
    * A boolean indicating if the form is currently in the process of being submitted after `handleSubmit` is called.
    *
@@ -271,7 +437,17 @@ export type BaseFormState<TFormData> = {
   submissionAttempts: number
 }
 
-export type DerivedFormState<TFormData> = {
+export type DerivedFormState<
+  TFormData,
+  TOnMount extends undefined | FormValidateOrFn<TFormData>,
+  TOnChange extends undefined | FormValidateOrFn<TFormData>,
+  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
+  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
+  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>,
+> = {
   /**
    * A boolean indicating if the form is currently validating.
    */
@@ -283,7 +459,16 @@ export type DerivedFormState<TFormData> = {
   /**
    * The error array for the form itself.
    */
-  errors: ValidationError[]
+  errors: Array<
+    | UnwrapFormValidateOrFn<TOnMount>
+    | UnwrapFormValidateOrFn<TOnChange>
+    | UnwrapFormAsyncValidateOrFn<TOnChangeAsync>
+    | UnwrapFormValidateOrFn<TOnBlur>
+    | UnwrapFormAsyncValidateOrFn<TOnBlurAsync>
+    | UnwrapFormValidateOrFn<TOnSubmit>
+    | UnwrapFormAsyncValidateOrFn<TOnSubmitAsync>
+    | UnwrapFormAsyncValidateOrFn<TOnServer>
+  >
   /**
    * A boolean indicating if any of the form fields are currently validating.
    */
@@ -319,15 +504,89 @@ export type DerivedFormState<TFormData> = {
   /**
    * A record of field metadata for each field in the form.
    */
-  fieldMeta: Record<DeepKeys<TFormData>, FieldMeta>
+  fieldMeta: Record<DeepKeys<TFormData>, AnyFieldMeta>
 }
 
-export type FormState<TFormData> = BaseFormState<TFormData> &
-  DerivedFormState<TFormData>
+export type FormState<
+  TFormData,
+  TOnMount extends undefined | FormValidateOrFn<TFormData>,
+  TOnChange extends undefined | FormValidateOrFn<TFormData>,
+  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
+  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
+  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>,
+> = BaseFormState<
+  TFormData,
+  TOnMount,
+  TOnChange,
+  TOnChangeAsync,
+  TOnBlur,
+  TOnBlurAsync,
+  TOnSubmit,
+  TOnSubmitAsync,
+  TOnServer
+> &
+  DerivedFormState<
+    TFormData,
+    TOnMount,
+    TOnChange,
+    TOnChangeAsync,
+    TOnBlur,
+    TOnBlurAsync,
+    TOnSubmit,
+    TOnSubmitAsync,
+    TOnServer
+  >
+
+export type AnyFormState = FormState<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+>
 
-function getDefaultFormState<TFormData>(
-  defaultState: Partial<FormState<TFormData>>,
-): BaseFormState<TFormData> {
+function getDefaultFormState<
+  TFormData,
+  TOnMount extends undefined | FormValidateOrFn<TFormData>,
+  TOnChange extends undefined | FormValidateOrFn<TFormData>,
+  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
+  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
+  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>,
+>(
+  defaultState: Partial<
+    FormState<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync,
+      TOnServer
+    >
+  >,
+): BaseFormState<
+  TFormData,
+  TOnMount,
+  TOnChange,
+  TOnChangeAsync,
+  TOnBlur,
+  TOnBlurAsync,
+  TOnSubmit,
+  TOnSubmitAsync,
+  TOnServer
+> {
   return {
     values: defaultState.values ?? ({} as never),
     errorMap: defaultState.errorMap ?? {},
@@ -346,11 +605,12 @@ function getDefaultFormState<TFormData>(
   }
 }
 
-const isFormValidationError = (
-  error: unknown,
-): error is FormValidationError<unknown> => {
-  return typeof error === 'object'
-}
+/**
+ * @public
+ *
+ * A type representing the Form API with all generics set to `any` for convenience.
+ */
+export type AnyFormApi = FormApi<any, any, any, any, any, any, any, any, any>
 
 /**
  * A class representing the Form API. It handles the logic and interactions with the form state.
@@ -361,20 +621,60 @@ const isFormValidationError = (
  */
 export class FormApi<
   TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
+  TOnMount extends undefined | FormValidateOrFn<TFormData>,
+  TOnChange extends undefined | FormValidateOrFn<TFormData>,
+  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
+  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
+  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
+  TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>,
 > {
   /**
    * The options for the form.
    */
-  options: FormOptions<TFormData, TFormValidator> = {}
-  baseStore!: Store<BaseFormState<TFormData>>
-  fieldMetaDerived!: Derived<Record<DeepKeys<TFormData>, FieldMeta>>
-  store!: Derived<FormState<TFormData>>
+  options: FormOptions<
+    TFormData,
+    TOnMount,
+    TOnChange,
+    TOnChangeAsync,
+    TOnBlur,
+    TOnBlurAsync,
+    TOnSubmit,
+    TOnSubmitAsync,
+    TOnServer
+  > = {}
+  baseStore!: Store<
+    BaseFormState<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync,
+      TOnServer
+    >
+  >
+  fieldMetaDerived!: Derived<Record<DeepKeys<TFormData>, AnyFieldMeta>>
+  store!: Derived<
+    FormState<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync,
+      TOnServer
+    >
+  >
   /**
    * A record of field information for each field in the form.
    */
-  fieldInfo: Record<DeepKeys<TFormData>, FieldInfo<TFormData, TFormValidator>> =
-    {} as any
+  fieldInfo: Record<DeepKeys<TFormData>, FieldInfo<TFormData>> = {} as any
 
   get state() {
     return this.store.state
@@ -388,7 +688,19 @@ export class FormApi<
   /**
    * Constructs a new `FormApi` instance with the given form options.
    */
-  constructor(opts?: FormOptions<TFormData, TFormValidator>) {
+  constructor(
+    opts?: FormOptions<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync,
+      TOnServer
+    >,
+  ) {
     this.baseStore = new Store(
       getDefaultFormState({
         ...(opts?.defaultState as any),
@@ -401,24 +713,35 @@ export class FormApi<
       deps: [this.baseStore],
       fn: ({ prevDepVals, currDepVals, prevVal: _prevVal }) => {
         const prevVal = _prevVal as
-          | Record<DeepKeys<TFormData>, FieldMeta>
+          | Record<DeepKeys<TFormData>, AnyFieldMeta>
           | undefined
         const prevBaseStore = prevDepVals?.[0]
         const currBaseStore = currDepVals[0]
 
         let originalMetaCount = 0
 
-        const fieldMeta = {} as FormState<TFormData>['fieldMeta']
+        const fieldMeta = {} as FormState<
+          TFormData,
+          TOnMount,
+          TOnChange,
+          TOnChangeAsync,
+          TOnBlur,
+          TOnBlurAsync,
+          TOnSubmit,
+          TOnSubmitAsync,
+          TOnServer
+        >['fieldMeta']
+
         for (const fieldName of Object.keys(
           currBaseStore.fieldMetaBase,
         ) as Array<keyof typeof currBaseStore.fieldMetaBase>) {
           const currBaseVal = currBaseStore.fieldMetaBase[
             fieldName as never
-          ] as FieldMetaBase
+          ] as AnyFieldMetaBase
 
           const prevBaseVal = prevBaseStore?.fieldMetaBase[
             fieldName as never
-          ] as FieldMetaBase | undefined
+          ] as AnyFieldMetaBase | undefined
 
           const prevFieldInfo =
             prevVal?.[fieldName as never as keyof typeof prevVal]
@@ -427,11 +750,20 @@ export class FormApi<
           if (!prevBaseVal || currBaseVal.errorMap !== prevBaseVal.errorMap) {
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             fieldErrors = Object.values(currBaseVal.errorMap ?? {}).filter(
-              (val: unknown) => val !== undefined,
-            )
+              (val) => val !== undefined,
+            ) as never
+
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            const fieldInstance = this.getFieldInfo(fieldName)?.instance
+
+            if (fieldInstance && !fieldInstance.options.disableErrorFlat) {
+              fieldErrors = (fieldErrors as undefined | string[])?.flat(
+                1,
+              ) as never
+            }
           }
 
-          // As a primitive, we don't need to aggressively persist the same referencial value for performance reasons
+          // As a primitive, we don't need to aggressively persist the same referential value for performance reasons
           const isFieldPristine = !currBaseVal.isDirty
 
           if (
@@ -449,7 +781,7 @@ export class FormApi<
             ...currBaseVal,
             errors: fieldErrors,
             isPristine: isFieldPristine,
-          } as FieldMeta
+          } as AnyFieldMeta
         }
 
         if (
@@ -466,13 +798,25 @@ export class FormApi<
     this.store = new Derived({
       deps: [this.baseStore, this.fieldMetaDerived],
       fn: ({ prevDepVals, currDepVals, prevVal: _prevVal }) => {
-        const prevVal = _prevVal as FormState<TFormData> | undefined
+        const prevVal = _prevVal as
+          | FormState<
+              TFormData,
+              TOnMount,
+              TOnChange,
+              TOnChangeAsync,
+              TOnBlur,
+              TOnBlurAsync,
+              TOnSubmit,
+              TOnSubmitAsync,
+              TOnServer
+            >
+          | undefined
         const prevBaseStore = prevDepVals?.[0]
         const currBaseStore = currDepVals[0]
 
         // Computed state
         const fieldMetaValues = Object.values(currBaseStore.fieldMetaBase) as (
-          | FieldMeta
+          | AnyFieldMeta
           | undefined
         )[]
 
@@ -511,21 +855,27 @@ export class FormApi<
           !prevBaseStore ||
           currBaseStore.errorMap !== prevBaseStore.errorMap
         ) {
-          errors = Object.values(currBaseStore.errorMap).reduce(
-            (prev, curr) => {
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              if (curr === undefined) return prev
-              if (typeof curr === 'string') {
-                prev.push(curr)
-                return prev
-              } else if (curr && isFormValidationError(curr)) {
-                prev.push(curr.form)
-                return prev
-              }
+          errors = Object.values(currBaseStore.errorMap).reduce<
+            Array<
+              | UnwrapFormValidateOrFn<TOnMount>
+              | UnwrapFormValidateOrFn<TOnChange>
+              | UnwrapFormAsyncValidateOrFn<TOnChangeAsync>
+              | UnwrapFormValidateOrFn<TOnBlur>
+              | UnwrapFormAsyncValidateOrFn<TOnBlurAsync>
+              | UnwrapFormValidateOrFn<TOnSubmit>
+              | UnwrapFormAsyncValidateOrFn<TOnSubmitAsync>
+              | UnwrapFormAsyncValidateOrFn<TOnServer>
+            >
+          >((prev, curr) => {
+            if (curr === undefined) return prev
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (curr && isGlobalFormValidationError(curr)) {
+              prev.push(curr.form as never)
               return prev
-            },
-            [] as ValidationError[],
-          )
+            }
+            prev.push(curr as never)
+            return prev
+          }, [])
         }
 
         const isFormValid = errors.length === 0
@@ -578,7 +928,17 @@ export class FormApi<
           isBlurred,
           isPristine,
           isDirty,
-        } as FormState<TFormData>
+        } as FormState<
+          TFormData,
+          TOnMount,
+          TOnChange,
+          TOnChangeAsync,
+          TOnBlur,
+          TOnBlurAsync,
+          TOnSubmit,
+          TOnSubmitAsync,
+          TOnServer
+        >
 
         // Only run transform if state has shallowly changed - IE how React.useEffect works
         const transformArray = this.options.transform?.deps ?? []
@@ -605,35 +965,25 @@ export class FormApi<
    * @private
    */
   runValidator<
-    TValue extends {
-      value: TFormData
-      formApi: FormApi<any, any>
-      validationSource: ValidationSource
+    TValue extends TStandardSchemaValidatorValue<TFormData> & {
+      formApi: AnyFormApi
     },
     TType extends 'validate' | 'validateAsync',
   >(props: {
     validate: TType extends 'validate'
-      ? FormValidateOrFn<TFormData, TFormValidator>
-      : FormAsyncValidateOrFn<TFormData, TFormValidator>
+      ? FormValidateOrFn<TFormData>
+      : FormAsyncValidateOrFn<TFormData>
     value: TValue
     type: TType
-  }): ReturnType<ReturnType<Validator<any>>[TType]> {
-    const adapter = this.options.validatorAdapter
-    if (
-      adapter &&
-      (typeof props.validate !== 'function' || '~standard' in props.validate)
-    ) {
-      return adapter()[props.type](props.value, props.validate) as never
-    }
-
+  }): unknown {
     if (isStandardSchemaValidator(props.validate)) {
-      return standardSchemaValidator()()[props.type](
+      return standardSchemaValidators[props.type](
         props.value,
         props.validate,
       ) as never
     }
 
-    return (props.validate as FormValidateFn<any, any>)(props.value) as never
+    return (props.validate as FormValidateFn<any>)(props.value) as never
   }
 
   mount = () => {
@@ -653,7 +1003,19 @@ export class FormApi<
   /**
    * Updates the form options and form state.
    */
-  update = (options?: FormOptions<TFormData, TFormValidator>) => {
+  update = (
+    options?: FormOptions<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync,
+      TOnServer
+    >,
+  ) => {
     if (!options) return
 
     const oldOptions = this.options
@@ -728,24 +1090,24 @@ export class FormApi<
   validateAllFields = async (cause: ValidationCause) => {
     const fieldValidationPromises: Promise<ValidationError[]>[] = [] as any
     batch(() => {
-      void (
-        Object.values(this.fieldInfo) as FieldInfo<any, TFormValidator>[]
-      ).forEach((field) => {
-        if (!field.instance) return
-        const fieldInstance = field.instance
-        // Validate the field
-        fieldValidationPromises.push(
-          // Remember, `validate` is either a sync operation or a promise
-          Promise.resolve().then(() =>
-            fieldInstance.validate(cause, { skipFormValidation: true }),
-          ),
-        )
-        // If any fields are not touched
-        if (!field.instance.state.meta.isTouched) {
-          // Mark them as touched
-          field.instance.setMeta((prev) => ({ ...prev, isTouched: true }))
-        }
-      })
+      void (Object.values(this.fieldInfo) as FieldInfo<any>[]).forEach(
+        (field) => {
+          if (!field.instance) return
+          const fieldInstance = field.instance
+          // Validate the field
+          fieldValidationPromises.push(
+            // Remember, `validate` is either a sync operation or a promise
+            Promise.resolve().then(() =>
+              fieldInstance.validate(cause, { skipFormValidation: true }),
+            ),
+          )
+          // If any fields are not touched
+          if (!field.instance.state.meta.isTouched) {
+            // Mark them as touched
+            field.instance.setMeta((prev) => ({ ...prev, isTouched: true }))
+          }
+        },
+      )
     })
 
     const fieldErrorMapMap = await Promise.all(fieldValidationPromises)
@@ -819,12 +1181,30 @@ export class FormApi<
     cause: ValidationCause,
   ): {
     hasErrored: boolean
-    fieldsErrorMap: FieldsErrorMapFromValidator<TFormData>
+    fieldsErrorMap: FormErrorMapFromValidator<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync
+    >
   } => {
     const validates = getSyncValidatorArray(cause, this.options)
     let hasErrored = false as boolean
 
-    const fieldsErrorMap: FieldsErrorMapFromValidator<TFormData> = {}
+    const fieldsErrorMap: FormErrorMapFromValidator<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync
+    > = {}
 
     batch(() => {
       for (const validateObj of validates) {
@@ -910,7 +1290,18 @@ export class FormApi<
    */
   validateAsync = async (
     cause: ValidationCause,
-  ): Promise<FieldsErrorMapFromValidator<TFormData>> => {
+  ): Promise<
+    FormErrorMapFromValidator<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync
+    >
+  > => {
     const validates = getAsyncValidatorArray(cause, this.options)
 
     if (!this.state.isFormValidating) {
@@ -928,6 +1319,7 @@ export class FormApi<
       | undefined
 
     for (const validateObj of validates) {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (!validateObj.validate) continue
       const key = getErrorMapKey(validateObj.cause)
       const fieldValidatorMeta = this.state.validationMetaMap[key]
@@ -1009,7 +1401,16 @@ export class FormApi<
 
     let results: ValidationPromiseResult<TFormData>[] = []
 
-    const fieldsErrorMap: FieldsErrorMapFromValidator<TFormData> = {}
+    const fieldsErrorMap: FormErrorMapFromValidator<
+      TFormData,
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync
+    > = {}
     if (promises.length) {
       results = await Promise.all(promises)
       for (const fieldValidationResult of results) {
@@ -1045,8 +1446,28 @@ export class FormApi<
   validate = (
     cause: ValidationCause,
   ):
-    | FieldsErrorMapFromValidator<TFormData>
-    | Promise<FieldsErrorMapFromValidator<TFormData>> => {
+    | FormErrorMapFromValidator<
+        TFormData,
+        TOnMount,
+        TOnChange,
+        TOnChangeAsync,
+        TOnBlur,
+        TOnBlurAsync,
+        TOnSubmit,
+        TOnSubmitAsync
+      >
+    | Promise<
+        FormErrorMapFromValidator<
+          TFormData,
+          TOnMount,
+          TOnChange,
+          TOnChangeAsync,
+          TOnBlur,
+          TOnBlurAsync,
+          TOnSubmit,
+          TOnSubmitAsync
+        >
+      > => {
     // Attempt to sync validate first
     const { hasErrored, fieldsErrorMap } = this.validateSync(cause)
 
@@ -1103,14 +1524,14 @@ export class FormApi<
     }
 
     batch(() => {
-      void (
-        Object.values(this.fieldInfo) as FieldInfo<TFormData, TFormValidator>[]
-      ).forEach((field) => {
-        field.instance?.options.listeners?.onSubmit?.({
-          value: field.instance.state.value,
-          fieldApi: field.instance,
-        })
-      })
+      void (Object.values(this.fieldInfo) as FieldInfo<TFormData>[]).forEach(
+        (field) => {
+          field.instance?.options.listeners?.onSubmit?.({
+            value: field.instance.state.value,
+            fieldApi: field.instance,
+          })
+        },
+      )
     })
 
     try {
@@ -1139,7 +1560,7 @@ export class FormApi<
    */
   getFieldMeta = <TField extends DeepKeys<TFormData>>(
     field: TField,
-  ): FieldMeta | undefined => {
+  ): AnyFieldMeta | undefined => {
     return this.state.fieldMeta[field]
   }
 
@@ -1148,7 +1569,7 @@ export class FormApi<
    */
   getFieldInfo = <TField extends DeepKeys<TFormData>>(
     field: TField,
-  ): FieldInfo<TFormData, TFormValidator> => {
+  ): FieldInfo<TFormData> => {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     return (this.fieldInfo[field] ||= {
       instance: null,
@@ -1167,7 +1588,7 @@ export class FormApi<
    */
   setFieldMeta = <TField extends DeepKeys<TFormData>>(
     field: TField,
-    updater: Updater<FieldMeta>,
+    updater: Updater<AnyFieldMeta>,
   ) => {
     this.baseStore.setState((prev) => {
       return {
@@ -1184,10 +1605,10 @@ export class FormApi<
   }
 
   resetFieldMeta = <TField extends DeepKeys<TFormData>>(
-    fieldMeta: Record<TField, FieldMeta>,
-  ): Record<TField, FieldMeta> => {
+    fieldMeta: Record<TField, AnyFieldMeta>,
+  ): Record<TField, AnyFieldMeta> => {
     return Object.keys(fieldMeta).reduce(
-      (acc: Record<TField, FieldMeta>, key) => {
+      (acc: Record<TField, AnyFieldMeta>, key) => {
         const fieldKey = key as TField
         acc[fieldKey] = {
           isValidating: false,
@@ -1200,7 +1621,7 @@ export class FormApi<
         }
         return acc
       },
-      {} as Record<TField, FieldMeta>,
+      {} as Record<TField, AnyFieldMeta>,
     )
   }
 
@@ -1422,14 +1843,27 @@ export class FormApi<
   /**
    * Updates the form's errorMap
    */
-  setErrorMap(errorMap: ValidationErrorMap) {
-    this.baseStore.setState((prev) => ({
-      ...prev,
-      errorMap: {
-        ...prev.errorMap,
-        ...errorMap,
-      },
-    }))
+  setErrorMap(
+    errorMap: ValidationErrorMap<
+      TOnMount,
+      TOnChange,
+      TOnChangeAsync,
+      TOnBlur,
+      TOnBlurAsync,
+      TOnSubmit,
+      TOnSubmitAsync
+    >,
+  ) {
+    this.baseStore.setState(
+      (prev) =>
+        ({
+          ...prev,
+          errorMap: {
+            ...prev.errorMap,
+            ...errorMap,
+          },
+        }) as never,
+    )
   }
 }
 
@@ -1438,16 +1872,12 @@ function normalizeError<TFormData>(rawError?: FormValidationError<unknown>): {
   fieldErrors?: Partial<Record<DeepKeys<TFormData>, ValidationError>>
 } {
   if (rawError) {
-    if (typeof rawError === 'object') {
+    if (isGlobalFormValidationError(rawError)) {
       const formError = normalizeError(rawError.form).formError
       const fieldErrors = rawError.fields
       return { formError, fieldErrors } as never
     }
 
-    if (typeof rawError !== 'string') {
-      return { formError: 'Invalid Form Values' }
-    }
-
     return { formError: rawError }
   }