@payloadcms/ui 3.0.0-alpha.0 → 3.0.0-alpha.10

package/dist/forms/Form/index.js

@@ -0,0 +1,565 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _deepequal = /*#__PURE__*/ _interop_require_default(require("deep-equal"));
+const _navigation = require("next/navigation");
+const _objecttoformdata = require("object-to-formdata");
+const _utilities = require("payload/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacttoastify = require("react-toastify");
+const _useDebouncedEffect = require("../../hooks/useDebouncedEffect");
+const _useThrottledEffect = /*#__PURE__*/ _interop_require_default(require("../../hooks/useThrottledEffect"));
+const _Auth = require("../../providers/Auth");
+const _Config = require("../../providers/Config");
+const _DocumentInfo = require("../../providers/DocumentInfo");
+const _Locale = require("../../providers/Locale");
+const _OperationProvider = require("../../providers/OperationProvider");
+const _Translation = require("../../providers/Translation");
+const _api = require("../../utilities/api");
+const _getFormState = require("../../utilities/getFormState");
+const _context = require("./context");
+const _errorMessages = /*#__PURE__*/ _interop_require_default(require("./errorMessages"));
+const _fieldReducer = require("./fieldReducer");
+const _getDataByPath = /*#__PURE__*/ _interop_require_default(require("./getDataByPath"));
+const _getSiblingData = /*#__PURE__*/ _interop_require_default(require("./getSiblingData"));
+const _initContextState = /*#__PURE__*/ _interop_require_default(require("./initContextState"));
+const _mergeServerFormState = require("./mergeServerFormState");
+const _reduceFieldsToValues = /*#__PURE__*/ _interop_require_default(require("./reduceFieldsToValues"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'form';
+const Form = (props)=>{
+    const { id, getDocPreferences } = (0, _DocumentInfo.useDocumentInfo)();
+    const { action, children, className, disableSuccessStatus, disabled, // fields: fieldsFromProps = collection?.fields || global?.fields,
+    beforeSubmit, handleResponse, initialState, onChange, onSubmit, onSuccess, redirect, submitted: submittedFromProps, uuid, waitForAutocomplete } = props;
+    const method = 'method' in props ? props.method : undefined;
+    const router = (0, _navigation.useRouter)();
+    const { code: locale } = (0, _Locale.useLocale)();
+    const { i18n, t } = (0, _Translation.useTranslation)();
+    const { refreshCookie, user } = (0, _Auth.useAuth)();
+    const operation = (0, _OperationProvider.useOperation)();
+    const config = (0, _Config.useConfig)();
+    const { routes: { api: apiRoute }, serverURL } = config;
+    const [modified, setModified] = (0, _react.useState)(false);
+    const [processing, setProcessing] = (0, _react.useState)(false);
+    const [submitted, setSubmitted] = (0, _react.useState)(false);
+    const formRef = (0, _react.useRef)(null);
+    const contextRef = (0, _react.useRef)({});
+    const { collectionSlug, globalSlug } = (0, _DocumentInfo.useDocumentInfo)();
+    const fieldsReducer = (0, _react.useReducer)(_fieldReducer.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 = (0, _react.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,
+                valid: true
+            };
+            if (field.passesCondition !== false) {
+                let validationResult = true;
+                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;
+                    isValid = false;
+                }
+            }
+            validatedFieldState[path] = validatedField;
+        });
+        await Promise.all(validationPromises);
+        if (!(0, _deepequal.default)(contextRef.current.fields, validatedFieldState)) {
+            dispatchFields({
+                type: 'REPLACE_STATE',
+                state: validatedFieldState
+            });
+        }
+        return isValid;
+    }, [
+        id,
+        user,
+        operation,
+        t,
+        dispatchFields,
+        config
+    ]);
+    const submit = (0, _react.useCallback)(async (options = {}, e)=>{
+        const { action: actionToUse = action, method: methodToUse = method, overrides = {}, skipValidation } = options;
+        if (disabled) {
+            if (e) {
+                e.preventDefault();
+            }
+            return;
+        }
+        if (e) {
+            e.stopPropagation();
+            e.preventDefault();
+        }
+        setProcessing(true);
+        setSubmitted(true);
+        if (waitForAutocomplete) await (0, _utilities.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);
+                return dispatchFields({
+                    type: 'REPLACE_STATE',
+                    state: revalidatedFormState
+                });
+            }
+        }
+        const isValid = skipValidation ? true : await contextRef.current.validateForm();
+        // If not valid, prevent submission
+        if (!isValid) {
+            _reacttoastify.toast.error(t('error:correctInvalidFields'));
+            setProcessing(false);
+            return;
+        }
+        // If submit handler comes through via props, run that
+        if (onSubmit) {
+            const data = {
+                ...(0, _reduceFieldsToValues.default)(fields, true),
+                ...overrides
+            };
+            onSubmit(fields, data);
+        }
+        const formData = contextRef.current.createFormData(overrides);
+        try {
+            let res;
+            if (typeof actionToUse === 'string') {
+                res = await _api.requests[methodToUse.toLowerCase()](actionToUse, {
+                    body: formData,
+                    headers: {
+                        'Accept-Language': i18n.language
+                    }
+                });
+            } else if (typeof actionToUse === 'function') {
+                res = await actionToUse(formData);
+            }
+            setModified(false);
+            if (typeof handleResponse === 'function') {
+                handleResponse(res);
+                return;
+            }
+            setProcessing(false);
+            const contentType = res.headers.get('content-type');
+            const isJSON = contentType && contentType.indexOf('application/json') !== -1;
+            let json = {};
+            if (isJSON) json = await res.json();
+            if (res.status < 400) {
+                setSubmitted(false);
+                if (typeof onSuccess === 'function') onSuccess(json);
+                if (redirect) {
+                    // const destination = {
+                    //   pathname: redirect,
+                    //   state: {},
+                    // }
+                    // if (typeof json === 'object' && json.message && !disableSuccessStatus) {
+                    //   destination.state = {
+                    //     status: [
+                    //       {
+                    //         message: json.message,
+                    //         type: 'success',
+                    //       },
+                    //     ],
+                    //   }
+                    // }
+                    router.push(redirect);
+                } else if (!disableSuccessStatus) {
+                    _reacttoastify.toast.success(json.message || t('general:submissionSuccessful'), {
+                        autoClose: 3000
+                    });
+                }
+            } else {
+                contextRef.current = {
+                    ...contextRef.current
+                } // triggers rerender of all components that subscribe to form
+                ;
+                if (json.message) {
+                    _reacttoastify.toast.error(json.message);
+                    return;
+                }
+                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)) {
+                            err.data.forEach((dataError)=>{
+                                if (dataError?.field) {
+                                    newFieldErrs.push(dataError);
+                                } else {
+                                    newNonFieldErrs.push(dataError);
+                                }
+                            });
+                        }
+                        return [
+                            [
+                                ...fieldErrs,
+                                ...newFieldErrs
+                            ],
+                            [
+                                ...nonFieldErrs,
+                                ...newNonFieldErrs
+                            ]
+                        ];
+                    }, [
+                        [],
+                        []
+                    ]);
+                    fieldErrors.forEach((err)=>{
+                        dispatchFields({
+                            type: 'UPDATE',
+                            ...contextRef.current?.fields?.[err.field] || {},
+                            errorMessage: err.message,
+                            path: err.field,
+                            valid: false
+                        });
+                    });
+                    nonFieldErrors.forEach((err)=>{
+                        _reacttoastify.toast.error(err.message || t('error:unknown'));
+                    });
+                    return;
+                }
+                const message = _errorMessages.default?.[res.status] || res?.statusText || t('error:unknown');
+                _reacttoastify.toast.error(message);
+            }
+        } catch (err) {
+            setProcessing(false);
+            _reacttoastify.toast.error(err);
+        }
+    }, [
+        action,
+        disableSuccessStatus,
+        disabled,
+        dispatchFields,
+        fields,
+        handleResponse,
+        method,
+        onSubmit,
+        onSuccess,
+        redirect,
+        router,
+        t,
+        i18n,
+        waitForAutocomplete,
+        beforeSubmit
+    ]);
+    const getFields = (0, _react.useCallback)(()=>contextRef.current.fields, []);
+    const getField = (0, _react.useCallback)((path)=>contextRef.current.fields[path], []);
+    const getData = (0, _react.useCallback)(()=>(0, _reduceFieldsToValues.default)(contextRef.current.fields, true), []);
+    const getSiblingData = (0, _react.useCallback)((path)=>(0, _getSiblingData.default)(contextRef.current.fields, path), []);
+    const getDataByPath = (0, _react.useCallback)((path)=>(0, _getDataByPath.default)(contextRef.current.fields, path), []);
+    const createFormData = (0, _react.useCallback)((overrides = {})=>{
+        const data = (0, _reduceFieldsToValues.default)(contextRef.current.fields, true);
+        const file = data?.file;
+        if (file) {
+            delete data.file;
+        }
+        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 = (0, _objecttoformdata.serialize)(dataToSerialize, {
+            indices: true,
+            nullsAsUndefineds: false
+        });
+        return formData;
+    }, []);
+    const reset = (0, _react.useCallback)(async (fieldSchema, data)=>{
+        const preferences = await getDocPreferences();
+        // const state = await buildStateFromSchema({
+        //   id,
+        //   // TODO: fix this
+        //   // @ts-ignore-next-line
+        //   config,
+        //   data,
+        //   fieldSchema,
+        //   locale,
+        //   operation,
+        //   preferences,
+        //   t,
+        //   user,
+        // })
+        contextRef.current = {
+            ..._initContextState.default
+        };
+        setModified(false);
+    // dispatchFields({ state, type: 'REPLACE_STATE' })
+    }, [
+        getDocPreferences
+    ]);
+    const replaceState = (0, _react.useCallback)((state)=>{
+        contextRef.current = {
+            ..._initContextState.default
+        };
+        setModified(false);
+        dispatchFields({
+            type: 'REPLACE_STATE',
+            state
+        });
+    }, [
+        dispatchFields
+    ]);
+    const getFieldStateByPath = (0, _react.useCallback)(async ({ data, path })=>{
+        const fieldSchema = await (0, _getFormState.getFormState)({
+            apiRoute,
+            body: {
+                collectionSlug,
+                data,
+                globalSlug,
+                /**
+            Turns: 'arrayField.0.group123field.arrayField.0.textField'
+            Into: 'arrayField.group123field.arrayField.textField'
+          */ schemaPath: `${collectionSlug || globalSlug}.${path}`.replace(/\.\d+\./g, '.')
+            },
+            serverURL
+        });
+        return fieldSchema;
+    }, [
+        apiRoute,
+        collectionSlug,
+        globalSlug,
+        serverURL
+    ]);
+    const addFieldRow = (0, _react.useCallback)(async ({ data, path, rowIndex })=>{
+        const subFieldState = await getFieldStateByPath({
+            data,
+            path
+        });
+        dispatchFields({
+            type: 'ADD_ROW',
+            blockType: data?.blockType,
+            path,
+            rowIndex,
+            subFieldState
+        });
+    }, [
+        getFieldStateByPath,
+        dispatchFields
+    ]);
+    const removeFieldRow = (0, _react.useCallback)(({ path, rowIndex })=>{
+        dispatchFields({
+            type: 'REMOVE_ROW',
+            path,
+            rowIndex
+        });
+    }, [
+        dispatchFields
+    ]);
+    const replaceFieldRow = (0, _react.useCallback)(async ({ data, path, rowIndex })=>{
+        const subFieldState = await getFieldStateByPath({
+            data,
+            path
+        });
+        dispatchFields({
+            type: 'REPLACE_ROW',
+            blockType: data?.blockType,
+            path,
+            rowIndex,
+            subFieldState
+        });
+    }, [
+        getFieldStateByPath,
+        dispatchFields
+    ]);
+    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.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;
+    (0, _react.useEffect)(()=>{
+        if (typeof submittedFromProps === 'boolean') setSubmitted(submittedFromProps);
+    }, [
+        submittedFromProps
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (initialState) {
+            contextRef.current = {
+                ..._initContextState.default
+            };
+            dispatchFields({
+                type: 'REPLACE_STATE',
+                state: initialState
+            });
+        }
+    }, [
+        initialState,
+        dispatchFields
+    ]);
+    (0, _useThrottledEffect.default)(()=>{
+        refreshCookie();
+    }, 15000, [
+        fields
+    ]);
+    (0, _react.useEffect)(()=>{
+        contextRef.current = {
+            ...contextRef.current
+        } // triggers rerender of all components that subscribe to form
+        ;
+        setModified(false);
+    }, [
+        locale
+    ]);
+    const classes = [
+        className,
+        baseClass
+    ].filter(Boolean).join(' ');
+    (0, _useDebouncedEffect.useDebouncedEffect)(()=>{
+        const executeOnChange = async ()=>{
+            if (Array.isArray(onChange)) {
+                let revalidatedFormState;
+                await onChange.reduce(async (priorOnChange, onChangeFn)=>{
+                    await priorOnChange;
+                    const result = await onChangeFn({
+                        formState: fields
+                    });
+                    revalidatedFormState = result;
+                }, Promise.resolve());
+                const { changed, newState } = (0, _mergeServerFormState.mergeServerFormState)(fields, revalidatedFormState);
+                if (changed) {
+                    dispatchFields({
+                        type: 'REPLACE_STATE',
+                        optimize: false,
+                        state: newState
+                    });
+                }
+            }
+        };
+        executeOnChange() // eslint-disable-line @typescript-eslint/no-floating-promises
+        ;
+    }, 150, [
+        fields,
+        dispatchFields,
+        onChange
+    ]);
+    return /*#__PURE__*/ _react.default.createElement("form", {
+        action: action,
+        className: classes,
+        method: method,
+        noValidate: true,
+        onSubmit: (e)=>contextRef.current.submit({}, e),
+        ref: formRef
+    }, /*#__PURE__*/ _react.default.createElement(_context.FormContext.Provider, {
+        value: contextRef.current
+    }, /*#__PURE__*/ _react.default.createElement(_context.FormWatchContext.Provider, {
+        value: {
+            fields,
+            ...contextRef.current
+        }
+    }, /*#__PURE__*/ _react.default.createElement(_context.SubmittedContext.Provider, {
+        value: submitted
+    }, /*#__PURE__*/ _react.default.createElement(_context.ProcessingContext.Provider, {
+        value: processing
+    }, /*#__PURE__*/ _react.default.createElement(_context.ModifiedContext.Provider, {
+        value: modified
+    }, /*#__PURE__*/ _react.default.createElement(_context.FormFieldsContext.Provider, {
+        value: fieldsReducer
+    }, children)))))));
+};
+const _default = Form;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/forms/Form/index.tsx"],"sourcesContent":["'use client'\nimport type { Field } from 'payload/types'\n\n/* eslint-disable jsx-a11y/no-noninteractive-element-interactions */\nimport isDeepEqual from 'deep-equal'\nimport { useRouter } from 'next/navigation'\nimport { serialize } from 'object-to-formdata'\nimport { wait } from 'payload/utilities'\nimport React, { useCallback, useEffect, useReducer, useRef, useState } from 'react'\nimport { toast } from 'react-toastify'\n\nimport type {\n  Context as FormContextType,\n  FormState,\n  GetDataByPath,\n  Props,\n  SubmitOptions,\n} from './types'\n\nimport { useDebouncedEffect } from '../../hooks/useDebouncedEffect'\nimport useThrottledEffect from '../../hooks/useThrottledEffect'\nimport { useAuth } from '../../providers/Auth'\nimport { useConfig } from '../../providers/Config'\nimport { useDocumentInfo } from '../../providers/DocumentInfo'\nimport { useLocale } from '../../providers/Locale'\nimport { useOperation } from '../../providers/OperationProvider'\nimport { useTranslation } from '../../providers/Translation'\nimport { requests } from '../../utilities/api'\nimport { getFormState } from '../../utilities/getFormState'\nimport {\n  FormContext,\n  FormFieldsContext,\n  FormWatchContext,\n  ModifiedContext,\n  ProcessingContext,\n  SubmittedContext,\n} from './context'\nimport errorMessages from './errorMessages'\nimport { fieldReducer } from './fieldReducer'\nimport getDataByPathFunc from './getDataByPath'\nimport getSiblingDataFunc from './getSiblingData'\nimport initContextState from './initContextState'\nimport { mergeServerFormState } from './mergeServerFormState'\nimport reduceFieldsToValues from './reduceFieldsToValues'\n\nconst baseClass = 'form'\n\nconst Form: React.FC<Props> = (props) => {\n  const { id, getDocPreferences } = useDocumentInfo()\n\n  const {\n    action,\n    children,\n    className,\n    disableSuccessStatus,\n    disabled,\n    // fields: fieldsFromProps = collection?.fields || global?.fields,\n    beforeSubmit,\n    handleResponse,\n    initialState, // fully formed initial field state\n    onChange,\n    onSubmit,\n    onSuccess,\n    redirect,\n    submitted: submittedFromProps,\n    uuid,\n    waitForAutocomplete,\n  } = props\n\n  const method = 'method' in props ? props.method : undefined\n\n  const router = useRouter()\n\n  const { code: locale } = useLocale()\n  const { i18n, t } = useTranslation()\n  const { refreshCookie, user } = useAuth()\n  const operation = useOperation()\n\n  const config = useConfig()\n  const {\n    routes: { api: apiRoute },\n    serverURL,\n  } = config\n\n  const [modified, setModified] = useState(false)\n  const [processing, setProcessing] = useState(false)\n  const [submitted, setSubmitted] = useState(false)\n  const formRef = useRef<HTMLFormElement>(null)\n  const contextRef = useRef({} as FormContextType)\n  const { collectionSlug, globalSlug } = useDocumentInfo()\n\n  const fieldsReducer = useReducer(fieldReducer, {}, () => initialState)\n  /**\n   * `fields` is the current, up-to-date state/data of all fields in the form. It can be modified by using dispatchFields,\n   * which calls the fieldReducer, which then updates the state.\n   */\n  const [fields, dispatchFields] = fieldsReducer\n\n  contextRef.current.fields = fields\n\n  const validateForm = useCallback(async () => {\n    const validatedFieldState = {}\n    let isValid = true\n\n    const dataFromContext = contextRef.current.getData()\n    const data = dataFromContext\n\n    const validationPromises = Object.entries(contextRef.current.fields).map(\n      async ([path, field]) => {\n        const validatedField = {\n          ...field,\n          valid: true,\n        }\n\n        if (field.passesCondition !== false) {\n          let validationResult: boolean | string = true\n\n          if (typeof field.validate === 'function') {\n            let valueToValidate = field.value\n\n            if (field?.rows && Array.isArray(field.rows)) {\n              valueToValidate = contextRef.current.getDataByPath(path)\n            }\n\n            validationResult = await field.validate(valueToValidate, {\n              id,\n              config,\n              data,\n              operation,\n              siblingData: contextRef.current.getSiblingData(path),\n              t,\n              user,\n            })\n          }\n\n          if (typeof validationResult === 'string') {\n            validatedField.errorMessage = validationResult\n            validatedField.valid = false\n            isValid = false\n          }\n        }\n\n        validatedFieldState[path] = validatedField\n      },\n    )\n\n    await Promise.all(validationPromises)\n\n    if (!isDeepEqual(contextRef.current.fields, validatedFieldState)) {\n      dispatchFields({ type: 'REPLACE_STATE', state: validatedFieldState })\n    }\n\n    return isValid\n  }, [id, user, operation, t, dispatchFields, config])\n\n  const submit = useCallback(\n    async (options: SubmitOptions = {}, e): Promise<void> => {\n      const {\n        action: actionToUse = action,\n        method: methodToUse = method,\n        overrides = {},\n        skipValidation,\n      } = options\n\n      if (disabled) {\n        if (e) {\n          e.preventDefault()\n        }\n        return\n      }\n\n      if (e) {\n        e.stopPropagation()\n        e.preventDefault()\n      }\n\n      setProcessing(true)\n      setSubmitted(true)\n\n      if (waitForAutocomplete) await wait(100)\n\n      // Execute server side validations\n      if (Array.isArray(beforeSubmit)) {\n        let revalidatedFormState: FormState\n\n        await beforeSubmit.reduce(async (priorOnChange, beforeSubmitFn) => {\n          await priorOnChange\n\n          const result = await beforeSubmitFn({\n            formState: fields,\n          })\n\n          revalidatedFormState = result\n        }, Promise.resolve())\n\n        const isValid = Object.entries(revalidatedFormState).every(([, field]) => field.valid)\n\n        if (!isValid) {\n          setProcessing(false)\n          return dispatchFields({ type: 'REPLACE_STATE', state: revalidatedFormState })\n        }\n      }\n\n      const isValid = skipValidation ? true : await contextRef.current.validateForm()\n\n      // If not valid, prevent submission\n      if (!isValid) {\n        toast.error(t('error:correctInvalidFields'))\n        setProcessing(false)\n\n        return\n      }\n\n      // If submit handler comes through via props, run that\n      if (onSubmit) {\n        const data = {\n          ...reduceFieldsToValues(fields, true),\n          ...overrides,\n        }\n\n        onSubmit(fields, data)\n      }\n\n      const formData = contextRef.current.createFormData(overrides)\n\n      try {\n        let res\n\n        if (typeof actionToUse === 'string') {\n          res = await requests[methodToUse.toLowerCase()](actionToUse, {\n            body: formData,\n            headers: {\n              'Accept-Language': i18n.language,\n            },\n          })\n        } else if (typeof actionToUse === 'function') {\n          res = await actionToUse(formData)\n        }\n\n        setModified(false)\n\n        if (typeof handleResponse === 'function') {\n          handleResponse(res)\n          return\n        }\n\n        setProcessing(false)\n\n        const contentType = res.headers.get('content-type')\n        const isJSON = contentType && contentType.indexOf('application/json') !== -1\n\n        let json: any = {}\n\n        if (isJSON) json = await res.json()\n\n        if (res.status < 400) {\n          setSubmitted(false)\n\n          if (typeof onSuccess === 'function') onSuccess(json)\n\n          if (redirect) {\n            // const destination = {\n            //   pathname: redirect,\n            //   state: {},\n            // }\n\n            // if (typeof json === 'object' && json.message && !disableSuccessStatus) {\n            //   destination.state = {\n            //     status: [\n            //       {\n            //         message: json.message,\n            //         type: 'success',\n            //       },\n            //     ],\n            //   }\n            // }\n\n            router.push(redirect)\n          } else if (!disableSuccessStatus) {\n            toast.success(json.message || t('general:submissionSuccessful'), { autoClose: 3000 })\n          }\n        } else {\n          contextRef.current = { ...contextRef.current } // triggers rerender of all components that subscribe to form\n          if (json.message) {\n            toast.error(json.message)\n\n            return\n          }\n\n          if (Array.isArray(json.errors)) {\n            const [fieldErrors, nonFieldErrors] = json.errors.reduce(\n              ([fieldErrs, nonFieldErrs], err) => {\n                const newFieldErrs = []\n                const newNonFieldErrs = []\n\n                if (err?.message) {\n                  newNonFieldErrs.push(err)\n                }\n\n                if (Array.isArray(err?.data)) {\n                  err.data.forEach((dataError) => {\n                    if (dataError?.field) {\n                      newFieldErrs.push(dataError)\n                    } else {\n                      newNonFieldErrs.push(dataError)\n                    }\n                  })\n                }\n\n                return [\n                  [...fieldErrs, ...newFieldErrs],\n                  [...nonFieldErrs, ...newNonFieldErrs],\n                ]\n              },\n              [[], []],\n            )\n\n            fieldErrors.forEach((err) => {\n              dispatchFields({\n                type: 'UPDATE',\n                ...(contextRef.current?.fields?.[err.field] || {}),\n                errorMessage: err.message,\n                path: err.field,\n                valid: false,\n              })\n            })\n\n            nonFieldErrors.forEach((err) => {\n              toast.error(err.message || t('error:unknown'))\n            })\n\n            return\n          }\n\n          const message = errorMessages?.[res.status] || res?.statusText || t('error:unknown')\n\n          toast.error(message)\n        }\n      } catch (err) {\n        setProcessing(false)\n\n        toast.error(err)\n      }\n    },\n    [\n      action,\n      disableSuccessStatus,\n      disabled,\n      dispatchFields,\n      fields,\n      handleResponse,\n      method,\n      onSubmit,\n      onSuccess,\n      redirect,\n      router,\n      t,\n      i18n,\n      waitForAutocomplete,\n      beforeSubmit,\n    ],\n  )\n\n  const getFields = useCallback(() => contextRef.current.fields, [])\n\n  const getField = useCallback((path: string) => contextRef.current.fields[path], [])\n\n  const getData = useCallback(() => reduceFieldsToValues(contextRef.current.fields, true), [])\n\n  const getSiblingData = useCallback(\n    (path: string) => getSiblingDataFunc(contextRef.current.fields, path),\n    [],\n  )\n  const getDataByPath = useCallback<GetDataByPath>(\n    (path: string) => getDataByPathFunc(contextRef.current.fields, path),\n    [],\n  )\n\n  const createFormData = useCallback((overrides: any = {}) => {\n    const data = reduceFieldsToValues(contextRef.current.fields, true)\n\n    const file = data?.file\n\n    if (file) {\n      delete data.file\n    }\n\n    const dataWithOverrides = {\n      ...data,\n      ...overrides,\n    }\n\n    const dataToSerialize = {\n      _payload: JSON.stringify(dataWithOverrides),\n      file,\n    }\n\n    // nullAsUndefineds is important to allow uploads and relationship fields to clear themselves\n    const formData = serialize(dataToSerialize, { indices: true, nullsAsUndefineds: false })\n\n    return formData\n  }, [])\n\n  const reset = useCallback(\n    async (fieldSchema: Field[], data: unknown) => {\n      const preferences = await getDocPreferences()\n      // const state = await buildStateFromSchema({\n      //   id,\n      //   // TODO: fix this\n      //   // @ts-ignore-next-line\n      //   config,\n      //   data,\n      //   fieldSchema,\n      //   locale,\n      //   operation,\n      //   preferences,\n      //   t,\n      //   user,\n      // })\n      contextRef.current = { ...initContextState } as FormContextType\n      setModified(false)\n      // dispatchFields({ state, type: 'REPLACE_STATE' })\n    },\n    [getDocPreferences],\n  )\n\n  const replaceState = useCallback(\n    (state: FormState) => {\n      contextRef.current = { ...initContextState } as FormContextType\n      setModified(false)\n      dispatchFields({ type: 'REPLACE_STATE', state })\n    },\n    [dispatchFields],\n  )\n\n  const getFieldStateByPath = useCallback(\n    async ({ data, path }) => {\n      const fieldSchema = await getFormState({\n        apiRoute,\n        body: {\n          collectionSlug,\n          data,\n          globalSlug,\n          /**\n            Turns: 'arrayField.0.group123field.arrayField.0.textField'\n            Into: 'arrayField.group123field.arrayField.textField'\n          */\n          schemaPath: `${collectionSlug || globalSlug}.${path}`.replace(/\\.\\d+\\./g, '.'),\n        },\n        serverURL,\n      })\n      return fieldSchema\n    },\n    [apiRoute, collectionSlug, globalSlug, serverURL],\n  )\n\n  const addFieldRow: FormContextType['addFieldRow'] = useCallback(\n    async ({ data, path, rowIndex }) => {\n      const subFieldState = await getFieldStateByPath({ data, path })\n\n      dispatchFields({\n        type: 'ADD_ROW',\n        blockType: data?.blockType,\n        path,\n        rowIndex,\n        subFieldState,\n      })\n    },\n    [getFieldStateByPath, dispatchFields],\n  )\n\n  const removeFieldRow: FormContextType['removeFieldRow'] = useCallback(\n    ({ path, rowIndex }) => {\n      dispatchFields({ type: 'REMOVE_ROW', path, rowIndex })\n    },\n    [dispatchFields],\n  )\n\n  const replaceFieldRow: FormContextType['replaceFieldRow'] = useCallback(\n    async ({ data, path, rowIndex }) => {\n      const subFieldState = await getFieldStateByPath({ data, path })\n\n      dispatchFields({\n        type: 'REPLACE_ROW',\n        blockType: data?.blockType,\n        path,\n        rowIndex,\n        subFieldState,\n      })\n    },\n    [getFieldStateByPath, dispatchFields],\n  )\n\n  contextRef.current.submit = submit\n  contextRef.current.getFields = getFields\n  contextRef.current.getField = getField\n  contextRef.current.getData = getData\n  contextRef.current.getSiblingData = getSiblingData\n  contextRef.current.getDataByPath = getDataByPath\n  contextRef.current.validateForm = validateForm\n  contextRef.current.createFormData = createFormData\n  contextRef.current.setModified = setModified\n  contextRef.current.setProcessing = setProcessing\n  contextRef.current.setSubmitted = setSubmitted\n  contextRef.current.disabled = disabled\n  contextRef.current.formRef = formRef\n  contextRef.current.reset = reset\n  contextRef.current.replaceState = replaceState\n  contextRef.current.dispatchFields = dispatchFields\n  contextRef.current.addFieldRow = addFieldRow\n  contextRef.current.removeFieldRow = removeFieldRow\n  contextRef.current.replaceFieldRow = replaceFieldRow\n  contextRef.current.uuid = uuid\n\n  useEffect(() => {\n    if (typeof submittedFromProps === 'boolean') setSubmitted(submittedFromProps)\n  }, [submittedFromProps])\n\n  useEffect(() => {\n    if (initialState) {\n      contextRef.current = { ...initContextState } as FormContextType\n      dispatchFields({ type: 'REPLACE_STATE', state: initialState })\n    }\n  }, [initialState, dispatchFields])\n\n  useThrottledEffect(\n    () => {\n      refreshCookie()\n    },\n    15000,\n    [fields],\n  )\n\n  useEffect(() => {\n    contextRef.current = { ...contextRef.current } // triggers rerender of all components that subscribe to form\n    setModified(false)\n  }, [locale])\n\n  const classes = [className, baseClass].filter(Boolean).join(' ')\n\n  useDebouncedEffect(\n    () => {\n      const executeOnChange = async () => {\n        if (Array.isArray(onChange)) {\n          let revalidatedFormState: FormState\n\n          await onChange.reduce(async (priorOnChange, onChangeFn) => {\n            await priorOnChange\n\n            const result = await onChangeFn({\n              formState: fields,\n            })\n\n            revalidatedFormState = result\n          }, Promise.resolve())\n\n          const { changed, newState } = mergeServerFormState(fields, revalidatedFormState)\n\n          if (changed) {\n            dispatchFields({ type: 'REPLACE_STATE', optimize: false, state: newState })\n          }\n        }\n      }\n\n      executeOnChange() // eslint-disable-line @typescript-eslint/no-floating-promises\n    },\n    150,\n    [fields, dispatchFields, onChange],\n  )\n\n  return (\n    <form\n      action={action}\n      className={classes}\n      method={method}\n      noValidate\n      onSubmit={(e) => contextRef.current.submit({}, e)}\n      ref={formRef}\n    >\n      <FormContext.Provider value={contextRef.current}>\n        <FormWatchContext.Provider\n          value={{\n            fields,\n            ...contextRef.current,\n          }}\n        >\n          <SubmittedContext.Provider value={submitted}>\n            <ProcessingContext.Provider value={processing}>\n              <ModifiedContext.Provider value={modified}>\n                <FormFieldsContext.Provider value={fieldsReducer}>\n                  {children}\n                </FormFieldsContext.Provider>\n              </ModifiedContext.Provider>\n            </ProcessingContext.Provider>\n          </SubmittedContext.Provider>\n        </FormWatchContext.Provider>\n      </FormContext.Provider>\n    </form>\n  )\n}\n\nexport default Form\n"],"names":["baseClass","Form","props","id","getDocPreferences","useDocumentInfo","action","children","className","disableSuccessStatus","disabled","beforeSubmit","handleResponse","initialState","onChange","onSubmit","onSuccess","redirect","submitted","submittedFromProps","uuid","waitForAutocomplete","method","undefined","router","useRouter","code","locale","useLocale","i18n","t","useTranslation","refreshCookie","user","useAuth","operation","useOperation","config","useConfig","routes","api","apiRoute","serverURL","modified","setModified","useState","processing","setProcessing","setSubmitted","formRef","useRef","contextRef","collectionSlug","globalSlug","fieldsReducer","useReducer","fieldReducer","fields","dispatchFields","current","validateForm","useCallback","validatedFieldState","isValid","dataFromContext","getData","data","validationPromises","Object","entries","map","path","field","validatedField","valid","passesCondition","validationResult","validate","valueToValidate","value","rows","Array","isArray","getDataByPath","siblingData","getSiblingData","errorMessage","Promise","all","isDeepEqual","type","state","submit","options","e","actionToUse","methodToUse","overrides","skipValidation","preventDefault","stopPropagation","wait","revalidatedFormState","reduce","priorOnChange","beforeSubmitFn","result","formState","resolve","every","toast","error","reduceFieldsToValues","formData","createFormData","res","requests","toLowerCase","body","headers","language","contentType","get","isJSON","indexOf","json","status","push","success","message","autoClose","errors","fieldErrors","nonFieldErrors","fieldErrs","nonFieldErrs","err","newFieldErrs","newNonFieldErrs","forEach","dataError","errorMessages","statusText","getFields","getField","getSiblingDataFunc","getDataByPathFunc","file","dataWithOverrides","dataToSerialize","_payload","JSON","stringify","serialize","indices","nullsAsUndefineds","reset","fieldSchema","preferences","initContextState","replaceState","getFieldStateByPath","getFormState","schemaPath","replace","addFieldRow","rowIndex","subFieldState","blockType","removeFieldRow","replaceFieldRow","useEffect","useThrottledEffect","classes","filter","Boolean","join","useDebouncedEffect","executeOnChange","onChangeFn","changed","newState","mergeServerFormState","optimize","form","noValidate","ref","FormContext","Provider","FormWatchContext","SubmittedContext","ProcessingContext","ModifiedContext","FormFieldsContext"],"mappings":"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"}