@tanstack/form-core 1.26.0 → 1.27.1

package/dist/cjs/FormApi.cjs

@@ -405,6 +405,121 @@ class FormApi {
       }
       return this.validateAsync(cause);
     };
+    this._handleSubmit = async (submitMeta) => {
+      this.baseStore.setState((old) => ({
+        ...old,
+        // Submission attempts mark the form as not submitted
+        isSubmitted: false,
+        // Count submission attempts
+        submissionAttempts: old.submissionAttempts + 1,
+        isSubmitSuccessful: false
+        // Reset isSubmitSuccessful at the start of submission
+      }));
+      store.batch(() => {
+        void Object.values(this.fieldInfo).forEach(
+          (field) => {
+            if (!field.instance) return;
+            if (!field.instance.state.meta.isTouched) {
+              field.instance.setMeta((prev) => ({ ...prev, isTouched: true }));
+            }
+          }
+        );
+      });
+      const submitMetaArg = submitMeta ?? this.options.onSubmitMeta;
+      if (!this.state.canSubmit && !this._devtoolsSubmissionOverride) {
+        this.options.onSubmitInvalid?.({
+          value: this.state.values,
+          formApi: this,
+          meta: submitMetaArg
+        });
+        return;
+      }
+      this.baseStore.setState((d) => ({ ...d, isSubmitting: true }));
+      const done = () => {
+        this.baseStore.setState((prev) => ({ ...prev, isSubmitting: false }));
+      };
+      await this.validateAllFields("submit");
+      if (!this.state.isFieldsValid) {
+        done();
+        this.options.onSubmitInvalid?.({
+          value: this.state.values,
+          formApi: this,
+          meta: submitMetaArg
+        });
+        EventClient.formEventClient.emit("form-submission", {
+          id: this._formId,
+          submissionAttempt: this.state.submissionAttempts,
+          successful: false,
+          stage: "validateAllFields",
+          errors: Object.values(this.state.fieldMeta).map((meta) => meta.errors).flat()
+        });
+        return;
+      }
+      await this.validate("submit");
+      if (!this.state.isValid) {
+        done();
+        this.options.onSubmitInvalid?.({
+          value: this.state.values,
+          formApi: this,
+          meta: submitMetaArg
+        });
+        EventClient.formEventClient.emit("form-submission", {
+          id: this._formId,
+          submissionAttempt: this.state.submissionAttempts,
+          successful: false,
+          stage: "validate",
+          errors: this.state.errors
+        });
+        return;
+      }
+      store.batch(() => {
+        void Object.values(this.fieldInfo).forEach(
+          (field) => {
+            field.instance?.options.listeners?.onSubmit?.({
+              value: field.instance.state.value,
+              fieldApi: field.instance
+            });
+          }
+        );
+      });
+      this.options.listeners?.onSubmit?.({ formApi: this, meta: submitMetaArg });
+      try {
+        await this.options.onSubmit?.({
+          value: this.state.values,
+          formApi: this,
+          meta: submitMetaArg
+        });
+        store.batch(() => {
+          this.baseStore.setState((prev) => ({
+            ...prev,
+            isSubmitted: true,
+            isSubmitSuccessful: true
+            // Set isSubmitSuccessful to true on successful submission
+          }));
+          EventClient.formEventClient.emit("form-submission", {
+            id: this._formId,
+            submissionAttempt: this.state.submissionAttempts,
+            successful: true
+          });
+          done();
+        });
+      } catch (err) {
+        this.baseStore.setState((prev) => ({
+          ...prev,
+          isSubmitSuccessful: false
+          // Ensure isSubmitSuccessful is false if an error occurs
+        }));
+        EventClient.formEventClient.emit("form-submission", {
+          id: this._formId,
+          submissionAttempt: this.state.submissionAttempts,
+          successful: false,
+          stage: "inflight",
+          onError: err
+        });
+        done();
+        throw err;
+      }
+    };
     this.getFieldValue = (field) => utils.getBy(this.state.values, field);
     this.getFieldMeta = (field) => {
       return this.state.fieldMeta[field];
@@ -627,6 +742,48 @@ class FormApi {
         };
       });
     };
+    this.setErrorMap = (errorMap) => {
+      store.batch(() => {
+        Object.entries(errorMap).forEach(([key, value]) => {
+          const errorMapKey = key;
+          if (utils.isGlobalFormValidationError(value)) {
+            const { formError, fieldErrors } = normalizeError(value);
+            for (const fieldName of Object.keys(
+              this.fieldInfo
+            )) {
+              const fieldMeta = this.getFieldMeta(fieldName);
+              if (!fieldMeta) continue;
+              this.setFieldMeta(fieldName, (prev) => ({
+                ...prev,
+                errorMap: {
+                  ...prev.errorMap,
+                  [errorMapKey]: fieldErrors?.[fieldName]
+                },
+                errorSourceMap: {
+                  ...prev.errorSourceMap,
+                  [errorMapKey]: "form"
+                }
+              }));
+            }
+            this.baseStore.setState((prev) => ({
+              ...prev,
+              errorMap: {
+                ...prev.errorMap,
+                [errorMapKey]: formError
+              }
+            }));
+          } else {
+            this.baseStore.setState((prev) => ({
+              ...prev,
+              errorMap: {
+                ...prev.errorMap,
+                [errorMapKey]: value
+              }
+            }));
+          }
+        });
+      });
+    };
     this.getAllErrors = () => {
       return {
         form: {
@@ -865,165 +1022,8 @@ class FormApi {
     }
     return props.validate(props.value);
   }
-  async handleSubmit(submitMeta) {
-    this.baseStore.setState((old) => ({
-      ...old,
-      // Submission attempts mark the form as not submitted
-      isSubmitted: false,
-      // Count submission attempts
-      submissionAttempts: old.submissionAttempts + 1,
-      isSubmitSuccessful: false
-      // Reset isSubmitSuccessful at the start of submission
-    }));
-    store.batch(() => {
-      void Object.values(this.fieldInfo).forEach(
-        (field) => {
-          if (!field.instance) return;
-          if (!field.instance.state.meta.isTouched) {
-            field.instance.setMeta((prev) => ({ ...prev, isTouched: true }));
-          }
-        }
-      );
-    });
-    const submitMetaArg = submitMeta ?? this.options.onSubmitMeta;
-    if (!this.state.canSubmit && !this._devtoolsSubmissionOverride) {
-      this.options.onSubmitInvalid?.({
-        value: this.state.values,
-        formApi: this,
-        meta: submitMetaArg
-      });
-      return;
-    }
-    this.baseStore.setState((d) => ({ ...d, isSubmitting: true }));
-    const done = () => {
-      this.baseStore.setState((prev) => ({ ...prev, isSubmitting: false }));
-    };
-    await this.validateAllFields("submit");
-    if (!this.state.isFieldsValid) {
-      done();
-      this.options.onSubmitInvalid?.({
-        value: this.state.values,
-        formApi: this,
-        meta: submitMetaArg
-      });
-      EventClient.formEventClient.emit("form-submission", {
-        id: this._formId,
-        submissionAttempt: this.state.submissionAttempts,
-        successful: false,
-        stage: "validateAllFields",
-        errors: Object.values(this.state.fieldMeta).map((meta) => meta.errors).flat()
-      });
-      return;
-    }
-    await this.validate("submit");
-    if (!this.state.isValid) {
-      done();
-      this.options.onSubmitInvalid?.({
-        value: this.state.values,
-        formApi: this,
-        meta: submitMetaArg
-      });
-      EventClient.formEventClient.emit("form-submission", {
-        id: this._formId,
-        submissionAttempt: this.state.submissionAttempts,
-        successful: false,
-        stage: "validate",
-        errors: this.state.errors
-      });
-      return;
-    }
-    store.batch(() => {
-      void Object.values(this.fieldInfo).forEach(
-        (field) => {
-          field.instance?.options.listeners?.onSubmit?.({
-            value: field.instance.state.value,
-            fieldApi: field.instance
-          });
-        }
-      );
-    });
-    this.options.listeners?.onSubmit?.({ formApi: this, meta: submitMetaArg });
-    try {
-      await this.options.onSubmit?.({
-        value: this.state.values,
-        formApi: this,
-        meta: submitMetaArg
-      });
-      store.batch(() => {
-        this.baseStore.setState((prev) => ({
-          ...prev,
-          isSubmitted: true,
-          isSubmitSuccessful: true
-          // Set isSubmitSuccessful to true on successful submission
-        }));
-        EventClient.formEventClient.emit("form-submission", {
-          id: this._formId,
-          submissionAttempt: this.state.submissionAttempts,
-          successful: true
-        });
-        done();
-      });
-    } catch (err) {
-      this.baseStore.setState((prev) => ({
-        ...prev,
-        isSubmitSuccessful: false
-        // Ensure isSubmitSuccessful is false if an error occurs
-      }));
-      EventClient.formEventClient.emit("form-submission", {
-        id: this._formId,
-        submissionAttempt: this.state.submissionAttempts,
-        successful: false,
-        stage: "inflight",
-        onError: err
-      });
-      done();
-      throw err;
-    }
-  }
-  /**
-   * Updates the form's errorMap
-   */
-  setErrorMap(errorMap) {
-    store.batch(() => {
-      Object.entries(errorMap).forEach(([key, value]) => {
-        const errorMapKey = key;
-        if (utils.isGlobalFormValidationError(value)) {
-          const { formError, fieldErrors } = normalizeError(value);
-          for (const fieldName of Object.keys(
-            this.fieldInfo
-          )) {
-            const fieldMeta = this.getFieldMeta(fieldName);
-            if (!fieldMeta) continue;
-            this.setFieldMeta(fieldName, (prev) => ({
-              ...prev,
-              errorMap: {
-                ...prev.errorMap,
-                [errorMapKey]: fieldErrors?.[fieldName]
-              },
-              errorSourceMap: {
-                ...prev.errorSourceMap,
-                [errorMapKey]: "form"
-              }
-            }));
-          }
-          this.baseStore.setState((prev) => ({
-            ...prev,
-            errorMap: {
-              ...prev.errorMap,
-              [errorMapKey]: formError
-            }
-          }));
-        } else {
-          this.baseStore.setState((prev) => ({
-            ...prev,
-            errorMap: {
-              ...prev.errorMap,
-              [errorMapKey]: value
-            }
-          }));
-        }
-      });
-    });
+  handleSubmit(submitMeta) {
+    return this._handleSubmit(submitMeta);
   }
 }
 function normalizeError(rawError) {