@payloadcms/ui 3.0.0-canary.4de9e42 → 3.0.0-canary.4eb1bfc

package/dist/forms/Form/index.js

@@ -1,4 +1,5 @@
 'use client';
+
 import { jsx as _jsx } from "react/jsx-runtime";
 import { dequal } from 'dequal/lite'; // lite: no need for Map and Set support
 import { useRouter } from 'next/navigation.js';
@@ -22,545 +23,550 @@ import { fieldReducer } from './fieldReducer.js';
 import { initContextState } from './initContextState.js';
 import { mergeServerFormState } from './mergeServerFormState.js';
 const baseClass = 'form';
-export const Form = (props)=>{
-    const { id, collectionSlug, globalSlug } = useDocumentInfo();
-    const { action, beforeSubmit, children, className, disableSuccessStatus, disableValidationOnSubmit, disabled: disabledFromProps, // fields: fieldsFromProps = collection?.fields || global?.fields,
-    handleResponse, initialState, isInitializing: initializingFromProps, onChange, onSubmit, onSuccess, redirect, submitted: submittedFromProps, uuid, waitForAutocomplete } = props;
-    const method = 'method' in props ? props?.method : undefined;
-    const router = useRouter();
-    const { code: locale } = useLocale();
-    const { i18n, t } = useTranslation();
-    const { refreshCookie, user } = useAuth();
-    const operation = useOperation();
-    const config = useConfig();
-    const { routes: { api: apiRoute }, serverURL } = config;
-    const [disabled, setDisabled] = useState(disabledFromProps || false);
-    const [isMounted, setIsMounted] = useState(false);
-    const [modified, setModified] = useState(false);
-    const [initializing, setInitializing] = useState(initializingFromProps);
-    const [processing, setProcessing] = useState(false);
-    const [submitted, setSubmitted] = useState(false);
-    const formRef = useRef(null);
-    const contextRef = useRef({});
-    const fieldsReducer = useReducer(fieldReducer, {}, ()=>initialState);
-    /**
-   * `fields` is the current, up-to-date state/data of all fields in the form. It can be modified by using dispatchFields,
-   * which calls the fieldReducer, which then updates the state.
-   */ const [fields, dispatchFields] = fieldsReducer;
-    contextRef.current.fields = fields;
-    const validateForm = useCallback(async ()=>{
-        const validatedFieldState = {};
-        let isValid = true;
-        const dataFromContext = contextRef.current.getData();
-        const data = dataFromContext;
-        const validationPromises = Object.entries(contextRef.current.fields).map(async ([path, field])=>{
-            const validatedField = field;
-            if (field.passesCondition !== false) {
-                let validationResult = validatedField.valid;
-                if (typeof field.validate === 'function') {
-                    let valueToValidate = field.value;
-                    if (field?.rows && Array.isArray(field.rows)) {
-                        valueToValidate = contextRef.current.getDataByPath(path);
-                    }
-                    validationResult = await field.validate(valueToValidate, {
-                        id,
-                        config,
-                        data,
-                        operation,
-                        siblingData: contextRef.current.getSiblingData(path),
-                        t,
-                        user
-                    });
-                    if (typeof validationResult === 'string') {
-                        validatedField.errorMessage = validationResult;
-                        validatedField.valid = false;
-                    } else {
-                        validatedField.valid = true;
-                        validatedField.errorMessage = undefined;
-                    }
-                }
-                if (validatedField.valid === false) {
-                    isValid = false;
-                }
-            }
-            validatedFieldState[path] = validatedField;
-        });
-        await Promise.all(validationPromises);
-        if (!dequal(contextRef.current.fields, validatedFieldState)) {
-            dispatchFields({
-                type: 'REPLACE_STATE',
-                state: validatedFieldState
-            });
-        }
-        return isValid;
-    }, [
-        id,
-        user,
-        operation,
-        t,
-        dispatchFields,
-        config
-    ]);
-    const submit = useCallback(async (options = {}, e)=>{
-        const { action: actionArg = action, method: methodToUse = method, overrides = {}, skipValidation } = options;
-        if (disabled) {
-            if (e) {
-                e.preventDefault();
-            }
-            return;
-        }
-        // create new toast promise which will resolve manually later
-        let successToast, errorToast;
-        const promise = new Promise((resolve, reject)=>{
-            successToast = resolve;
-            errorToast = reject;
-        });
-        const hasFormSubmitAction = actionArg || typeof action === 'string' || typeof action === 'function';
-        if (redirect || disableSuccessStatus || !hasFormSubmitAction) {
-            // Do not show submitting toast, as the promise toast may never disappear under these conditions.
-            // Instead, make successToast() or errorToast() throw toast.success / toast.error
-            successToast = (data)=>toast.success(data);
-            errorToast = (data)=>toast.error(data);
-        } else {
-            toast.promise(promise, {
-                error: (data)=>{
-                    return data;
-                },
-                loading: t('general:submitting'),
-                success: (data)=>{
-                    return data;
-                }
-            });
+export const Form = props => {
+  const {
+    id,
+    collectionSlug,
+    globalSlug
+  } = useDocumentInfo();
+  const {
+    action,
+    beforeSubmit,
+    children,
+    className,
+    disabled: disabledFromProps,
+    disableSuccessStatus,
+    disableValidationOnSubmit,
+    // fields: fieldsFromProps = collection?.fields || global?.fields,
+    handleResponse,
+    initialState,
+    isInitializing: initializingFromProps,
+    onChange,
+    onSubmit,
+    onSuccess,
+    redirect,
+    submitted: submittedFromProps,
+    uuid,
+    waitForAutocomplete
+  } = props;
+  const method = 'method' in props ? props?.method : undefined;
+  const router = useRouter();
+  const {
+    code: locale
+  } = useLocale();
+  const {
+    i18n,
+    t
+  } = useTranslation();
+  const {
+    refreshCookie,
+    user
+  } = useAuth();
+  const operation = useOperation();
+  const {
+    config
+  } = useConfig();
+  const {
+    routes: {
+      api: apiRoute
+    },
+    serverURL
+  } = config;
+  const [disabled, setDisabled] = useState(disabledFromProps || false);
+  const [isMounted, setIsMounted] = useState(false);
+  const [modified, setModified] = useState(false);
+  const [initializing, setInitializing] = useState(initializingFromProps);
+  const [processing, setProcessing] = useState(false);
+  const [submitted, setSubmitted] = useState(false);
+  const formRef = useRef(null);
+  const contextRef = useRef({});
+  const fieldsReducer = useReducer(fieldReducer, {}, () => initialState);
+  /**
+  * `fields` is the current, up-to-date state/data of all fields in the form. It can be modified by using dispatchFields,
+  * which calls the fieldReducer, which then updates the state.
+  */
+  const [fields, dispatchFields] = fieldsReducer;
+  contextRef.current.fields = fields;
+  const validateForm = useCallback(async () => {
+    const validatedFieldState = {};
+    let isValid = true;
+    const dataFromContext = contextRef.current.getData();
+    const data = dataFromContext;
+    const validationPromises = Object.entries(contextRef.current.fields).map(async ([path, field]) => {
+      const validatedField = field;
+      if (field.passesCondition !== false) {
+        let validationResult = validatedField.valid;
+        if (typeof field.validate === 'function') {
+          let valueToValidate = field.value;
+          if (field?.rows && Array.isArray(field.rows)) {
+            valueToValidate = contextRef.current.getDataByPath(path);
+          }
+          validationResult = await field.validate(valueToValidate, {
+            ...field,
+            id,
+            collectionSlug,
+            data,
+            operation,
+            preferences: {},
+            req: {
+              payload: {
+                config
+              },
+              t,
+              user
+            },
+            siblingData: contextRef.current.getSiblingData(path)
+          });
+          if (typeof validationResult === 'string') {
+            validatedField.errorMessage = validationResult;
+            validatedField.valid = false;
+          } else {
+            validatedField.valid = true;
+            validatedField.errorMessage = undefined;
+          }
         }
-        if (e) {
-            e.stopPropagation();
-            e.preventDefault();
+        if (validatedField.valid === false) {
+          isValid = false;
         }
-        setProcessing(true);
-        setDisabled(true);
-        if (waitForAutocomplete) await wait(100);
-        // Execute server side validations
-        if (Array.isArray(beforeSubmit)) {
-            let revalidatedFormState;
-            await beforeSubmit.reduce(async (priorOnChange, beforeSubmitFn)=>{
-                await priorOnChange;
-                const result = await beforeSubmitFn({
-                    formState: fields
-                });
-                revalidatedFormState = result;
-            }, Promise.resolve());
-            const isValid = Object.entries(revalidatedFormState).every(([, field])=>field.valid);
-            if (!isValid) {
-                setProcessing(false);
-                setSubmitted(true);
-                setDisabled(false);
-                return dispatchFields({
-                    type: 'REPLACE_STATE',
-                    state: revalidatedFormState
-                });
-            }
+      }
+      validatedFieldState[path] = validatedField;
+    });
+    await Promise.all(validationPromises);
+    if (!dequal(contextRef.current.fields, validatedFieldState)) {
+      dispatchFields({
+        type: 'REPLACE_STATE',
+        state: validatedFieldState
+      });
+    }
+    return isValid;
+  }, [collectionSlug, config, dispatchFields, id, operation, t, user]);
+  const submit = useCallback(async (options = {}, e) => {
+    const {
+      action: actionArg = action,
+      method: methodToUse = method,
+      overrides = {},
+      skipValidation
+    } = options;
+    if (disabled) {
+      if (e) {
+        e.preventDefault();
+      }
+      return;
+    }
+    // create new toast promise which will resolve manually later
+    let errorToast, successToast;
+    const promise = new Promise((resolve, reject) => {
+      successToast = resolve;
+      errorToast = reject;
+    });
+    const hasFormSubmitAction = actionArg || typeof action === 'string' || typeof action === 'function';
+    if (redirect || disableSuccessStatus || !hasFormSubmitAction) {
+      // Do not show submitting toast, as the promise toast may never disappear under these conditions.
+      // Instead, make successToast() or errorToast() throw toast.success / toast.error
+      successToast = data_0 => toast.success(data_0);
+      errorToast = data_1 => toast.error(data_1);
+    } else {
+      toast.promise(promise, {
+        error: data_2 => {
+          return data_2;
+        },
+        loading: t('general:submitting'),
+        success: data_3 => {
+          return data_3;
         }
-        const isValid = skipValidation || disableValidationOnSubmit ? true : await contextRef.current.validateForm();
-        // If not valid, prevent submission
-        if (!isValid) {
-            errorToast(t('error:correctInvalidFields'));
-            setProcessing(false);
-            setSubmitted(true);
-            setDisabled(false);
-            return;
+      });
+    }
+    if (e) {
+      e.stopPropagation();
+      e.preventDefault();
+    }
+    setProcessing(true);
+    setDisabled(true);
+    if (waitForAutocomplete) {
+      await wait(100);
+    }
+    // Execute server side validations
+    if (Array.isArray(beforeSubmit)) {
+      let revalidatedFormState;
+      await beforeSubmit.reduce(async (priorOnChange, beforeSubmitFn) => {
+        await priorOnChange;
+        const result = await beforeSubmitFn({
+          formState: fields
+        });
+        revalidatedFormState = result;
+      }, Promise.resolve());
+      const isValid_0 = Object.entries(revalidatedFormState).every(([, field_0]) => field_0.valid);
+      if (!isValid_0) {
+        setProcessing(false);
+        setSubmitted(true);
+        setDisabled(false);
+        return dispatchFields({
+          type: 'REPLACE_STATE',
+          state: revalidatedFormState
+        });
+      }
+    }
+    const isValid_1 = skipValidation || disableValidationOnSubmit ? true : await contextRef.current.validateForm();
+    // If not valid, prevent submission
+    if (!isValid_1) {
+      errorToast(t('error:correctInvalidFields'));
+      setProcessing(false);
+      setSubmitted(true);
+      setDisabled(false);
+      return;
+    }
+    // If submit handler comes through via props, run that
+    if (onSubmit) {
+      const data_4 = {
+        ...reduceFieldsToValues(fields, true),
+        ...overrides
+      };
+      onSubmit(fields, data_4);
+    }
+    if (!hasFormSubmitAction) {
+      // No action provided, so we should return. An example where this happens are lexical link drawers. Upon submitting the drawer, we
+      // want to close it without submitting the form. Stuff like validation would be handled by lexical before this, through beforeSubmit
+      setProcessing(false);
+      setSubmitted(true);
+      setDisabled(false);
+      return;
+    }
+    const formData = contextRef.current.createFormData(overrides);
+    try {
+      let res;
+      if (typeof actionArg === 'string') {
+        res = await requests[methodToUse.toLowerCase()](actionArg, {
+          body: formData,
+          headers: {
+            'Accept-Language': i18n.language
+          }
+        });
+      } else if (typeof action === 'function') {
+        res = await action(formData);
+      }
+      setModified(false);
+      setDisabled(false);
+      if (typeof handleResponse === 'function') {
+        handleResponse(res, successToast, errorToast);
+        return;
+      }
+      const contentType = res.headers.get('content-type');
+      const isJSON = contentType && contentType.indexOf('application/json') !== -1;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let json = {};
+      if (isJSON) {
+        json = await res.json();
+      }
+      if (res.status < 400) {
+        if (typeof onSuccess === 'function') {
+          await onSuccess(json);
         }
-        // If submit handler comes through via props, run that
-        if (onSubmit) {
-            const data = {
-                ...reduceFieldsToValues(fields, true),
-                ...overrides
-            };
-            onSubmit(fields, data);
+        setSubmitted(false);
+        setProcessing(false);
+        if (redirect) {
+          router.push(redirect);
+        } else if (!disableSuccessStatus) {
+          successToast(json.message || t('general:submissionSuccessful'));
         }
-        if (!hasFormSubmitAction) {
-            // No action provided, so we should return. An example where this happens are lexical link drawers. Upon submitting the drawer, we
-            // want to close it without submitting the form. Stuff like validation would be handled by lexical before this, through beforeSubmit
-            setProcessing(false);
-            setSubmitted(true);
-            setDisabled(false);
-            return;
+      } else {
+        setProcessing(false);
+        setSubmitted(true);
+        contextRef.current = {
+          ...contextRef.current
+        } // triggers rerender of all components that subscribe to form
+        ;
+        if (json.message) {
+          errorToast(json.message);
+          return;
         }
-        const formData = contextRef.current.createFormData(overrides);
-        try {
-            let res;
-            if (typeof actionArg === 'string') {
-                res = await requests[methodToUse.toLowerCase()](actionArg, {
-                    body: formData,
-                    headers: {
-                        'Accept-Language': i18n.language
-                    }
-                });
-            } else if (typeof action === 'function') {
-                res = await action(formData);
+        if (Array.isArray(json.errors)) {
+          const [fieldErrors, nonFieldErrors] = json.errors.reduce(([fieldErrs, nonFieldErrs], err_0) => {
+            const newFieldErrs = [];
+            const newNonFieldErrs = [];
+            if (err_0?.message) {
+              newNonFieldErrs.push(err_0);
             }
-            setModified(false);
-            setDisabled(false);
-            if (typeof handleResponse === 'function') {
-                handleResponse(res, successToast, errorToast);
-                return;
-            }
-            const contentType = res.headers.get('content-type');
-            const isJSON = contentType && contentType.indexOf('application/json') !== -1;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let json = {};
-            if (isJSON) json = await res.json();
-            if (res.status < 400) {
-                if (typeof onSuccess === 'function') await onSuccess(json);
-                setSubmitted(false);
-                setProcessing(false);
-                if (redirect) {
-                    router.push(redirect);
-                } else if (!disableSuccessStatus) {
-                    successToast(json.message || t('general:submissionSuccessful'));
-                }
-            } else {
-                setProcessing(false);
-                setSubmitted(true);
-                contextRef.current = {
-                    ...contextRef.current
-                } // triggers rerender of all components that subscribe to form
-                ;
-                if (json.message) {
-                    errorToast(json.message);
-                    return;
+            if (Array.isArray(err_0?.data?.errors)) {
+              err_0.data?.errors.forEach(dataError => {
+                if (dataError?.field) {
+                  newFieldErrs.push(dataError);
+                } else {
+                  newNonFieldErrs.push(dataError);
                 }
-                if (Array.isArray(json.errors)) {
-                    const [fieldErrors, nonFieldErrors] = json.errors.reduce(([fieldErrs, nonFieldErrs], err)=>{
-                        const newFieldErrs = [];
-                        const newNonFieldErrs = [];
-                        if (err?.message) {
-                            newNonFieldErrs.push(err);
-                        }
-                        if (Array.isArray(err?.data?.errors)) {
-                            err.data?.errors.forEach((dataError)=>{
-                                if (dataError?.field) {
-                                    newFieldErrs.push(dataError);
-                                } else {
-                                    newNonFieldErrs.push(dataError);
-                                }
-                            });
-                        }
-                        return [
-                            [
-                                ...fieldErrs,
-                                ...newFieldErrs
-                            ],
-                            [
-                                ...nonFieldErrs,
-                                ...newNonFieldErrs
-                            ]
-                        ];
-                    }, [
-                        [],
-                        []
-                    ]);
-                    dispatchFields({
-                        type: 'ADD_SERVER_ERRORS',
-                        errors: fieldErrors
-                    });
-                    nonFieldErrors.forEach((err)=>{
-                        errorToast(err.message || t('error:unknown'));
-                    });
-                    return;
-                }
-                const message = errorMessages?.[res.status] || res?.statusText || t('error:unknown');
-                errorToast(message);
+              });
             }
-        } catch (err) {
-            console.error('Error submitting form', err);
-            setProcessing(false);
-            setSubmitted(true);
-            setDisabled(false);
-            errorToast(err.message);
-        }
-    }, [
-        beforeSubmit,
-        action,
-        disableSuccessStatus,
-        disableValidationOnSubmit,
-        disabled,
-        dispatchFields,
-        fields,
-        handleResponse,
-        method,
-        onSubmit,
-        onSuccess,
-        redirect,
-        router,
-        t,
-        i18n,
-        waitForAutocomplete
-    ]);
-    const getFields = useCallback(()=>contextRef.current.fields, []);
-    const getField = useCallback((path)=>contextRef.current.fields[path], []);
-    const getData = useCallback(()=>reduceFieldsToValues(contextRef.current.fields, true), []);
-    const getSiblingData = useCallback((path)=>getSiblingDataFunc(contextRef.current.fields, path), []);
-    const getDataByPath = useCallback((path)=>getDataByPathFunc(contextRef.current.fields, path), []);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const createFormData = useCallback((overrides = {})=>{
-        const data = reduceFieldsToValues(contextRef.current.fields, true);
-        const file = data?.file;
-        if (file) {
-            delete data.file;
+            return [[...fieldErrs, ...newFieldErrs], [...nonFieldErrs, ...newNonFieldErrs]];
+          }, [[], []]);
+          dispatchFields({
+            type: 'ADD_SERVER_ERRORS',
+            errors: fieldErrors
+          });
+          nonFieldErrors.forEach(err_1 => {
+            errorToast(err_1.message || t('error:unknown'));
+          });
+          return;
         }
-        const dataWithOverrides = {
-            ...data,
-            ...overrides
-        };
-        const dataToSerialize = {
-            _payload: JSON.stringify(dataWithOverrides),
-            file
-        };
-        // nullAsUndefineds is important to allow uploads and relationship fields to clear themselves
-        const formData = serialize(dataToSerialize, {
-            indices: true,
-            nullsAsUndefineds: false
-        });
-        return formData;
-    }, []);
-    const reset = useCallback(async (data)=>{
-        const newState = await getFormState({
-            apiRoute,
-            body: {
-                id,
-                collectionSlug,
-                data,
-                globalSlug,
-                operation,
-                schemaPath: collectionSlug || globalSlug
-            },
-            serverURL
-        });
-        contextRef.current = {
-            ...initContextState
-        };
-        setModified(false);
-        dispatchFields({
-            type: 'REPLACE_STATE',
-            state: newState
-        });
-    }, [
-        apiRoute,
+        const message = errorMessages?.[res.status] || res?.statusText || t('error:unknown');
+        errorToast(message);
+      }
+    } catch (err) {
+      console.error('Error submitting form', err);
+      setProcessing(false);
+      setSubmitted(true);
+      setDisabled(false);
+      errorToast(err.message);
+    }
+  }, [beforeSubmit, action, disableSuccessStatus, disableValidationOnSubmit, disabled, dispatchFields, fields, handleResponse, method, onSubmit, onSuccess, redirect, router, t, i18n, waitForAutocomplete]);
+  const getFields = useCallback(() => contextRef.current.fields, []);
+  const getField = useCallback(path_0 => contextRef.current.fields[path_0], []);
+  const getData = useCallback(() => reduceFieldsToValues(contextRef.current.fields, true), []);
+  const getSiblingData = useCallback(path_1 => getSiblingDataFunc(contextRef.current.fields, path_1), []);
+  const getDataByPath = useCallback(path_2 => getDataByPathFunc(contextRef.current.fields, path_2), []);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const createFormData = useCallback((overrides_0 = {}) => {
+    const data_5 = reduceFieldsToValues(contextRef.current.fields, true);
+    const file = data_5?.file;
+    if (file) {
+      delete data_5.file;
+    }
+    const dataWithOverrides = {
+      ...data_5,
+      ...overrides_0
+    };
+    const dataToSerialize = {
+      _payload: JSON.stringify(dataWithOverrides),
+      file
+    };
+    // nullAsUndefineds is important to allow uploads and relationship fields to clear themselves
+    const formData_0 = serialize(dataToSerialize, {
+      indices: true,
+      nullsAsUndefineds: false
+    });
+    return formData_0;
+  }, []);
+  const reset = useCallback(async data_6 => {
+    const {
+      state: newState
+    } = await getFormState({
+      apiRoute,
+      body: {
+        id,
         collectionSlug,
-        dispatchFields,
+        data: data_6,
         globalSlug,
-        id,
         operation,
-        serverURL
-    ]);
-    const replaceState = useCallback((state)=>{
-        contextRef.current = {
-            ...initContextState
-        };
-        setModified(false);
-        dispatchFields({
-            type: 'REPLACE_STATE',
-            state
-        });
-    }, [
-        dispatchFields
-    ]);
-    const getFieldStateBySchemaPath = useCallback(async ({ data, schemaPath })=>{
-        const fieldSchema = await getFormState({
-            apiRoute,
-            body: {
-                collectionSlug,
-                data,
-                globalSlug,
-                schemaPath
-            },
-            serverURL
-        });
-        return fieldSchema;
-    }, [
-        apiRoute,
+        schemaPath: collectionSlug || globalSlug
+      },
+      serverURL
+    });
+    contextRef.current = {
+      ...initContextState
+    };
+    setModified(false);
+    dispatchFields({
+      type: 'REPLACE_STATE',
+      state: newState
+    });
+  }, [apiRoute, collectionSlug, dispatchFields, globalSlug, id, operation, serverURL]);
+  const replaceState = useCallback(state => {
+    contextRef.current = {
+      ...initContextState
+    };
+    setModified(false);
+    dispatchFields({
+      type: 'REPLACE_STATE',
+      state
+    });
+  }, [dispatchFields]);
+  const getFieldStateBySchemaPath = useCallback(async ({
+    data: data_7,
+    schemaPath
+  }) => {
+    const {
+      state: fieldSchema
+    } = await getFormState({
+      apiRoute,
+      body: {
         collectionSlug,
+        data: data_7,
         globalSlug,
-        serverURL
-    ]);
-    const addFieldRow = useCallback(async ({ data, path, rowIndex, schemaPath })=>{
-        const subFieldState = await getFieldStateBySchemaPath({
-            data,
-            schemaPath
-        });
-        dispatchFields({
-            type: 'ADD_ROW',
-            blockType: data?.blockType,
-            path,
-            rowIndex,
-            subFieldState
-        });
-    }, [
-        getFieldStateBySchemaPath,
-        dispatchFields
-    ]);
-    const removeFieldRow = useCallback(({ path, rowIndex })=>{
-        dispatchFields({
-            type: 'REMOVE_ROW',
-            path,
-            rowIndex
-        });
-    }, [
-        dispatchFields
-    ]);
-    const replaceFieldRow = useCallback(async ({ data, path, rowIndex, schemaPath })=>{
-        const subFieldState = await getFieldStateBySchemaPath({
-            data,
-            schemaPath
-        });
-        dispatchFields({
-            type: 'REPLACE_ROW',
-            blockType: data?.blockType,
-            path,
-            rowIndex,
-            subFieldState
-        });
-    }, [
-        getFieldStateBySchemaPath,
-        dispatchFields
-    ]);
-    useEffect(()=>{
-        if (initializingFromProps !== undefined) {
-            setInitializing(initializingFromProps);
+        schemaPath
+      },
+      serverURL
+    });
+    return fieldSchema;
+  }, [apiRoute, collectionSlug, globalSlug, serverURL]);
+  const addFieldRow = useCallback(async ({
+    data: data_8,
+    path: path_3,
+    rowIndex,
+    schemaPath: schemaPath_0
+  }) => {
+    const subFieldState = await getFieldStateBySchemaPath({
+      data: data_8,
+      schemaPath: schemaPath_0
+    });
+    dispatchFields({
+      type: 'ADD_ROW',
+      blockType: data_8?.blockType,
+      path: path_3,
+      rowIndex,
+      subFieldState
+    });
+  }, [getFieldStateBySchemaPath, dispatchFields]);
+  const removeFieldRow = useCallback(({
+    path: path_4,
+    rowIndex: rowIndex_0
+  }) => {
+    dispatchFields({
+      type: 'REMOVE_ROW',
+      path: path_4,
+      rowIndex: rowIndex_0
+    });
+  }, [dispatchFields]);
+  const replaceFieldRow = useCallback(async ({
+    data: data_9,
+    path: path_5,
+    rowIndex: rowIndex_1,
+    schemaPath: schemaPath_1
+  }) => {
+    const subFieldState_0 = await getFieldStateBySchemaPath({
+      data: data_9,
+      schemaPath: schemaPath_1
+    });
+    dispatchFields({
+      type: 'REPLACE_ROW',
+      blockType: data_9?.blockType,
+      path: path_5,
+      rowIndex: rowIndex_1,
+      subFieldState: subFieldState_0
+    });
+  }, [getFieldStateBySchemaPath, dispatchFields]);
+  useEffect(() => {
+    if (initializingFromProps !== undefined) {
+      setInitializing(initializingFromProps);
+    }
+  }, [initializingFromProps]);
+  contextRef.current.submit = submit;
+  contextRef.current.getFields = getFields;
+  contextRef.current.getField = getField;
+  contextRef.current.getData = getData;
+  contextRef.current.getSiblingData = getSiblingData;
+  contextRef.current.getDataByPath = getDataByPath;
+  contextRef.current.validateForm = validateForm;
+  contextRef.current.createFormData = createFormData;
+  contextRef.current.setModified = setModified;
+  contextRef.current.setProcessing = setProcessing;
+  contextRef.current.setSubmitted = setSubmitted;
+  contextRef.current.disabled = disabled;
+  contextRef.current.setDisabled = setDisabled;
+  contextRef.current.formRef = formRef;
+  contextRef.current.reset = reset;
+  contextRef.current.replaceState = replaceState;
+  contextRef.current.dispatchFields = dispatchFields;
+  contextRef.current.addFieldRow = addFieldRow;
+  contextRef.current.removeFieldRow = removeFieldRow;
+  contextRef.current.replaceFieldRow = replaceFieldRow;
+  contextRef.current.uuid = uuid;
+  contextRef.current.initializing = initializing;
+  useEffect(() => {
+    setIsMounted(true);
+  }, []);
+  useEffect(() => {
+    if (typeof disabledFromProps === 'boolean') {
+      setDisabled(disabledFromProps);
+    }
+  }, [disabledFromProps]);
+  useEffect(() => {
+    if (typeof submittedFromProps === 'boolean') {
+      setSubmitted(submittedFromProps);
+    }
+  }, [submittedFromProps]);
+  useEffect(() => {
+    if (initialState) {
+      contextRef.current = {
+        ...initContextState
+      };
+      dispatchFields({
+        type: 'REPLACE_STATE',
+        optimize: false,
+        state: initialState
+      });
+    }
+  }, [initialState, dispatchFields]);
+  useThrottledEffect(() => {
+    refreshCookie();
+  }, 15000, [fields]);
+  useEffect(() => {
+    contextRef.current = {
+      ...contextRef.current
+    } // triggers rerender of all components that subscribe to form
+    ;
+    setModified(false);
+  }, [locale]);
+  const classes = [className, baseClass].filter(Boolean).join(' ');
+  useDebouncedEffect(() => {
+    const executeOnChange = async () => {
+      if (Array.isArray(onChange)) {
+        let revalidatedFormState_0 = contextRef.current.fields;
+        for (const onChangeFn of onChange) {
+          revalidatedFormState_0 = await onChangeFn({
+            formState: revalidatedFormState_0
+          });
         }
-    }, [
-        initializingFromProps
-    ]);
-    contextRef.current.submit = submit;
-    contextRef.current.getFields = getFields;
-    contextRef.current.getField = getField;
-    contextRef.current.getData = getData;
-    contextRef.current.getSiblingData = getSiblingData;
-    contextRef.current.getDataByPath = getDataByPath;
-    contextRef.current.validateForm = validateForm;
-    contextRef.current.createFormData = createFormData;
-    contextRef.current.setModified = setModified;
-    contextRef.current.setProcessing = setProcessing;
-    contextRef.current.setSubmitted = setSubmitted;
-    contextRef.current.disabled = disabled;
-    contextRef.current.setDisabled = setDisabled;
-    contextRef.current.formRef = formRef;
-    contextRef.current.reset = reset;
-    contextRef.current.replaceState = replaceState;
-    contextRef.current.dispatchFields = dispatchFields;
-    contextRef.current.addFieldRow = addFieldRow;
-    contextRef.current.removeFieldRow = removeFieldRow;
-    contextRef.current.replaceFieldRow = replaceFieldRow;
-    contextRef.current.uuid = uuid;
-    contextRef.current.initializing = initializing;
-    useEffect(()=>{
-        setIsMounted(true);
-    }, []);
-    useEffect(()=>{
-        if (typeof disabledFromProps === 'boolean') setDisabled(disabledFromProps);
-    }, [
-        disabledFromProps
-    ]);
-    useEffect(()=>{
-        if (typeof submittedFromProps === 'boolean') setSubmitted(submittedFromProps);
-    }, [
-        submittedFromProps
-    ]);
-    useEffect(()=>{
-        if (initialState) {
-            contextRef.current = {
-                ...initContextState
-            };
-            dispatchFields({
-                type: 'REPLACE_STATE',
-                optimize: false,
-                state: initialState
-            });
+        const {
+          changed,
+          newState: newState_0
+        } = mergeServerFormState(contextRef.current.fields || {}, revalidatedFormState_0);
+        if (changed) {
+          dispatchFields({
+            type: 'REPLACE_STATE',
+            optimize: false,
+            state: newState_0
+          });
         }
-    }, [
-        initialState,
-        dispatchFields
-    ]);
-    useThrottledEffect(()=>{
-        refreshCookie();
-    }, 15000, [
-        fields
-    ]);
-    useEffect(()=>{
-        contextRef.current = {
-            ...contextRef.current
-        } // triggers rerender of all components that subscribe to form
-        ;
-        setModified(false);
-    }, [
-        locale
-    ]);
-    const classes = [
-        className,
-        baseClass
-    ].filter(Boolean).join(' ');
-    useDebouncedEffect(()=>{
-        const executeOnChange = async ()=>{
-            if (Array.isArray(onChange)) {
-                let revalidatedFormState = contextRef.current.fields;
-                for (const onChangeFn of onChange){
-                    revalidatedFormState = await onChangeFn({
-                        formState: revalidatedFormState
-                    });
-                }
-                const { changed, newState } = mergeServerFormState(contextRef.current.fields || {}, revalidatedFormState);
-                if (changed) {
-                    dispatchFields({
-                        type: 'REPLACE_STATE',
-                        optimize: false,
-                        state: newState
-                    });
-                }
-            }
-        };
-        if (modified) void executeOnChange();
-    }, 150, // Make sure we trigger this whenever modified changes (not just when `fields` changes), otherwise we will miss merging server form state for the first form update/onChange. Here's why:
-    // `fields` updates before `modified`, because setModified is in a setTimeout. So on the first change, modified is false, so we don't trigger the effect even though we should.
-    [
-        contextRef.current.fields,
-        dispatchFields,
-        onChange,
-        modified
-    ]);
-    return /*#__PURE__*/ _jsx("form", {
-        action: action,
-        className: classes,
-        method: method,
-        noValidate: true,
-        onSubmit: (e)=>contextRef.current.submit({}, e),
-        ref: formRef,
-        children: /*#__PURE__*/ _jsx(FormContext.Provider, {
-            value: contextRef.current,
-            children: /*#__PURE__*/ _jsx(FormWatchContext.Provider, {
-                value: {
-                    fields,
-                    ...contextRef.current
-                },
-                children: /*#__PURE__*/ _jsx(SubmittedContext.Provider, {
-                    value: submitted,
-                    children: /*#__PURE__*/ _jsx(InitializingContext.Provider, {
-                        value: !isMounted || isMounted && initializing,
-                        children: /*#__PURE__*/ _jsx(ProcessingContext.Provider, {
-                            value: processing,
-                            children: /*#__PURE__*/ _jsx(ModifiedContext.Provider, {
-                                value: modified,
-                                children: /*#__PURE__*/ _jsx(FormFieldsContext.Provider, {
-                                    value: fieldsReducer,
-                                    children: children
-                                })
-                            })
-                        })
-                    })
+      }
+    };
+    if (modified) {
+      void executeOnChange();
+    }
+  }, 150,
+  // Make sure we trigger this whenever modified changes (not just when `fields` changes), otherwise we will miss merging server form state for the first form update/onChange. Here's why:
+  // `fields` updates before `modified`, because setModified is in a setTimeout. So on the first change, modified is false, so we don't trigger the effect even though we should.
+  [contextRef.current.fields, dispatchFields, onChange, modified]);
+  return /*#__PURE__*/_jsx("form", {
+    action: typeof action === 'function' ? void action : action,
+    className: classes,
+    method: method,
+    noValidate: true,
+    onSubmit: e_0 => void contextRef.current.submit({}, e_0),
+    ref: formRef,
+    children: /*#__PURE__*/_jsx(FormContext.Provider, {
+      value: contextRef.current,
+      children: /*#__PURE__*/_jsx(FormWatchContext.Provider, {
+        value: {
+          fields,
+          ...contextRef.current
+        },
+        children: /*#__PURE__*/_jsx(SubmittedContext.Provider, {
+          value: submitted,
+          children: /*#__PURE__*/_jsx(InitializingContext.Provider, {
+            value: !isMounted || isMounted && initializing,
+            children: /*#__PURE__*/_jsx(ProcessingContext.Provider, {
+              value: processing,
+              children: /*#__PURE__*/_jsx(ModifiedContext.Provider, {
+                value: modified,
+                children: /*#__PURE__*/_jsx(FormFieldsContext.Provider, {
+                  value: fieldsReducer,
+                  children: children
                 })
+              })
             })
+          })
         })
-    });
+      })
+    })
+  });
 };
 export { FormContext, FormFieldsContext, FormWatchContext, ModifiedContext, ProcessingContext, SubmittedContext, useAllFormFields, useForm, useFormFields, useFormModified, useFormProcessing, useFormSubmitted, useWatchForm } from './context.js';
-
 //# sourceMappingURL=index.js.map