@tanstack/form-core 0.40.1 → 0.40.3

package/src/FormApi.ts

@@ -12,6 +12,7 @@ import {
   isStandardSchemaValidator,
   standardSchemaValidator,
 } from './standardSchemaValidator'
+import type { StandardSchemaV1 } from './standardSchemaValidator'
 import type { FieldApi, FieldMeta } from './FieldApi'
 import type {
   FormValidationError,
@@ -26,7 +27,6 @@ import type {
 } from './types'
 import type { DeepKeys, DeepValue } from './util-types'
 import type { Updater } from './utils'
-import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 export type FieldsErrorMapFromValidator<TFormData> = Partial<
   Record<DeepKeys<TFormData>, ValidationErrorMap>
@@ -532,21 +532,8 @@ export class FormApi<
   mount = () => {
     const { onMount } = this.options.validators || {}
     if (!onMount) return
-    const error = this.runValidator({
-      validate: onMount,
-      value: {
-        value: this.state.values,
-        formApi: this,
-        validationSource: 'form',
-      },
-      type: 'validate',
-    })
-    if (error) {
-      this.store.setState((prev) => ({
-        ...prev,
-        errorMap: { ...prev.errorMap, onMount: error },
-      }))
-    }
+
+    this.validateSync('mount')
   }
 
   /**

package/src/standardSchemaValidator.ts

@@ -3,16 +3,15 @@ import type {
   Validator,
   ValidatorAdapterParams,
 } from './types'
-import type { StandardSchemaV1 } from '@standard-schema/spec'
 
-type Params = ValidatorAdapterParams<StandardSchemaV1.Issue>
+type Params = ValidatorAdapterParams<StandardSchemaV1Issue>
 type TransformFn = NonNullable<Params['transformErrors']>
 
 function prefixSchemaToErrors(
-  issues: readonly StandardSchemaV1.Issue[],
+  issues: readonly StandardSchemaV1Issue[],
   transformErrors: TransformFn,
 ) {
-  const schema = new Map<string, StandardSchemaV1.Issue[]>()
+  const schema = new Map<string, StandardSchemaV1Issue[]>()
 
   for (const issue of issues) {
     const path = [...(issue.path ?? [])]
@@ -39,18 +38,18 @@ function prefixSchemaToErrors(
 }
 
 function defaultFormTransformer(transformErrors: TransformFn) {
-  return (issues: readonly StandardSchemaV1.Issue[]) => ({
-    form: transformErrors(issues as StandardSchemaV1.Issue[]),
+  return (issues: readonly StandardSchemaV1Issue[]) => ({
+    form: transformErrors(issues as StandardSchemaV1Issue[]),
     fields: prefixSchemaToErrors(issues, transformErrors),
   })
 }
 
 export const standardSchemaValidator =
-  (params: Params = {}): Validator<unknown, StandardSchemaV1> =>
+  (params: Params = {}): Validator<unknown, StandardSchemaV1<any>> =>
   () => {
     const transformFieldErrors =
       params.transformErrors ??
-      ((issues: StandardSchemaV1.Issue[]) =>
+      ((issues: StandardSchemaV1Issue[]) =>
         issues.map((issue) => issue.message).join(', '))
 
     const getTransformStrategy = (validationSource: 'form' | 'field') =>
@@ -70,7 +69,7 @@ export const standardSchemaValidator =
 
         const transformer = getTransformStrategy(validationSource)
 
-        return transformer(result.issues as StandardSchemaV1.Issue[])
+        return transformer(result.issues as StandardSchemaV1Issue[])
       },
       async validateAsync({ value, validationSource }, fn) {
         const result = await fn['~standard'].validate(value)
@@ -79,7 +78,7 @@ export const standardSchemaValidator =
 
         const transformer = getTransformStrategy(validationSource)
 
-        return transformer(result.issues as StandardSchemaV1.Issue[])
+        return transformer(result.issues as StandardSchemaV1Issue[])
       },
     }
   }
@@ -88,3 +87,102 @@ export const isStandardSchemaValidator = (
   validator: unknown,
 ): validator is StandardSchemaV1 =>
   !!validator && '~standard' in (validator as object)
+
+/**
+ * The Standard Schema interface.
+ */
+export type StandardSchemaV1<Input = unknown, Output = Input> = {
+  /**
+   * The Standard Schema properties.
+   */
+  readonly '~standard': StandardSchemaV1Props<Input, Output>
+}
+
+/**
+ * The Standard Schema properties interface.
+ */
+interface StandardSchemaV1Props<Input = unknown, Output = Input> {
+  /**
+   * The version number of the standard.
+   */
+  readonly version: 1
+  /**
+   * The vendor name of the schema library.
+   */
+  readonly vendor: string
+  /**
+   * Validates unknown input values.
+   */
+  readonly validate: (
+    value: unknown,
+  ) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>
+  /**
+   * Inferred types associated with the schema.
+   */
+  readonly types?: StandardSchemaV1Types<Input, Output> | undefined
+}
+/**
+ * The result interface of the validate function.
+ */
+type StandardSchemaV1Result<Output> =
+  | StandardSchemaV1SuccessResult<Output>
+  | StandardSchemaV1FailureResult
+/**
+ * The result interface if validation succeeds.
+ */
+interface StandardSchemaV1SuccessResult<Output> {
+  /**
+   * The typed output value.
+   */
+  readonly value: Output
+  /**
+   * The non-existent issues.
+   */
+  readonly issues?: undefined
+}
+/**
+ * The result interface if validation fails.
+ */
+interface StandardSchemaV1FailureResult {
+  /**
+   * The issues of failed validation.
+   */
+  readonly issues: ReadonlyArray<StandardSchemaV1Issue>
+}
+/**
+ * The issue interface of the failure output.
+ */
+interface StandardSchemaV1Issue {
+  /**
+   * The error message of the issue.
+   */
+  readonly message: string
+  /**
+   * The path of the issue, if any.
+   */
+  readonly path?:
+    | ReadonlyArray<PropertyKey | StandardSchemaV1PathSegment>
+    | undefined
+}
+/**
+ * The path segment interface of the issue.
+ */
+interface StandardSchemaV1PathSegment {
+  /**
+   * The key representing a path segment.
+   */
+  readonly key: PropertyKey
+}
+/**
+ * The Standard Schema types interface.
+ */
+interface StandardSchemaV1Types<Input = unknown, Output = Input> {
+  /**
+   * The input type of the schema.
+   */
+  readonly input: Input
+  /**
+   * The output type of the schema.
+   */
+  readonly output: Output
+}

package/src/utils.ts

@@ -280,17 +280,24 @@ export function getSyncValidatorArray<T>(
   cause: ValidationCause,
   options: SyncValidatorArrayPartialOptions<T>,
 ): T extends FieldValidators<any, any>
-  ? Array<SyncValidator<T['onChange'] | T['onBlur'] | T['onSubmit']>>
+  ? Array<
+      SyncValidator<T['onChange'] | T['onBlur'] | T['onSubmit'] | T['onMount']>
+    >
   : T extends FormValidators<any, any>
-    ? Array<SyncValidator<T['onChange'] | T['onBlur'] | T['onSubmit']>>
+    ? Array<
+        SyncValidator<
+          T['onChange'] | T['onBlur'] | T['onSubmit'] | T['onMount']
+        >
+      >
     : never {
-  const { onChange, onBlur, onSubmit } = (options.validators || {}) as
+  const { onChange, onBlur, onSubmit, onMount } = (options.validators || {}) as
     | FieldValidators<any, any>
     | FormValidators<any, any>
 
   const changeValidator = { cause: 'change', validate: onChange } as const
   const blurValidator = { cause: 'blur', validate: onBlur } as const
   const submitValidator = { cause: 'submit', validate: onSubmit } as const
+  const mountValidator = { cause: 'mount', validate: onMount } as const
 
   // Allows us to clear onServer errors
   const serverValidator = {
@@ -299,6 +306,8 @@ export function getSyncValidatorArray<T>(
   } as const
 
   switch (cause) {
+    case 'mount':
+      return [mountValidator] as never
     case 'submit':
       return [
         changeValidator,