@payloadcms/ui 3.0.0-canary.a0b06af → 3.0.0-canary.a5aaf21

package/dist/providers/DocumentInfo/index.js

@@ -1,9 +1,11 @@
 'use client';
+
 import { jsx as _jsx } from "react/jsx-runtime";
 import { notFound } from 'next/navigation.js';
 import { reduceFieldsToValues } from 'payload/shared';
 import * as qs from 'qs-esm';
 import React, { createContext, useCallback, useContext, useEffect, useRef, useState } from 'react';
+import { requests } from '../../utilities/api.js';
 import { formatDocTitle } from '../../utilities/formatDocTitle.js';
 import { getFormState } from '../../utilities/getFormState.js';
 import { hasSavePermission as getHasSavePermission } from '../../utilities/hasSavePermission.js';
@@ -13,436 +15,541 @@ import { useConfig } from '../Config/index.js';
 import { useLocale } from '../Locale/index.js';
 import { usePreferences } from '../Preferences/index.js';
 import { useTranslation } from '../Translation/index.js';
-const Context = /*#__PURE__*/ createContext({});
-export const useDocumentInfo = ()=>useContext(Context);
-export const DocumentInfoProvider = ({ children, ...props })=>{
-    const { id, collectionSlug, docPermissions: docPermissionsFromProps, globalSlug, hasPublishPermission: hasPublishPermissionFromProps, hasSavePermission: hasSavePermissionFromProps, initialData: initialDataFromProps, initialState: initialStateFromProps, onLoadError, onSave: onSaveFromProps } = props;
-    const { admin: { dateFormat }, collections, globals, routes: { api }, serverURL } = useConfig();
-    const collectionConfig = collections.find((c)=>c.slug === collectionSlug);
-    const globalConfig = globals.find((g)=>g.slug === globalSlug);
-    const docConfig = collectionConfig || globalConfig;
-    const { i18n } = useTranslation();
-    const [documentTitle, setDocumentTitle] = useState(()=>{
-        if (!initialDataFromProps) return '';
-        return formatDocTitle({
-            collectionConfig,
-            data: {
-                ...initialDataFromProps,
-                id
-            },
-            dateFormat,
-            fallback: id?.toString(),
-            globalConfig,
-            i18n
-        });
-    });
-    const [isLoading, setIsLoading] = useState(false);
-    const [isError, setIsError] = useState(false);
-    const [data, setData] = useState(initialDataFromProps);
-    const [initialState, setInitialState] = useState(initialStateFromProps);
-    const [publishedDoc, setPublishedDoc] = useState(null);
-    const [versions, setVersions] = useState(null);
-    const [docPermissions, setDocPermissions] = useState(docPermissionsFromProps);
-    const [hasSavePermission, setHasSavePermission] = useState(hasSavePermissionFromProps);
-    const [hasPublishPermission, setHasPublishPermission] = useState(hasPublishPermissionFromProps);
-    const isInitializing = initialState === undefined || data === undefined;
-    const hasInitializedDocPermissions = useRef(false);
-    const [unpublishedVersions, setUnpublishedVersions] = useState(null);
-    const { getPreference, setPreference } = usePreferences();
-    const { permissions } = useAuth();
-    const { code: locale } = useLocale();
-    const prevLocale = useRef(locale);
-    const versionsConfig = docConfig?.versions;
-    const baseURL = `${serverURL}${api}`;
-    let slug;
-    let preferencesKey;
-    if (globalSlug) {
-        slug = globalSlug;
-        preferencesKey = `global-${slug}`;
+import { UploadEditsProvider, useUploadEdits } from '../UploadEdits/index.js';
+const Context = /*#__PURE__*/createContext({});
+export const useDocumentInfo = () => {
+  return useContext(Context);
+};
+const DocumentInfo = ({
+  children,
+  ...props
+}) => {
+  const {
+    id,
+    collectionSlug,
+    docPermissions: docPermissionsFromProps,
+    globalSlug,
+    hasPublishPermission: hasPublishPermissionFromProps,
+    hasSavePermission: hasSavePermissionFromProps,
+    initialData: initialDataFromProps,
+    initialState: initialStateFromProps,
+    onLoadError,
+    onSave: onSaveFromProps
+  } = props;
+  const {
+    config: {
+      admin: {
+        dateFormat
+      },
+      collections,
+      globals,
+      routes: {
+        api
+      },
+      serverURL
     }
-    if (collectionSlug) {
-        slug = collectionSlug;
-        if (id) {
-            preferencesKey = `collection-${slug}-${id}`;
-        }
+  } = useConfig();
+  const collectionConfig = collections.find(c => c.slug === collectionSlug);
+  const globalConfig = globals.find(g => g.slug === globalSlug);
+  const docConfig = collectionConfig || globalConfig;
+  const lockDocumentsProp = docConfig?.lockDocuments !== undefined ? docConfig?.lockDocuments : true;
+  const isLockingEnabled = lockDocumentsProp !== false;
+  const {
+    i18n
+  } = useTranslation();
+  const {
+    uploadEdits
+  } = useUploadEdits();
+  const [documentTitle, setDocumentTitle] = useState(() => {
+    if (!initialDataFromProps) {
+      return '';
     }
-    const isEditing = getIsEditing({
-        id,
-        collectionSlug,
-        globalSlug
+    return formatDocTitle({
+      collectionConfig,
+      data: {
+        ...initialDataFromProps,
+        id
+      },
+      dateFormat,
+      fallback: id?.toString(),
+      globalConfig,
+      i18n
     });
-    const operation = isEditing ? 'update' : 'create';
-    const shouldFetchVersions = Boolean(versionsConfig && docPermissions?.readVersions?.permission);
-    const getVersions = useCallback(async ()=>{
-        let versionFetchURL;
-        let publishedFetchURL;
-        let unpublishedVersionJSON = null;
-        let versionJSON = null;
-        let shouldFetch = true;
-        const versionParams = {
-            depth: 0,
-            where: {
-                and: []
-            }
-        };
-        const publishedVersionParams = {
-            depth: 0,
-            locale: locale || undefined,
-            where: {
-                and: [
-                    {
-                        or: [
-                            {
-                                _status: {
-                                    equals: 'published'
-                                }
-                            },
-                            {
-                                _status: {
-                                    exists: false
-                                }
-                            }
-                        ]
-                    }
-                ]
+  });
+  const [isLoading, setIsLoading] = useState(false);
+  const [isError, setIsError] = useState(false);
+  const [data, setData] = useState(initialDataFromProps);
+  const [initialState, setInitialState] = useState(initialStateFromProps);
+  const [publishedDoc, setPublishedDoc] = useState(null);
+  const [versions, setVersions] = useState(null);
+  const [docPermissions, setDocPermissions] = useState(docPermissionsFromProps);
+  const [hasSavePermission, setHasSavePermission] = useState(hasSavePermissionFromProps);
+  const [hasPublishPermission, setHasPublishPermission] = useState(hasPublishPermissionFromProps);
+  const [documentIsLocked, setDocumentIsLocked] = useState(false);
+  const [currentEditor, setCurrentEditor] = useState(null);
+  const isInitializing = initialState === undefined || data === undefined;
+  const [unpublishedVersions, setUnpublishedVersions] = useState(null);
+  const {
+    getPreference,
+    setPreference
+  } = usePreferences();
+  const {
+    permissions
+  } = useAuth();
+  const {
+    code: locale
+  } = useLocale();
+  const prevLocale = useRef(locale);
+  const hasInitializedDocPermissions = useRef(false);
+  const versionsConfig = docConfig?.versions;
+  const baseURL = `${serverURL}${api}`;
+  let slug;
+  let pluralType;
+  let preferencesKey;
+  if (globalSlug) {
+    slug = globalSlug;
+    pluralType = 'globals';
+    preferencesKey = `global-${slug}`;
+  }
+  if (collectionSlug) {
+    slug = collectionSlug;
+    pluralType = 'collections';
+    if (id) {
+      preferencesKey = `collection-${slug}-${id}`;
+    }
+  }
+  const isEditing = getIsEditing({
+    id,
+    collectionSlug,
+    globalSlug
+  });
+  const operation = isEditing ? 'update' : 'create';
+  const shouldFetchVersions = Boolean(versionsConfig && docPermissions?.readVersions?.permission);
+  const unlockDocument = useCallback(async (docId, slug_0) => {
+    try {
+      const isGlobal = slug_0 === globalSlug;
+      const query = isGlobal ? `where[globalSlug][equals]=${slug_0}` : `where[document.value][equals]=${docId}&where[document.relationTo][equals]=${slug_0}`;
+      const request = await requests.get(`${serverURL}${api}/payload-locked-documents?${query}`);
+      const {
+        docs
+      } = await request.json();
+      if (docs.length > 0) {
+        const lockId = docs[0].id;
+        await requests.delete(`${serverURL}${api}/payload-locked-documents/${lockId}`, {
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        });
+        setDocumentIsLocked(false);
+      }
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error('Failed to unlock the document', error);
+    }
+  }, [serverURL, api, globalSlug]);
+  const updateDocumentEditor = useCallback(async (docId_0, slug_1, user) => {
+    try {
+      const isGlobal_0 = slug_1 === globalSlug;
+      const query_0 = isGlobal_0 ? `where[globalSlug][equals]=${slug_1}` : `where[document.value][equals]=${docId_0}&where[document.relationTo][equals]=${slug_1}`;
+      // Check if the document is already locked
+      const request_0 = await requests.get(`${serverURL}${api}/payload-locked-documents?${query_0}`);
+      const {
+        docs: docs_0
+      } = await request_0.json();
+      if (docs_0.length > 0) {
+        const lockId_0 = docs_0[0].id;
+        // Send a patch request to update the _lastEdited info
+        await requests.patch(`${serverURL}${api}/payload-locked-documents/${lockId_0}`, {
+          body: JSON.stringify({
+            user: {
+              relationTo: user?.collection,
+              value: user?.id
             }
-        };
-        if (globalSlug) {
-            versionFetchURL = `${baseURL}/globals/${globalSlug}/versions`;
-            publishedFetchURL = `${baseURL}/globals/${globalSlug}?${qs.stringify(publishedVersionParams)}`;
-        }
-        if (collectionSlug) {
-            versionFetchURL = `${baseURL}/${collectionSlug}/versions`;
-            publishedVersionParams.where.and.push({
-                id: {
-                    equals: id
-                }
-            });
-            publishedFetchURL = `${baseURL}/${collectionSlug}?${qs.stringify(publishedVersionParams)}`;
-            if (!id) {
-                shouldFetch = false;
+          }),
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        });
+      }
+    } catch (error_0) {
+      // eslint-disable-next-line no-console
+      console.error('Failed to update the document editor', error_0);
+    }
+  }, [serverURL, api, globalSlug]);
+  useEffect(() => {
+    if (!isLockingEnabled || !id && !globalSlug) {
+      return;
+    }
+    const fetchDocumentLockState = async () => {
+      if (id || globalSlug) {
+        try {
+          const slug_2 = collectionSlug ?? globalSlug;
+          const isGlobal_1 = slug_2 === globalSlug;
+          const query_1 = isGlobal_1 ? `where[globalSlug][equals]=${slug_2}` : `where[document.value][equals]=${id}&where[document.relationTo][equals]=${slug_2}`;
+          const request_1 = await requests.get(`${serverURL}${api}/payload-locked-documents?${query_1}`);
+          const {
+            docs: docs_1
+          } = await request_1.json();
+          if (docs_1.length > 0) {
+            const newEditor = docs_1[0].user?.value;
+            if (newEditor && newEditor.id !== currentEditor?.id) {
+              setCurrentEditor(newEditor);
+              setDocumentIsLocked(true);
             }
-            versionParams.where.and.push({
-                parent: {
-                    equals: id
-                }
-            });
+          } else {
+            setDocumentIsLocked(false);
+          }
+        } catch (error_1) {
+          // swallow error
         }
-        if (shouldFetch) {
-            let publishedJSON;
-            if (versionsConfig?.drafts) {
-                publishedJSON = await fetch(publishedFetchURL, {
-                    credentials: 'include',
-                    headers: {
-                        'Accept-Language': i18n.language
-                    }
-                }).then((res)=>res.json());
-                if (collectionSlug) {
-                    publishedJSON = publishedJSON?.docs?.[0];
-                }
+      }
+    };
+    void fetchDocumentLockState();
+  }, [id, serverURL, api, collectionSlug, globalSlug, currentEditor, isLockingEnabled]);
+  const getVersions = useCallback(async () => {
+    let versionFetchURL;
+    let publishedFetchURL;
+    let unpublishedVersionJSON = null;
+    let versionJSON = null;
+    let shouldFetch = true;
+    const versionParams = {
+      depth: 0,
+      limit: 0,
+      where: {
+        and: []
+      }
+    };
+    const publishedVersionParams = {
+      depth: 0,
+      locale: locale || undefined,
+      where: {
+        and: [{
+          or: [{
+            _status: {
+              equals: 'published'
             }
-            if (shouldFetchVersions) {
-                versionJSON = await fetch(`${versionFetchURL}?${qs.stringify(versionParams)}`, {
-                    credentials: 'include',
-                    headers: {
-                        'Accept-Language': i18n.language
-                    }
-                }).then((res)=>res.json());
-                if (publishedJSON?.updatedAt) {
-                    const newerVersionParams = {
-                        ...versionParams,
-                        where: {
-                            ...versionParams.where,
-                            and: [
-                                ...versionParams.where.and,
-                                {
-                                    updatedAt: {
-                                        greater_than: publishedJSON?.updatedAt
-                                    }
-                                }
-                            ]
-                        }
-                    };
-                    // Get any newer versions available
-                    const newerVersionRes = await fetch(`${versionFetchURL}?${qs.stringify(newerVersionParams)}`, {
-                        credentials: 'include',
-                        headers: {
-                            'Accept-Language': i18n.language
-                        }
-                    });
-                    if (newerVersionRes.status === 200) {
-                        unpublishedVersionJSON = await newerVersionRes.json();
-                    }
-                }
+          }, {
+            _status: {
+              exists: false
             }
-            setPublishedDoc(publishedJSON);
-            setVersions(versionJSON);
-            setUnpublishedVersions(unpublishedVersionJSON);
+          }]
+        }]
+      }
+    };
+    if (globalSlug) {
+      versionFetchURL = `${baseURL}/globals/${globalSlug}/versions`;
+      publishedFetchURL = `${baseURL}/globals/${globalSlug}?${qs.stringify(publishedVersionParams)}`;
+    }
+    if (collectionSlug) {
+      versionFetchURL = `${baseURL}/${collectionSlug}/versions`;
+      publishedVersionParams.where.and.push({
+        id: {
+          equals: id
         }
-    }, [
-        i18n,
-        globalSlug,
-        collectionSlug,
-        id,
-        baseURL,
-        locale,
-        versionsConfig,
-        shouldFetchVersions
-    ]);
-    const getDocPermissions = React.useCallback(async (data)=>{
-        const params = {
-            locale: locale || undefined
-        };
-        const newIsEditing = getIsEditing({
-            id: data?.id,
-            collectionSlug,
-            globalSlug
-        });
-        if (newIsEditing) {
-            const docAccessURL = collectionSlug ? `/${collectionSlug}/access/${data.id}` : globalSlug ? `/globals/${globalSlug}/access` : null;
-            if (docAccessURL) {
-                const res = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
-                    credentials: 'include',
-                    headers: {
-                        'Accept-Language': i18n.language
-                    }
-                });
-                const json = await res.json();
-                const publishedAccessJSON = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
-                    body: JSON.stringify({
-                        data: {
-                            ...data || {},
-                            _status: 'published'
-                        }
-                    }),
-                    credentials: 'include',
-                    headers: {
-                        'Accept-Language': i18n.language
-                    },
-                    method: 'POST'
-                }).then((res)=>res.json());
-                setDocPermissions(json);
-                setHasSavePermission(getHasSavePermission({
-                    collectionSlug,
-                    docPermissions: json,
-                    globalSlug,
-                    isEditing: newIsEditing
-                }));
-                setHasPublishPermission(publishedAccessJSON?.update?.permission);
-            }
-        } else {
-            // when creating new documents, there is no permissions saved for this document yet
-            // use the generic entity permissions instead
-            const newDocPermissions = collectionSlug ? permissions?.collections?.[collectionSlug] : permissions?.globals?.[globalSlug];
-            setDocPermissions(newDocPermissions);
-            setHasSavePermission(getHasSavePermission({
-                collectionSlug,
-                docPermissions: newDocPermissions,
-                globalSlug,
-                isEditing: newIsEditing
-            }));
+      });
+      publishedFetchURL = `${baseURL}/${collectionSlug}?${qs.stringify(publishedVersionParams)}`;
+      if (!id) {
+        shouldFetch = false;
+      }
+      versionParams.where.and.push({
+        parent: {
+          equals: id
         }
-    }, [
-        serverURL,
-        api,
-        permissions,
-        i18n.language,
-        locale,
-        collectionSlug,
-        globalSlug
-    ]);
-    const getDocPreferences = useCallback(()=>{
-        return getPreference(preferencesKey);
-    }, [
-        getPreference,
-        preferencesKey
-    ]);
-    const setDocFieldPreferences = useCallback(async (path, fieldPreferences)=>{
-        const allPreferences = await getDocPreferences();
-        if (preferencesKey) {
-            try {
-                await setPreference(preferencesKey, {
-                    ...allPreferences,
-                    fields: {
-                        ...allPreferences?.fields || {},
-                        [path]: {
-                            ...allPreferences?.fields?.[path],
-                            ...fieldPreferences
-                        }
-                    }
-                });
-            } catch (e) {
-                console.error(e) // eslint-disable-line no-console
-                ;
-            }
+      });
+    }
+    if (shouldFetch) {
+      let publishedJSON;
+      if (versionsConfig?.drafts) {
+        publishedJSON = await fetch(publishedFetchURL, {
+          credentials: 'include',
+          headers: {
+            'Accept-Language': i18n.language
+          }
+        }).then(res => res.json());
+        if (collectionSlug) {
+          publishedJSON = publishedJSON?.docs?.[0];
         }
-    }, [
-        setPreference,
-        preferencesKey,
-        getDocPreferences
-    ]);
-    const onSave = React.useCallback(async (json)=>{
-        if (typeof onSaveFromProps === 'function') {
-            void onSaveFromProps(json);
+      }
+      if (shouldFetchVersions) {
+        versionJSON = await fetch(`${versionFetchURL}?${qs.stringify(versionParams)}`, {
+          credentials: 'include',
+          headers: {
+            'Accept-Language': i18n.language
+          }
+        }).then(res_0 => res_0.json());
+        if (publishedJSON?.updatedAt) {
+          const newerVersionParams = {
+            ...versionParams,
+            where: {
+              ...versionParams.where,
+              and: [...versionParams.where.and, {
+                or: [{
+                  updatedAt: {
+                    greater_than: publishedJSON.updatedAt
+                  }
+                }, {
+                  latest: {
+                    equals: true
+                  }
+                }]
+              }]
+            }
+          };
+          // Get any newer versions available
+          const newerVersionRes = await fetch(`${versionFetchURL}?${qs.stringify(newerVersionParams)}`, {
+            credentials: 'include',
+            headers: {
+              'Accept-Language': i18n.language
+            }
+          });
+          if (newerVersionRes.status === 200) {
+            unpublishedVersionJSON = await newerVersionRes.json();
+          }
         }
-        const docPreferences = await getDocPreferences();
-        const newData = collectionSlug ? json.doc : json.result;
-        const newState = await getFormState({
-            apiRoute: api,
-            body: {
-                id,
-                collectionSlug,
-                data: newData,
-                docPreferences,
-                globalSlug,
-                locale,
-                operation,
-                schemaPath: collectionSlug || globalSlug
-            },
-            serverURL
+      }
+      setPublishedDoc(publishedJSON);
+      setVersions(versionJSON);
+      setUnpublishedVersions(unpublishedVersionJSON);
+    }
+  }, [i18n, globalSlug, collectionSlug, id, baseURL, locale, versionsConfig, shouldFetchVersions]);
+  const getDocPermissions = React.useCallback(async data_0 => {
+    const params = {
+      locale: locale || undefined
+    };
+    const idToUse = data_0?.id || id;
+    const newIsEditing = getIsEditing({
+      id: idToUse,
+      collectionSlug,
+      globalSlug
+    });
+    if (newIsEditing) {
+      const docAccessURL = collectionSlug ? `/${collectionSlug}/access/${idToUse}` : globalSlug ? `/globals/${globalSlug}/access` : null;
+      if (docAccessURL) {
+        const res_1 = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
+          body: JSON.stringify(data_0),
+          credentials: 'include',
+          headers: {
+            'Accept-Language': i18n.language,
+            'Content-Type': 'application/json'
+          },
+          method: 'post'
         });
-        setInitialState(newState);
-        setData(newData);
-        await getDocPermissions(newData);
-    }, [
-        api,
+        const json = await res_1.json();
+        const publishedAccessJSON = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
+          body: JSON.stringify({
+            ...(data_0 || {}),
+            _status: 'published'
+          }),
+          credentials: 'include',
+          headers: {
+            'Accept-Language': i18n.language,
+            'Content-Type': 'application/json'
+          },
+          method: 'POST'
+        }).then(res_2 => res_2.json());
+        setDocPermissions(json);
+        setHasSavePermission(getHasSavePermission({
+          collectionSlug,
+          docPermissions: json,
+          globalSlug,
+          isEditing: newIsEditing
+        }));
+        setHasPublishPermission(publishedAccessJSON?.update?.permission);
+      }
+    } else {
+      // when creating new documents, there is no permissions saved for this document yet
+      // use the generic entity permissions instead
+      const newDocPermissions = collectionSlug ? permissions?.collections?.[collectionSlug] : permissions?.globals?.[globalSlug];
+      setDocPermissions(newDocPermissions);
+      setHasSavePermission(getHasSavePermission({
         collectionSlug,
-        getDocPreferences,
+        docPermissions: newDocPermissions,
         globalSlug,
+        isEditing: newIsEditing
+      }));
+    }
+  }, [serverURL, api, id, permissions, i18n.language, locale, collectionSlug, globalSlug]);
+  const getDocPreferences = useCallback(() => {
+    return getPreference(preferencesKey);
+  }, [getPreference, preferencesKey]);
+  const setDocFieldPreferences = useCallback(async (path, fieldPreferences) => {
+    const allPreferences = await getDocPreferences();
+    if (preferencesKey) {
+      try {
+        await setPreference(preferencesKey, {
+          ...allPreferences,
+          fields: {
+            ...(allPreferences?.fields || {}),
+            [path]: {
+              ...allPreferences?.fields?.[path],
+              ...fieldPreferences
+            }
+          }
+        });
+      } catch (e) {
+        console.error(e) // eslint-disable-line no-console
+        ;
+      }
+    }
+  }, [setPreference, preferencesKey, getDocPreferences]);
+  const onSave = React.useCallback(async json_0 => {
+    if (typeof onSaveFromProps === 'function') {
+      void onSaveFromProps(json_0);
+    }
+    const docPreferences = await getDocPreferences();
+    const newData = collectionSlug ? json_0.doc : json_0.result;
+    const {
+      state: newState
+    } = await getFormState({
+      apiRoute: api,
+      body: {
         id,
-        operation,
-        locale,
-        onSaveFromProps,
-        serverURL,
-        getDocPermissions
-    ]);
-    useEffect(()=>{
-        const abortController = new AbortController();
-        const localeChanged = locale !== prevLocale.current;
-        if (initialStateFromProps === undefined || initialDataFromProps === undefined || localeChanged) {
-            if (localeChanged) prevLocale.current = locale;
-            const getInitialState = async ()=>{
-                setIsError(false);
-                setIsLoading(true);
-                try {
-                    const result = await getFormState({
-                        apiRoute: api,
-                        body: {
-                            id,
-                            collectionSlug,
-                            globalSlug,
-                            locale,
-                            operation,
-                            schemaPath: collectionSlug || globalSlug
-                        },
-                        onError: onLoadError,
-                        serverURL,
-                        signal: abortController.signal
-                    });
-                    setData(reduceFieldsToValues(result, true));
-                    setInitialState(result);
-                } catch (err) {
-                    if (!abortController.signal.aborted) {
-                        if (typeof onLoadError === 'function') {
-                            void onLoadError();
-                        }
-                        setIsError(true);
-                        setIsLoading(false);
-                    }
-                }
-                setIsLoading(false);
-            };
-            void getInitialState();
-        }
-        return ()=>{
-            abortController.abort();
-        };
-    }, [
-        api,
-        operation,
         collectionSlug,
-        serverURL,
-        id,
+        data: newData,
+        docPreferences,
         globalSlug,
         locale,
-        onLoadError,
-        initialDataFromProps,
-        initialStateFromProps
-    ]);
-    useEffect(()=>{
-        void getVersions();
-    }, [
-        getVersions
-    ]);
-    useEffect(()=>{
-        setDocumentTitle(formatDocTitle({
-            collectionConfig,
-            data: {
-                ...data,
-                id
+        operation,
+        schemaPath: collectionSlug || globalSlug
+      },
+      serverURL
+    });
+    setInitialState(newState);
+    setData(newData);
+    await getDocPermissions(newData);
+  }, [api, collectionSlug, getDocPreferences, globalSlug, id, operation, locale, onSaveFromProps, serverURL, getDocPermissions]);
+  useEffect(() => {
+    const abortController = new AbortController();
+    const localeChanged = locale !== prevLocale.current;
+    if (initialStateFromProps === undefined || initialDataFromProps === undefined || localeChanged) {
+      if (localeChanged) {
+        prevLocale.current = locale;
+      }
+      const getInitialState = async () => {
+        setIsError(false);
+        setIsLoading(true);
+        try {
+          const {
+            state: result
+          } = await getFormState({
+            apiRoute: api,
+            body: {
+              id,
+              collectionSlug,
+              globalSlug,
+              locale,
+              operation,
+              schemaPath: collectionSlug || globalSlug
             },
-            dateFormat,
-            fallback: id?.toString(),
-            globalConfig,
-            i18n
-        }));
-    }, [
-        collectionConfig,
-        data,
-        dateFormat,
-        i18n,
-        id,
-        globalConfig
-    ]);
-    useEffect(()=>{
-        const loadDocPermissions = async ()=>{
-            const docPermissions = docPermissionsFromProps;
-            const hasSavePermission = hasSavePermissionFromProps;
-            const hasPublishPermission = hasPublishPermissionFromProps;
-            if (!docPermissions || hasSavePermission === undefined || hasSavePermission === null || hasPublishPermission === undefined || hasPublishPermission === null) {
-                await getDocPermissions(data);
+            onError: onLoadError,
+            serverURL,
+            signal: abortController.signal
+          });
+          const data_1 = reduceFieldsToValues(result, true);
+          setData(data_1);
+          if (localeChanged) {
+            void getDocPermissions(data_1);
+          }
+          setInitialState(result);
+        } catch (err) {
+          if (!abortController.signal.aborted) {
+            if (typeof onLoadError === 'function') {
+              void onLoadError();
             }
-        };
-        if (!hasInitializedDocPermissions.current && data && (collectionSlug || globalSlug)) {
-            hasInitializedDocPermissions.current = true;
-            void loadDocPermissions();
+            setIsError(true);
+            setIsLoading(false);
+          }
         }
-    }, [
-        getDocPermissions,
-        docPermissionsFromProps,
-        hasSavePermissionFromProps,
-        hasPublishPermissionFromProps,
-        setDocPermissions,
-        collectionSlug,
-        globalSlug,
-        data
-    ]);
-    if (isError) notFound();
-    const value = {
-        ...props,
-        docConfig,
-        docPermissions,
-        getDocPermissions,
-        getDocPreferences,
-        getVersions,
-        hasPublishPermission,
-        hasSavePermission,
-        initialData: data,
-        initialState,
-        isInitializing,
-        isLoading,
-        onSave,
-        publishedDoc,
-        setDocFieldPreferences,
-        setDocumentTitle,
-        title: documentTitle,
-        unpublishedVersions,
-        versions
+        setIsLoading(false);
+      };
+      void getInitialState();
+    }
+    return () => {
+      try {
+        abortController.abort();
+      } catch (error_2) {
+        // swallow error
+      }
     };
-    return /*#__PURE__*/ _jsx(Context.Provider, {
-        value: value,
-        children: children
-    });
+  }, [api, operation, collectionSlug, serverURL, id, globalSlug, locale, onLoadError, initialDataFromProps, initialStateFromProps, getDocPermissions]);
+  useEffect(() => {
+    void getVersions();
+  }, [getVersions]);
+  useEffect(() => {
+    setDocumentTitle(formatDocTitle({
+      collectionConfig,
+      data: {
+        ...data,
+        id
+      },
+      dateFormat,
+      fallback: id?.toString(),
+      globalConfig,
+      i18n
+    }));
+  }, [collectionConfig, data, dateFormat, i18n, id, globalConfig]);
+  useEffect(() => {
+    if (data && (collectionSlug || globalSlug)) {
+      if (hasInitializedDocPermissions.current === false && (!docPermissions || hasSavePermission === undefined || hasSavePermission === null || hasPublishPermission === undefined || hasPublishPermission === null)) {
+        hasInitializedDocPermissions.current = true;
+        void getDocPermissions(data);
+      }
+    }
+  }, [getDocPermissions, docPermissionsFromProps, hasSavePermissionFromProps, hasPublishPermissionFromProps, setDocPermissions, collectionSlug, globalSlug, data, docPermissions, hasSavePermission, hasPublishPermission]);
+  const action = React.useMemo(() => {
+    const docURL = `${baseURL}${pluralType === 'globals' ? `/globals` : ''}/${slug}${id ? `/${id}` : ''}`;
+    const params_0 = {
+      depth: 0,
+      'fallback-locale': 'null',
+      locale,
+      uploadEdits: uploadEdits || undefined
+    };
+    return `${docURL}${qs.stringify(params_0, {
+      addQueryPrefix: true
+    })}`;
+  }, [baseURL, locale, pluralType, id, slug, uploadEdits]);
+  if (isError) {
+    notFound();
+  }
+  const value = {
+    ...props,
+    action,
+    currentEditor,
+    docConfig,
+    docPermissions,
+    documentIsLocked,
+    getDocPermissions,
+    getDocPreferences,
+    getVersions,
+    hasPublishPermission,
+    hasSavePermission,
+    initialData: data,
+    initialState,
+    isInitializing,
+    isLoading,
+    onSave,
+    preferencesKey,
+    publishedDoc,
+    setCurrentEditor,
+    setDocFieldPreferences,
+    setDocumentIsLocked,
+    setDocumentTitle,
+    title: documentTitle,
+    unlockDocument,
+    unpublishedVersions,
+    updateDocumentEditor,
+    versions
+  };
+  return /*#__PURE__*/_jsx(Context.Provider, {
+    value: value,
+    children: children
+  });
+};
+export const DocumentInfoProvider = props => {
+  return /*#__PURE__*/_jsx(UploadEditsProvider, {
+    children: /*#__PURE__*/_jsx(DocumentInfo, {
+      ...props
+    })
+  });
 };
-
 //# sourceMappingURL=index.js.map