@tanstack/form-core 0.42.0 → 0.43.0

package/src/formOptions.ts

@@ -1,9 +1,31 @@
-import type { Validator } from './types'
-import type { FormOptions } from './FormApi'
+import type {
+  FormAsyncValidateOrFn,
+  FormOptions,
+  FormValidateOrFn,
+} from './FormApi'
 
 export function formOptions<
   TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
->(defaultOpts?: FormOptions<TFormData, TFormValidator>) {
+  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>,
+>(
+  defaultOpts?: FormOptions<
+    TFormData,
+    TOnMount,
+    TOnChange,
+    TOnChangeAsync,
+    TOnBlur,
+    TOnBlurAsync,
+    TOnSubmit,
+    TOnSubmitAsync,
+    TOnServer
+  >,
+) {
   return defaultOpts
 }

package/src/mergeForm.ts

@@ -1,44 +1,81 @@
 import type { FormApi } from './FormApi'
-import type { Validator } from './types'
 import type { NoInfer } from './util-types'
 
+function isValidKey(key: string | number | symbol): boolean {
+  const dangerousProps = ['__proto__', 'constructor', 'prototype']
+  return !dangerousProps.includes(String(key))
+}
+
 /**
  * @private
  */
-export function mutateMergeDeep(target: object, source: object): object {
+export function mutateMergeDeep(
+  target: object | null | undefined,
+  source: object | null | undefined,
+): object {
+  // Early return if either is not an object
+  if (target === null || target === undefined || typeof target !== 'object')
+    return {} as object
+  if (source === null || source === undefined || typeof source !== 'object')
+    return target
+
   const targetKeys = Object.keys(target)
   const sourceKeys = Object.keys(source)
   const keySet = new Set([...targetKeys, ...sourceKeys])
+
   for (const key of keySet) {
-    const targetKey = key as never as keyof typeof target
-    const sourceKey = key as never as keyof typeof source
-
-    if (Array.isArray(target[targetKey]) && Array.isArray(source[sourceKey])) {
-      // always use the source array to prevent array fields from multiplying
-      target[targetKey] = source[sourceKey] as [] as never
-    } else if (
-      typeof target[targetKey] === 'object' &&
-      typeof source[sourceKey] === 'object'
-    ) {
-      mutateMergeDeep(target[targetKey] as {}, source[sourceKey] as {})
-    } else {
-      // Prevent assigning undefined to target, only if undefined is not explicitly set on source
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (!(sourceKey in source) && source[sourceKey] === undefined) {
-        continue
-      }
-      target[targetKey] = source[sourceKey] as never
+    if (!isValidKey(key)) continue
+
+    const targetKey = key as keyof typeof target
+    const sourceKey = key as keyof typeof source
+
+    if (!Object.hasOwn(source, sourceKey)) continue
+
+    const sourceValue = source[sourceKey] as unknown
+    const targetValue = target[targetKey] as unknown
+
+    // Handle arrays
+    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+      Object.defineProperty(target, key, {
+        value: [...sourceValue],
+        enumerable: true,
+        writable: true,
+        configurable: true,
+      })
+      continue
+    }
+
+    // Handle nested objects (type assertion to satisfy ESLint)
+    const isTargetObj = typeof targetValue === 'object' && targetValue !== null
+    const isSourceObj = typeof sourceValue === 'object' && sourceValue !== null
+    const areObjects =
+      isTargetObj &&
+      isSourceObj &&
+      !Array.isArray(targetValue) &&
+      !Array.isArray(sourceValue)
+
+    if (areObjects) {
+      mutateMergeDeep(targetValue as object, sourceValue as object)
+      continue
     }
+
+    // Handle all other cases
+    Object.defineProperty(target, key, {
+      value: sourceValue,
+      enumerable: true,
+      writable: true,
+      configurable: true,
+    })
   }
+
   return target
 }
 
-export function mergeForm<
-  TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
->(
-  baseForm: FormApi<NoInfer<TFormData>, NoInfer<TFormValidator>>,
-  state: Partial<FormApi<TFormData, TFormValidator>['state']>,
+export function mergeForm<TFormData>(
+  baseForm: FormApi<NoInfer<TFormData>, any, any, any, any, any, any, any, any>,
+  state: Partial<
+    FormApi<TFormData, any, any, any, any, any, any, any, any>['state']
+  >,
 ) {
   mutateMergeDeep(baseForm.state, state)
   return baseForm

package/src/metaHelper.ts

@@ -1,14 +1,36 @@
-import type { FieldMeta } from './FieldApi'
-import type { FormApi } from './FormApi'
-import type { Validator } from './types'
+import type {
+  FormApi,
+  FormAsyncValidateOrFn,
+  FormValidateOrFn,
+} from './FormApi'
+import type { AnyFieldMeta } from './FieldApi'
 import type { DeepKeys } from './util-types'
 
 type ArrayFieldMode = 'insert' | 'remove' | 'swap' | 'move'
 
 export function metaHelper<
   TFormData,
-  TFormValidator extends Validator<TFormData, unknown> | undefined = undefined,
->(formApi: FormApi<TFormData, TFormValidator>) {
+  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>,
+>(
+  formApi: FormApi<
+    TFormData,
+    TOnMount,
+    TOnChange,
+    TOnChangeAsync,
+    TOnBlur,
+    TOnBlurAsync,
+    TOnSubmit,
+    TOnSubmitAsync,
+    TOnServer
+  >,
+) {
   function handleArrayFieldMetaShift(
     field: DeepKeys<TFormData>,
     index: number,
@@ -90,7 +112,7 @@ export function metaHelper<
     })
   }
 
-  const getEmptyFieldMeta = (): FieldMeta => ({
+  const getEmptyFieldMeta = (): AnyFieldMeta => ({
     isValidating: false,
     isTouched: false,
     isBlurred: false,

package/src/standardSchemaValidator.ts

@@ -1,16 +1,11 @@
-import type {
-  ValidationError,
-  Validator,
-  ValidatorAdapterParams,
-} from './types'
+import type { ValidationSource } from './types'
 
-type Params = ValidatorAdapterParams<StandardSchemaV1Issue>
-type TransformFn = NonNullable<Params['transformErrors']>
+export type TStandardSchemaValidatorValue<TData> = {
+  value: TData
+  validationSource: ValidationSource
+}
 
-function prefixSchemaToErrors(
-  issues: readonly StandardSchemaV1Issue[],
-  transformErrors: TransformFn,
-) {
+function prefixSchemaToErrors(issues: readonly StandardSchemaV1Issue[]) {
   const schema = new Map<string, StandardSchemaV1Issue[]>()
 
   for (const issue of issues) {
@@ -28,60 +23,54 @@ function prefixSchemaToErrors(
     schema.set(path, (schema.get(path) ?? []).concat(issue))
   }
 
-  const transformedSchema = {} as Record<string, ValidationError>
-
-  schema.forEach((value, key) => {
-    transformedSchema[key] = transformErrors(value)
-  })
-
-  return transformedSchema
+  return Object.fromEntries(schema)
 }
 
-function defaultFormTransformer(transformErrors: TransformFn) {
-  return (issues: readonly StandardSchemaV1Issue[]) => ({
-    form: transformErrors(issues as StandardSchemaV1Issue[]),
-    fields: prefixSchemaToErrors(issues, transformErrors),
-  })
-}
-
-export const standardSchemaValidator =
-  (params: Params = {}): Validator<unknown, StandardSchemaV1<any>> =>
-  () => {
-    const transformFieldErrors =
-      params.transformErrors ??
-      ((issues: StandardSchemaV1Issue[]) =>
-        issues.map((issue) => issue.message).join(', '))
-
-    const getTransformStrategy = (validationSource: 'form' | 'field') =>
-      validationSource === 'form'
-        ? defaultFormTransformer(transformFieldErrors)
-        : transformFieldErrors
-
-    return {
-      validate({ value, validationSource }, fn) {
-        const result = fn['~standard'].validate(value)
+const defaultFieldTransformer = (issues: readonly StandardSchemaV1Issue[]) =>
+  issues
 
-        if (result instanceof Promise) {
-          throw new Error('async function passed to sync validator')
-        }
-
-        if (!result.issues) return
+const defaultFormTransformer = (issues: readonly StandardSchemaV1Issue[]) => {
+  const schemaErrors = prefixSchemaToErrors(issues)
+  return {
+    form: schemaErrors,
+    fields: schemaErrors,
+  }
+}
 
-        const transformer = getTransformStrategy(validationSource)
+const transformIssues = (
+  validationSource: 'form' | 'field',
+  issues: readonly StandardSchemaV1Issue[],
+) =>
+  validationSource === 'form'
+    ? defaultFormTransformer(issues)
+    : defaultFieldTransformer(issues)
+
+export const standardSchemaValidators = {
+  validate(
+    { value, validationSource }: TStandardSchemaValidatorValue<unknown>,
+    schema: StandardSchemaV1,
+  ) {
+    const result = schema['~standard'].validate(value)
+
+    if (result instanceof Promise) {
+      throw new Error('async function passed to sync validator')
+    }
 
-        return transformer(result.issues as StandardSchemaV1Issue[])
-      },
-      async validateAsync({ value, validationSource }, fn) {
-        const result = await fn['~standard'].validate(value)
+    if (!result.issues) return
 
-        if (!result.issues) return
+    return transformIssues(validationSource, result.issues)
+  },
+  async validateAsync(
+    { value, validationSource }: TStandardSchemaValidatorValue<unknown>,
+    schema: StandardSchemaV1,
+  ) {
+    const result = await schema['~standard'].validate(value)
 
-        const transformer = getTransformStrategy(validationSource)
+    if (!result.issues) return
 
-        return transformer(result.issues as StandardSchemaV1Issue[])
-      },
-    }
-  }
+    return transformIssues(validationSource, result.issues)
+  },
+}
 
 export const isStandardSchemaValidator = (
   validator: unknown,
@@ -152,7 +141,7 @@ interface StandardSchemaV1FailureResult {
 /**
  * The issue interface of the failure output.
  */
-interface StandardSchemaV1Issue {
+export interface StandardSchemaV1Issue {
   /**
    * The error message of the issue.
    */

package/src/types.ts

@@ -1,32 +1,9 @@
 import type { DeepKeys } from './util-types'
 
-export type ValidationError = undefined | false | null | string
+export type ValidationError = unknown
 
 export type ValidationSource = 'form' | 'field'
 
-/**
- * If/when TypeScript supports higher-kinded types, this should not be `unknown` anymore
- * @private
- */
-export type Validator<Type, Fn = unknown> = () => {
-  validate(
-    options: { value: Type; validationSource: ValidationSource },
-    fn: Fn,
-  ): ValidationError | FormValidationError<unknown>
-  validateAsync(
-    options: { value: Type; validationSource: ValidationSource },
-    fn: Fn,
-  ): Promise<ValidationError | FormValidationError<unknown>>
-}
-
-/**
- * Parameters in common for all validator adapters, making it easier to swap adapter
- * @private
- */
-export type ValidatorAdapterParams<TError = unknown> = {
-  transformErrors?: (errors: TError[]) => ValidationError
-}
-
 /**
  * "server" is only intended for SSR/SSG validation and should not execute anything
  * @private
@@ -41,17 +18,47 @@ export type ValidationErrorMapKeys = `on${Capitalize<ValidationCause>}`
 /**
  * @private
  */
-export type ValidationErrorMap = {
-  [K in ValidationErrorMapKeys]?: ValidationError
+export type ValidationErrorMap<
+  TOnMountReturn = unknown,
+  TOnChangeReturn = unknown,
+  TOnChangeAsyncReturn = unknown,
+  TOnBlurReturn = unknown,
+  TOnBlurAsyncReturn = unknown,
+  TOnSubmitReturn = unknown,
+  TOnSubmitAsyncReturn = unknown,
+  TOnServerReturn = unknown,
+> = {
+  onMount?: TOnMountReturn
+  onChange?: TOnChangeReturn | TOnChangeAsyncReturn
+  onBlur?: TOnBlurReturn | TOnBlurAsyncReturn
+  onSubmit?: TOnSubmitReturn | TOnSubmitAsyncReturn
+  onServer?: TOnServerReturn
 }
 
 /**
  * @private
  */
-export type FormValidationErrorMap = {
-  [K in ValidationErrorMapKeys]?: ValidationError | FormValidationError<unknown>
+export type FormValidationErrorMap<
+  TOnMountReturn = unknown,
+  TOnChangeReturn = unknown,
+  TOnChangeAsyncReturn = unknown,
+  TOnBlurReturn = unknown,
+  TOnBlurAsyncReturn = unknown,
+  TOnSubmitReturn = unknown,
+  TOnSubmitAsyncReturn = unknown,
+  TOnServerReturn = unknown,
+> = {
+  onMount?: TOnMountReturn
+  onChange?: TOnChangeReturn | TOnChangeAsyncReturn
+  onBlur?: TOnBlurReturn | TOnBlurAsyncReturn
+  onSubmit?: TOnSubmitReturn | TOnSubmitAsyncReturn
+  onServer?: TOnServerReturn
 }
 
+export type FormValidationError<TFormData> =
+  | ValidationError
+  | GlobalFormValidationError<TFormData>
+
 /**
  * @private
  *
@@ -65,12 +72,10 @@ export type FormValidationErrorMap = {
  * }
  * ````
  */
-export type FormValidationError<TFormData> =
-  | ValidationError
-  | {
-      form?: ValidationError
-      fields: Partial<Record<DeepKeys<TFormData>, ValidationError>>
-    }
+export type GlobalFormValidationError<TFormData> = {
+  form?: ValidationError
+  fields: Partial<Record<DeepKeys<TFormData>, ValidationError>>
+}
 
 /**
  * @private

package/src/util-types.ts

@@ -1,6 +1,8 @@
 type Nullable<T> = T | null
 type IsNullable<T> = [null] extends [T] ? true : false
 
+export type UnwrapOneLevelOfArray<T> = T extends (infer U)[] ? U : T
+
 /**
  * @private
  */

package/src/utils.ts

@@ -1,4 +1,4 @@
-import type { ValidationCause } from './types'
+import type { GlobalFormValidationError, ValidationCause } from './types'
 import type { FormValidators } from './FormApi'
 import type { FieldValidators } from './FieldApi'
 
@@ -195,11 +195,11 @@ export interface AsyncValidator<T> {
 export function getAsyncValidatorArray<T>(
   cause: ValidationCause,
   options: AsyncValidatorArrayPartialOptions<T>,
-): T extends FieldValidators<any, any>
+): T extends FieldValidators<any, any, any, any, any, any, any, any, any, any>
   ? Array<
       AsyncValidator<T['onChangeAsync'] | T['onBlurAsync'] | T['onSubmitAsync']>
     >
-  : T extends FormValidators<any, any>
+  : T extends FormValidators<any, any, any, any, any, any, any, any>
     ? Array<
         AsyncValidator<
           T['onChangeAsync'] | T['onBlurAsync'] | T['onSubmitAsync']
@@ -214,8 +214,8 @@ export function getAsyncValidatorArray<T>(
     onBlurAsyncDebounceMs,
     onChangeAsyncDebounceMs,
   } = (options.validators || {}) as
-    | FieldValidators<any, any>
-    | FormValidators<any, any>
+    | FieldValidators<any, any, any, any, any, any, any, any, any, any>
+    | FormValidators<any, any, any, any, any, any, any, any>
 
   const defaultDebounceMs = asyncDebounceMs ?? 0
 
@@ -279,11 +279,11 @@ export interface SyncValidator<T> {
 export function getSyncValidatorArray<T>(
   cause: ValidationCause,
   options: SyncValidatorArrayPartialOptions<T>,
-): T extends FieldValidators<any, any>
+): T extends FieldValidators<any, any, any, any, any, any, any, any, any, any>
   ? Array<
       SyncValidator<T['onChange'] | T['onBlur'] | T['onSubmit'] | T['onMount']>
     >
-  : T extends FormValidators<any, any>
+  : T extends FormValidators<any, any, any, any, any, any, any, any>
     ? Array<
         SyncValidator<
           T['onChange'] | T['onBlur'] | T['onSubmit'] | T['onMount']
@@ -291,8 +291,8 @@ export function getSyncValidatorArray<T>(
       >
     : never {
   const { onChange, onBlur, onSubmit, onMount } = (options.validators || {}) as
-    | FieldValidators<any, any>
-    | FormValidators<any, any>
+    | FieldValidators<any, any, any, any, any, any, any, any, any, any>
+    | FormValidators<any, any, any, any, any, any, any, any>
 
   const changeValidator = { cause: 'change', validate: onChange } as const
   const blurValidator = { cause: 'blur', validate: onBlur } as const
@@ -325,6 +325,12 @@ export function getSyncValidatorArray<T>(
   }
 }
 
+export const isGlobalFormValidationError = (
+  error: unknown,
+): error is GlobalFormValidationError<unknown> => {
+  return !!error && typeof error === 'object' && 'fields' in error
+}
+
 export function shallow<T>(objA: T, objB: T) {
   if (Object.is(objA, objB)) {
     return true