payload 0.14.22-beta.0 → 0.14.23-beta.0

package/dist/admin/components/forms/field-types/Relationship/index.js

@@ -1,5 +1,6 @@
 import React, { useCallback, useEffect, useState, useReducer, } from 'react';
 import { useConfig } from '@payloadcms/config-provider';
+import qs from 'qs';
 import withCondition from '../../withCondition';
 import ReactSelect from '../../../elements/ReactSelect';
 import useField from '../../useField';
@@ -10,6 +11,7 @@ import { relationship } from '../../../../../fields/validations';
 import { useFormProcessing } from '../../Form/context';
 import optionsReducer from './optionsReducer';
 import useDebounce from '../../../../hooks/useDebounce';
+import { createRelationMap } from './createRelationMap';
 import './index.scss';
 const maxResultsPerRequest = 10;
 const baseClass = 'relationship';
@@ -29,21 +31,22 @@ const Relationship = (props) => {
         const validationResult = validate(value, { required });
         return validationResult;
     }, [validate, required]);
-    const { value, showError, errorMessage, setValue, } = useField({
+    const { value, showError, errorMessage, setValue, initialValue, } = useField({
         path: path || name,
         validate: memoizedValidate,
         condition,
     });
-    const addOptions = useCallback((data, relation) => {
+    const addOptions = useCallback((data, relation, sort) => {
         const collection = collections.find((coll) => coll.slug === relation);
-        dispatchOptions({ type: 'ADD', data, relation, hasMultipleRelations, collection });
+        dispatchOptions({ type: 'ADD', data, relation, hasMultipleRelations, collection, sort });
     }, [collections, hasMultipleRelations]);
-    const getResults = useCallback(async ({ lastFullyLoadedRelation: lastFullyLoadedRelationArg, lastLoadedPage: lastLoadedPageArg, search: searchArg, }) => {
+    const getResults = useCallback(async ({ lastFullyLoadedRelation: lastFullyLoadedRelationArg, lastLoadedPage: lastLoadedPageArg, search: searchArg, value: valueArg, sort, }) => {
         let lastLoadedPageToUse = typeof lastLoadedPageArg !== 'undefined' ? lastLoadedPageArg : 1;
         const lastFullyLoadedRelationToUse = typeof lastFullyLoadedRelationArg !== 'undefined' ? lastFullyLoadedRelationArg : -1;
         const relations = Array.isArray(relationTo) ? relationTo : [relationTo];
         const relationsToFetch = lastFullyLoadedRelationToUse === -1 ? relations : relations.slice(lastFullyLoadedRelationToUse + 1);
         let resultsFetched = 0;
+        const relationMap = createRelationMap({ hasMany, relationTo, value: valueArg });
         if (!errorLoading) {
             relationsToFetch.reduce(async (priorRelation, relation) => {
                 var _a;
@@ -51,13 +54,29 @@ const Relationship = (props) => {
                 if (resultsFetched < 10) {
                     const collection = collections.find((coll) => coll.slug === relation);
                     const fieldToSearch = ((_a = collection === null || collection === void 0 ? void 0 : collection.admin) === null || _a === void 0 ? void 0 : _a.useAsTitle) || 'id';
-                    const searchParam = searchArg ? `&where[${fieldToSearch}][like]=${searchArg}` : '';
-                    const response = await fetch(`${serverURL}${api}/${relation}?limit=${maxResultsPerRequest}&page=${lastLoadedPageToUse}&depth=0${searchParam}`);
+                    const query = {
+                        where: {},
+                        limit: maxResultsPerRequest,
+                        page: lastLoadedPageToUse,
+                        sort: fieldToSearch,
+                        depth: 0,
+                    };
+                    if (searchArg) {
+                        query.where[fieldToSearch] = {
+                            like: searchArg,
+                        };
+                    }
+                    else {
+                        query.where.id = {
+                            not_in: relationMap[relation],
+                        };
+                    }
+                    const response = await fetch(`${serverURL}${api}/${relation}?${qs.stringify(query)}`);
                     if (response.ok) {
                         const data = await response.json();
                         if (data.docs.length > 0) {
                             resultsFetched += data.docs.length;
-                            addOptions(data, relation);
+                            addOptions(data, relation, sort);
                             setLastLoadedPage(data.page);
                             if (!data.nextPage) {
                                 setLastFullyLoadedRelation(relations.indexOf(relation));
@@ -75,7 +94,7 @@ const Relationship = (props) => {
                 }
             }, Promise.resolve());
         }
-    }, [addOptions, api, collections, serverURL, errorLoading, relationTo]);
+    }, [addOptions, api, collections, serverURL, errorLoading, relationTo, hasMany]);
     const findOptionsByValue = useCallback(() => {
         if (value) {
             if (hasMany) {
@@ -126,18 +145,6 @@ const Relationship = (props) => {
             setSearch(newSearch);
         }
     }, [search]);
-    const addOptionByID = useCallback(async (id, relation) => {
-        if (!errorLoading && id !== 'null' && id !== null) {
-            const response = await fetch(`${serverURL}${api}/${relation}/${id}?depth=0`);
-            if (response.ok) {
-                const data = await response.json();
-                addOptions({ docs: [data] }, relation);
-            }
-            else {
-                console.error(`There was a problem loading the document with ID of ${id}.`);
-            }
-        }
-    }, [addOptions, api, errorLoading, serverURL]);
     // ///////////////////////////
     // Get results when search input changes
     // ///////////////////////////
@@ -146,43 +153,50 @@ const Relationship = (props) => {
             type: 'CLEAR',
             required,
         });
-        setHasLoadedFirstOptions(true);
         setLastLoadedPage(1);
         setLastFullyLoadedRelation(-1);
-        getResults({ search: debouncedSearch });
-    }, [getResults, debouncedSearch, relationTo, required]);
+        getResults({ search: debouncedSearch, value: initialValue, sort: true });
+    }, [getResults, debouncedSearch, relationTo, required, initialValue]);
     // ///////////////////////////
-    // Format options once first options have been retrieved
+    // Fetch value options when initialValue changes
     // ///////////////////////////
     useEffect(() => {
-        if (value && hasLoadedFirstOptions) {
-            if (hasMany) {
-                const matchedOptions = findOptionsByValue();
-                (matchedOptions || []).forEach((option, i) => {
-                    if (!option) {
-                        if (hasMultipleRelations) {
-                            addOptionByID(value[i].value, value[i].relationTo);
+        if (initialValue && !hasLoadedFirstOptions) {
+            const relationMap = createRelationMap({
+                hasMany,
+                relationTo,
+                value: initialValue,
+            });
+            Object.entries(relationMap).reduce(async (priorRelation, [relation, ids]) => {
+                await priorRelation;
+                if (ids.length > 0) {
+                    const query = {
+                        where: {
+                            id: {
+                                in: ids,
+                            },
+                        },
+                        depth: 0,
+                        limit: ids.length,
+                    };
+                    if (!errorLoading) {
+                        const response = await fetch(`${serverURL}${api}/${relation}?${qs.stringify(query)}`);
+                        if (response.ok) {
+                            const data = await response.json();
+                            addOptions({ docs: data.docs }, relation, true);
                         }
                         else {
-                            addOptionByID(value[i], relationTo);
+                            console.error(`There was a problem loading relationships to related collection ${relation}.`);
                         }
                     }
-                });
-            }
-            else {
-                const matchedOption = findOptionsByValue();
-                if (!matchedOption) {
-                    if (hasMultipleRelations) {
-                        const valueWithRelation = value;
-                        addOptionByID(valueWithRelation.value, valueWithRelation.relationTo);
-                    }
-                    else {
-                        addOptionByID(value, relationTo);
-                    }
                 }
-            }
+            }, Promise.resolve());
+            setHasLoadedFirstOptions(true);
         }
-    }, [addOptionByID, findOptionsByValue, hasMany, hasMultipleRelations, relationTo, value, hasLoadedFirstOptions]);
+    }, [hasMany, hasMultipleRelations, relationTo, initialValue, hasLoadedFirstOptions, errorLoading, addOptions, api, serverURL]);
+    useEffect(() => {
+        setHasLoadedFirstOptions(false);
+    }, [initialValue]);
     const classes = [
         'field-type',
         baseClass,
@@ -220,7 +234,13 @@ const Relationship = (props) => {
                     setValue(selected.value);
                 }
             } : undefined, onMenuScrollToBottom: () => {
-                getResults({ lastFullyLoadedRelation, lastLoadedPage: lastLoadedPage + 1, search });
+                getResults({
+                    lastFullyLoadedRelation,
+                    lastLoadedPage: lastLoadedPage + 1,
+                    search,
+                    value: initialValue,
+                    sort: false,
+                });
             }, value: valueToRender, showError: showError, disabled: formProcessing, options: options, isMulti: hasMany })),
         errorLoading && (React.createElement("div", { className: `${baseClass}__error-loading` }, errorLoading)),
         React.createElement(FieldDescription, { value: value, description: description })));

package/dist/admin/components/forms/field-types/Relationship/optionsReducer.js

@@ -10,17 +10,24 @@ const reduceToIDs = (options) => options.reduce((ids, option) => {
         option.value,
     ];
 }, []);
+const sortOptions = (options) => options.sort((a, b) => {
+    var _a, _b;
+    if (typeof ((_a = a === null || a === void 0 ? void 0 : a.label) === null || _a === void 0 ? void 0 : _a.localeCompare) === 'function' && typeof ((_b = b === null || b === void 0 ? void 0 : b.label) === null || _b === void 0 ? void 0 : _b.localeCompare) === 'function') {
+        return a.label.localeCompare(b.label);
+    }
+    return 0;
+});
 const optionsReducer = (state, action) => {
     switch (action.type) {
         case 'CLEAR': {
             return action.required ? [] : [{ value: 'null', label: 'None' }];
         }
         case 'ADD': {
-            const { hasMultipleRelations, collection, relation, data } = action;
+            const { hasMultipleRelations, collection, relation, data, sort } = action;
             const labelKey = collection.admin.useAsTitle || 'id';
             const loadedIDs = reduceToIDs(state);
             if (!hasMultipleRelations) {
-                return [
+                const options = [
                     ...state,
                     ...data.docs.reduce((docs, doc) => {
                         if (loadedIDs.indexOf(doc.id) === -1) {
@@ -28,7 +35,7 @@ const optionsReducer = (state, action) => {
                             return [
                                 ...docs,
                                 {
-                                    label: doc[labelKey],
+                                    label: doc[labelKey] || `Untitled - ID: ${doc.id}`,
                                     value: doc.id,
                                 },
                             ];
@@ -36,6 +43,7 @@ const optionsReducer = (state, action) => {
                         return docs;
                     }, []),
                 ];
+                return sort ? sortOptions(options) : options;
             }
             const newOptions = [...state];
             const optionsToAddTo = newOptions.find((optionGroup) => optionGroup.label === collection.labels.plural);
@@ -45,7 +53,7 @@ const optionsReducer = (state, action) => {
                     return [
                         ...docs,
                         {
-                            label: doc[labelKey],
+                            label: doc[labelKey] || `Untitled - ID: ${doc.id}`,
                             relationTo: relation,
                             value: doc.id,
                         },
@@ -54,15 +62,16 @@ const optionsReducer = (state, action) => {
                 return docs;
             }, []);
             if (optionsToAddTo) {
-                optionsToAddTo.options = [
+                const subOptions = [
                     ...optionsToAddTo.options,
                     ...newSubOptions,
                 ];
+                optionsToAddTo.options = sort ? sortOptions(subOptions) : subOptions;
             }
             else {
                 newOptions.push({
                     label: collection.labels.plural,
-                    options: newSubOptions,
+                    options: sort ? sortOptions(newSubOptions) : newSubOptions,
                     value: undefined,
                 });
             }

package/dist/admin/components/forms/field-types/Relationship/types.d.ts

@@ -1,4 +1,5 @@
-import { PaginatedDocs, SanitizedCollectionConfig } from '../../../../../collections/config/types';
+import { SanitizedCollectionConfig } from '../../../../../collections/config/types';
+import { PaginatedDocs } from '../../../../../mongoose/types';
 import { RelationshipField } from '../../../../../fields/config/types';
 export declare type Props = Omit<RelationshipField, 'type'> & {
     path?: string;
@@ -19,10 +20,18 @@ declare type ADD = {
     relation: string;
     hasMultipleRelations: boolean;
     collection: SanitizedCollectionConfig;
+    sort?: boolean;
 };
 export declare type Action = CLEAR | ADD;
 export declare type ValueWithRelation = {
     relationTo: string;
     value: string;
 };
+export declare type GetResults = (args: {
+    lastFullyLoadedRelation?: number;
+    lastLoadedPage?: number;
+    search?: string;
+    value?: unknown;
+    sort?: boolean;
+}) => Promise<void>;
 export {};

package/dist/admin/components/forms/field-types/RichText/RichText.js

@@ -32,6 +32,7 @@ const RichText = (props) => {
     const [loaded, setLoaded] = useState(false);
     const [enabledElements, setEnabledElements] = useState({});
     const [enabledLeaves, setEnabledLeaves] = useState({});
+    const [initialValueKey, setInitialValueKey] = useState('');
     const renderElement = useCallback(({ attributes, children, element }) => {
         const matchedElement = enabledElements[element === null || element === void 0 ? void 0 : element.type];
         const Element = matchedElement === null || matchedElement === void 0 ? void 0 : matchedElement.Element;
@@ -58,7 +59,7 @@ const RichText = (props) => {
         validate: memoizedValidate,
         condition,
     });
-    const { value, showError, setValue, errorMessage, } = fieldType;
+    const { value, showError, setValue, errorMessage, initialValue, } = fieldType;
     const classes = [
         baseClass,
         'field-type',
@@ -85,6 +86,9 @@ const RichText = (props) => {
             setLoaded(true);
         }
     }, [loaded, elements, leaves]);
+    useEffect(() => {
+        setInitialValueKey(JSON.stringify(initialValue || ''));
+    }, [initialValue]);
     if (!loaded) {
         return null;
     }
@@ -100,7 +104,7 @@ const RichText = (props) => {
     }
     if (!valueToRender)
         valueToRender = defaultValue;
-    return (React.createElement("div", { className: classes, style: {
+    return (React.createElement("div", { key: initialValueKey, className: classes, style: {
             ...style,
             width,
         } },

package/dist/admin/components/forms/field-types/RichText/elements/upload/Button/index.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import './index.scss';
-import '../modal.scss';
+import '../addSwapModals.scss';
 declare const UploadButton: React.FC<{
     path: string;
 }>;

package/dist/admin/components/forms/field-types/RichText/elements/upload/Button/index.js

@@ -16,7 +16,7 @@ import MinimalTemplate from '../../../../../../templates/Minimal';
 import Button from '../../../../../../elements/Button';
 import PerPage from '../../../../../../elements/PerPage';
 import './index.scss';
-import '../modal.scss';
+import '../addSwapModals.scss';
 const baseClass = 'upload-rich-text-button';
 const baseModalClass = 'rich-text-upload-modal';
 const insertUpload = (editor, { value, relationTo }) => {
@@ -37,6 +37,7 @@ const insertUpload = (editor, { value, relationTo }) => {
     ReactEditor.focus(editor);
 };
 const UploadButton = ({ path }) => {
+    var _a, _b;
     const { open, closeAll, currentModal } = useModal();
     const editor = useSlate();
     const { serverURL, routes: { api }, collections } = useConfig();
@@ -132,6 +133,6 @@ const UploadButton = ({ path }) => {
                         "of",
                         ' ',
                         data.totalDocs),
-                    React.createElement(PerPage, { collection: modalCollection, limit: limit, modifySearchParams: false, handleChange: setLimit }))))))))));
+                    React.createElement(PerPage, { limits: (_b = (_a = modalCollection === null || modalCollection === void 0 ? void 0 : modalCollection.admin) === null || _a === void 0 ? void 0 : _a.pagination) === null || _b === void 0 ? void 0 : _b.limits, limit: limit, modifySearchParams: false, handleChange: setLimit }))))))))));
 };
 export default UploadButton;

package/dist/admin/components/forms/field-types/RichText/elements/upload/Element/SwapUploadModal/index.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { Element } from 'slate';
 import { SanitizedCollectionConfig } from '../../../../../../../../../collections/config/types';
-import './index.scss';
+import '../../addSwapModals.scss';
 declare type Props = {
     slug: string;
     element: Element;

package/dist/admin/components/forms/field-types/RichText/elements/upload/Element/SwapUploadModal/index.js

@@ -13,9 +13,10 @@ import UploadGallery from '../../../../../../../elements/UploadGallery';
 import Paginator from '../../../../../../../elements/Paginator';
 import PerPage from '../../../../../../../elements/PerPage';
 import formatFields from '../../../../../../../views/collections/List/formatFields';
-import './index.scss';
-const baseClass = 'swap-upload-modal';
+import '../../addSwapModals.scss';
+const baseClass = 'rich-text-upload-modal';
 export const SwapUploadModal = ({ closeModal, element, setRelatedCollectionConfig, relatedCollectionConfig, slug }) => {
+    var _a, _b;
     const { collections, serverURL, routes: { api } } = useConfig();
     const editor = useSlateStatic();
     const [modalCollection, setModalCollection] = React.useState(relatedCollectionConfig);
@@ -92,5 +93,5 @@ export const SwapUploadModal = ({ closeModal, element, setRelatedCollectionConfi
                         "of",
                         ' ',
                         data.totalDocs),
-                    React.createElement(PerPage, { collection: modalCollection, limit: limit, modifySearchParams: false, handleChange: setLimit })))))));
+                    React.createElement(PerPage, { limits: (_b = (_a = modalCollection === null || modalCollection === void 0 ? void 0 : modalCollection.admin) === null || _a === void 0 ? void 0 : _a.pagination) === null || _b === void 0 ? void 0 : _b.limits, limit: limit, modifySearchParams: false, handleChange: setLimit })))))));
 };

package/dist/admin/components/forms/field-types/RichText/elements/upload/Element/index.js

@@ -8,8 +8,8 @@ import FileGraphic from '../../../../../../graphics/File';
 import useThumbnail from '../../../../../../../hooks/useThumbnail';
 import Button from '../../../../../../elements/Button';
 import { SwapUploadModal } from './SwapUploadModal';
-import './index.scss';
 import { EditModal } from './EditModal';
+import './index.scss';
 const baseClass = 'rich-text-upload';
 const initialParams = {
     depth: 0,

package/dist/admin/components/forms/field-types/Select/index.js

@@ -1,4 +1,4 @@
-import React, { useCallback, useState } from 'react';
+import React, { useCallback, useEffect, useState } from 'react';
 import withCondition from '../../withCondition';
 import useField from '../../useField';
 import { select } from '../../../../../fields/validations';
@@ -15,7 +15,10 @@ const formatOptions = (options) => options.map((option) => {
 const Select = (props) => {
     const { path: pathFromProps, name, required, validate = select, label, options: optionsFromProps, hasMany, admin: { readOnly, style, className, width, description, condition, } = {}, } = props;
     const path = pathFromProps || name;
-    const [options] = useState(formatOptions(optionsFromProps));
+    const [options, setOptions] = useState(formatOptions(optionsFromProps));
+    useEffect(() => {
+        setOptions(formatOptions(optionsFromProps));
+    }, [optionsFromProps]);
     const memoizedValidate = useCallback((value) => {
         const validationResult = validate(value, { required, options });
         return validationResult;

package/dist/admin/components/forms/field-types/Upload/SelectExisting/index.js

@@ -12,6 +12,7 @@ import formatFields from '../../../../views/collections/List/formatFields';
 import './index.scss';
 const baseClass = 'select-existing-upload-modal';
 const SelectExistingUploadModal = (props) => {
+    var _a, _b;
     const { setValue, collection, collection: { slug: collectionSlug, admin: { description, pagination: { defaultLimit, }, } = {}, } = {}, slug: modalSlug, } = props;
     const { serverURL, routes: { api } } = useConfig();
     const { closeAll, currentModal } = useModal();
@@ -67,6 +68,6 @@ const SelectExistingUploadModal = (props) => {
                     "of",
                     ' ',
                     data.totalDocs),
-                React.createElement(PerPage, { collection: collection, limit: limit, modifySearchParams: false, handleChange: setLimit }))))))));
+                React.createElement(PerPage, { limits: (_b = (_a = collection === null || collection === void 0 ? void 0 : collection.admin) === null || _a === void 0 ? void 0 : _a.pagination) === null || _b === void 0 ? void 0 : _b.limits, limit: limit, modifySearchParams: false, handleChange: setLimit }))))))));
 };
 export default SelectExistingUploadModal;

package/dist/admin/components/utilities/DocumentInfo/index.d.ts

@@ -1,17 +1,6 @@
 import React from 'react';
-declare type CollectionDoc = {
-    type: 'collection';
-    slug: string;
-    id?: string;
-};
-declare type GlobalDoc = {
-    type: 'global';
-    slug: string;
-};
-declare type ContextType = (CollectionDoc | GlobalDoc) & {
-    preferencesKey?: string;
-};
+import { ContextType, Props } from './types';
 declare const Context: React.Context<ContextType>;
-export declare const DocumentInfoProvider: React.FC<CollectionDoc | GlobalDoc>;
+export declare const DocumentInfoProvider: React.FC<Props>;
 export declare const useDocumentInfo: () => ContextType;
 export default Context;

package/dist/admin/components/utilities/DocumentInfo/index.js

@@ -1,27 +1,136 @@
-import React, { createContext, useContext, } from 'react';
+import React, { createContext, useCallback, useContext, useEffect, useState, } from 'react';
+import { useConfig } from '@payloadcms/config-provider';
+import qs from 'qs';
 const Context = createContext({});
-export const DocumentInfoProvider = (props) => {
-    const { children, type, slug } = props;
-    if (type === 'global') {
-        return (React.createElement(Context.Provider, { value: {
-                type,
-                slug: props.slug,
-                preferencesKey: `global-${slug}`,
-            } }, children));
+export const DocumentInfoProvider = ({ children, global, collection, id, }) => {
+    const { serverURL, routes: { api } } = useConfig();
+    const [publishedDoc, setPublishedDoc] = useState(null);
+    const [versions, setVersions] = useState(null);
+    const [unpublishedVersions, setUnpublishedVersions] = useState(null);
+    const baseURL = `${serverURL}${api}`;
+    let slug;
+    let type;
+    let preferencesKey;
+    if (global) {
+        slug = global.slug;
+        type = 'global';
+        preferencesKey = `global-${slug}`;
     }
-    if (type === 'collection') {
-        const { id } = props;
-        const value = {
-            type,
-            slug,
-        };
+    if (collection) {
+        slug = collection.slug;
+        type = 'collection';
         if (id) {
-            value.id = id;
-            value.preferencesKey = `collection-${slug}-${id}`;
+            preferencesKey = `collection-${slug}-${id}`;
         }
-        return (React.createElement(Context.Provider, { value: value }, children));
     }
-    return null;
+    const getVersions = useCallback(async () => {
+        var _a;
+        let versionFetchURL;
+        let publishedFetchURL;
+        let shouldFetchVersions = false;
+        let unpublishedVersionJSON = null;
+        let versionJSON = null;
+        let shouldFetch = true;
+        const versionParams = {
+            where: {
+                and: [],
+            },
+            depth: 0,
+        };
+        const publishedVersionParams = {
+            where: {
+                and: [
+                    {
+                        or: [
+                            {
+                                _status: {
+                                    equals: 'published',
+                                },
+                            },
+                            {
+                                _status: {
+                                    exists: false,
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+            depth: 0,
+        };
+        if (global) {
+            shouldFetchVersions = Boolean(global === null || global === void 0 ? void 0 : global.versions);
+            versionFetchURL = `${baseURL}/globals/${global.slug}/versions`;
+            publishedFetchURL = `${baseURL}/globals/${global.slug}?${qs.stringify(publishedVersionParams)}`;
+        }
+        if (collection) {
+            shouldFetchVersions = Boolean(collection === null || collection === void 0 ? void 0 : collection.versions);
+            versionFetchURL = `${baseURL}/${collection.slug}/versions`;
+            publishedVersionParams.where.and.push({
+                id: {
+                    equals: id,
+                },
+            });
+            publishedFetchURL = `${baseURL}/${collection.slug}?${qs.stringify(publishedVersionParams)}`;
+            if (!id) {
+                shouldFetch = false;
+            }
+            versionParams.where.and.push({
+                parent: {
+                    equals: id,
+                },
+            });
+        }
+        if (shouldFetch) {
+            let publishedJSON = await fetch(publishedFetchURL).then((res) => res.json());
+            if (collection) {
+                publishedJSON = (_a = publishedJSON === null || publishedJSON === void 0 ? void 0 : publishedJSON.docs) === null || _a === void 0 ? void 0 : _a[0];
+            }
+            if (shouldFetchVersions) {
+                versionJSON = await fetch(`${versionFetchURL}?${qs.stringify(versionParams)}`).then((res) => res.json());
+                if (publishedJSON === null || publishedJSON === void 0 ? void 0 : publishedJSON.updatedAt) {
+                    const newerVersionParams = {
+                        ...versionParams,
+                        where: {
+                            ...versionParams.where,
+                            and: [
+                                ...versionParams.where.and,
+                                {
+                                    updatedAt: {
+                                        greater_than: publishedJSON === null || publishedJSON === void 0 ? void 0 : publishedJSON.updatedAt,
+                                    },
+                                },
+                            ],
+                        },
+                    };
+                    // Get any newer versions available
+                    const newerVersionRes = await fetch(`${versionFetchURL}?${qs.stringify(newerVersionParams)}`);
+                    if (newerVersionRes.status === 200) {
+                        unpublishedVersionJSON = await newerVersionRes.json();
+                    }
+                }
+            }
+            setPublishedDoc(publishedJSON);
+            setVersions(versionJSON);
+            setUnpublishedVersions(unpublishedVersionJSON);
+        }
+    }, [global, collection, id, baseURL]);
+    useEffect(() => {
+        getVersions();
+    }, [getVersions]);
+    const value = {
+        slug,
+        type,
+        preferencesKey,
+        global,
+        collection,
+        versions,
+        unpublishedVersions,
+        getVersions,
+        publishedDoc,
+        id,
+    };
+    return (React.createElement(Context.Provider, { value: value }, children));
 };
 export const useDocumentInfo = () => useContext(Context);
 export default Context;

package/dist/admin/components/utilities/DocumentInfo/types.d.ts

@@ -0,0 +1,23 @@
+import { SanitizedCollectionConfig, TypeWithID, TypeWithTimestamps } from '../../../../collections/config/types';
+import { SanitizedGlobalConfig } from '../../../../globals/config/types';
+import { PaginatedDocs } from '../../../../mongoose/types';
+import { TypeWithVersion } from '../../../../versions/types';
+export declare type Version = TypeWithVersion<any>;
+export declare type ContextType = {
+    collection?: SanitizedCollectionConfig;
+    global?: SanitizedGlobalConfig;
+    type: 'global' | 'collection';
+    id?: string | number;
+    preferencesKey?: string;
+    versions?: PaginatedDocs<Version>;
+    unpublishedVersions?: PaginatedDocs<Version>;
+    publishedDoc?: TypeWithID & TypeWithTimestamps & {
+        _status?: string;
+    };
+    getVersions: () => Promise<void>;
+};
+export declare type Props = {
+    collection?: SanitizedCollectionConfig;
+    global?: SanitizedGlobalConfig;
+    id?: string | number;
+};

package/dist/admin/components/utilities/DocumentInfo/types.js

@@ -0,0 +1 @@
+export {};