@strapi/content-manager 0.0.0-experimental.e0df4d50334a17a1beb3d203bff414fbbff62f7b → 0.0.0-experimental.e12978dcee698470990e9c5c63384faf2c307443

package/dist/admin/chunks/{Input-BexkC_pp.mjs → Input-BHucdqva.mjs}

@@ -1,11 +1,11 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import * as React from 'react';
-import { useState, useEffect, useCallback, memo } from 'react';
-import { useStrapiApp, useElementOnScreen, createContext, useField, useForm, useNotification, useAPIErrorHandler, useQueryParams, useFocusInputField, InputRenderer as InputRenderer$1 } from '@strapi/admin/strapi-admin';
-import { Box, SingleSelect, SingleSelectOption, Typography, Flex, Button, Popover, Field, Menu, IconButton, Tooltip, useComposedRefs, Portal, FocusTrap, Divider, VisuallyHidden, Accordion, MenuItem, Grid as Grid$1, TextInput, IconButtonGroup, TextButton } from '@strapi/design-system';
-import { CodeBlock as CodeBlock$1, HeadingOne, HeadingTwo, HeadingThree, HeadingFour, HeadingFive, HeadingSix, Image as Image$1, NumberList, BulletList, Paragraph, Quotes, More, Link as Link$1, Drag, Collapse, Bold, Italic, Underline, StrikeThrough, Code, Expand, PlusCircle, Trash, EyeStriked, CheckCircle, WarningCircle, Loader, ArrowClockwise, Plus } from '@strapi/icons';
+import { useState, useEffect, useCallback } from 'react';
+import { useStrapiApp, useElementOnScreen, createContext, useField, useForm, useNotification, useRBAC, Form, DescriptionComponentRenderer, useQueryParams, useFocusInputField, useAPIErrorHandler, InputRenderer as InputRenderer$1 } from '@strapi/admin/strapi-admin';
+import { Box, SingleSelect, SingleSelectOption, Typography, Flex, Button, Popover, Field, Menu, IconButton, Tooltip, useComposedRefs, Portal, FocusTrap, Divider, VisuallyHidden, Accordion, MenuItem, Grid as Grid$1, TextInput, Modal, Loader, EmptyStateLayout, TextButton, Link as Link$2, Combobox, ComboboxOption, IconButtonGroup } from '@strapi/design-system';
+import { CodeBlock as CodeBlock$1, HeadingOne, HeadingTwo, HeadingThree, HeadingFour, HeadingFive, HeadingSix, Image as Image$1, NumberList, BulletList, Paragraph, Quotes, More, Link as Link$1, Drag, Collapse, Bold, Italic, Underline, StrikeThrough, Code, Expand, PlusCircle, Trash, EyeStriked, ArrowLeft, WarningCircle, ArrowClockwise, Cross, CheckCircle, Loader as Loader$1, Plus } from '@strapi/icons';
 import { useIntl } from 'react-intl';
-import { g as getTranslation, m as useDocLayout, c as useDoc, n as createDefaultForm, t as transformDocument, e as contentManagerApi, o as CLONE_PATH, d as buildValidParams, f as useDocumentRBAC, S as SINGLE_TYPES } from './index-Cs6qwFQu.mjs';
+import { g as getTranslation, c as useDocumentContext, d as useDocumentLayout, e as createDefaultForm, t as transformDocument, P as PERMISSIONS, f as DocumentRBAC, h as createYupSchema, i as DocumentActionButton, D as DocumentStatus, C as COLLECTION_TYPES, S as SINGLE_TYPES, j as buildValidParams, k as useLazyGetDocumentQuery, l as contentManagerApi, m as useDoc, n as CLONE_PATH, o as useDocumentRBAC, p as useDocLayout } from './index-DYrCidCq.mjs';
 import { styled, css, keyframes } from 'styled-components';
 import { Editor as Editor$1, Transforms, Node, Element, Range, Path, Point, createEditor } from 'slate';
 import { withHistory } from 'slate-history';
@@ -61,16 +61,15 @@ import 'prismjs/components/prism-typescript';
 import 'prismjs/components/prism-tsx';
 import 'prismjs/components/prism-vbnet';
 import 'prismjs/components/prism-yaml';
-import { p as prefixFileUrlWithBackendUrl, u as usePrev } from './usePrev-Bjw2dhmq.mjs';
-import { a as DIRECTIONS, u as useDragAndDrop, I as ItemTypes } from './useDragAndDrop-HYwNDExe.mjs';
+import { p as prefixFileUrlWithBackendUrl, u as useGetRelationsQuery, g as getRelationLabel, a as useDebounce, b as useLazySearchRelationsQuery, c as usePrev } from './usePrev-DinC2aha.mjs';
+import { D as DIRECTIONS, u as useDragAndDrop, I as ItemTypes, g as getIn, a as DROP_SENSITIVITY } from './objects-D2z-IJgu.mjs';
 import * as Toolbar from '@radix-ui/react-toolbar';
 import { getEmptyImage } from 'react-dnd-html5-backend';
 import { useMatch, useLocation } from 'react-router-dom';
-import { g as getIn } from './objects-wl73iEma.mjs';
-import { u as useComponent, C as ComponentProvider, M as MemoizedUnstableRelationsField, a as MemoizedRelationsField } from './Relations-qeZyLDgQ.mjs';
 import pipe$1 from 'lodash/fp/pipe';
 import { C as ComponentIcon, a as COMPONENT_ICONS } from './ComponentIcon-BZcTc4rj.mjs';
-import { a as useDebounce } from './relations-Cq8NRUto.mjs';
+import { generateNKeysBetween } from 'fractional-indexing';
+import { FixedSizeList } from 'react-window';
 import CodeMirror from 'codemirror5';
 import sanitizeHtml from 'sanitize-html';
 import { getLanguage, highlight, highlightAuto } from 'highlight.js';
@@ -3463,6 +3462,20 @@ const Initializer = ({ disabled, name, onClick })=>{
     });
 };
 
+/**
+ * We use this component to wrap any individual component field in the Edit View,
+ * this could be a component field in a dynamic zone, a component within a repeatable space,
+ * or even nested components.
+ *
+ * We primarily need this to provide the component id to the components so that they can
+ * correctly fetch their relations.
+ */ const [ComponentProvider, useComponent] = createContext('ComponentContext', {
+    id: undefined,
+    level: -1,
+    uid: undefined,
+    type: undefined
+});
+
 const AddComponentButton = ({ hasError, isDisabled, isOpen, children, onClick })=>{
     return /*#__PURE__*/ jsx(StyledButton, {
         type: "button",
@@ -3641,7 +3654,8 @@ const ComponentPicker = ({ dynamicComponentsByCategory = {}, isOpen, onClickAddC
 const DynamicComponent = ({ componentUid, disabled, index, name, onRemoveComponentClick, onMoveComponent, onGrabItem, onDropItem, onCancel, dynamicComponentsByCategory = {}, onAddComponent, children })=>{
     const { formatMessage } = useIntl();
     const formValues = useForm('DynamicComponent', (state)=>state.values);
-    const { edit: { components } } = useDocLayout();
+    const documentMeta = useDocumentContext('DynamicComponent', (state)=>state.meta);
+    const { edit: { components } } = useDocumentLayout(documentMeta.model);
     const title = React.useMemo(()=>{
         const { mainField } = components[componentUid]?.settings ?? {
             mainField: 'id'
@@ -3993,7 +4007,8 @@ const DynamicZone = ({ attribute, disabled: disabledProp, hint, label, labelActi
     const { max = Infinity, min = -Infinity } = attribute ?? {};
     const [addComponentIsOpen, setAddComponentIsOpen] = React.useState(false);
     const [liveText, setLiveText] = React.useState('');
-    const { components, isLoading } = useDoc();
+    const document = useDocumentContext('DynamicZone', (state)=>state.document);
+    const { components, isLoading } = document;
     const disabled = disabledProp || isLoading;
     const { addFieldRow, removeFieldRow, moveFieldRow } = useForm('DynamicZone', ({ addFieldRow, removeFieldRow, moveFieldRow })=>({
             addFieldRow,
@@ -4226,6 +4241,1055 @@ const NotAllowedInput = ({ hint, label, required, name })=>{
     });
 };
 
+function getCollectionType(url) {
+    const regex = new RegExp(`(${COLLECTION_TYPES}|${SINGLE_TYPES})`);
+    const match = url.match(regex);
+    return match ? match[1] : undefined;
+}
+const CustomModalContent = styled(Modal.Content)`
+  width: 90%;
+  max-width: 100%;
+  height: 90%;
+  max-height: 100%;
+`;
+const RelationModal = ({ open, onToggle })=>{
+    const { formatMessage } = useIntl();
+    return /*#__PURE__*/ jsx(Modal.Root, {
+        open: open,
+        onOpenChange: onToggle,
+        children: /*#__PURE__*/ jsxs(CustomModalContent, {
+            children: [
+                /*#__PURE__*/ jsx(Modal.Header, {
+                    gap: 2,
+                    children: /*#__PURE__*/ jsx(Flex, {
+                        justifyContent: "space-between",
+                        alignItems: "center",
+                        width: "100%",
+                        children: /*#__PURE__*/ jsxs(Flex, {
+                            gap: 2,
+                            children: [
+                                /*#__PURE__*/ jsx(IconButton, {
+                                    withTooltip: false,
+                                    label: "Back",
+                                    variant: "ghost",
+                                    disabled: true,
+                                    onClick: ()=>{},
+                                    marginRight: 1,
+                                    children: /*#__PURE__*/ jsx(ArrowLeft, {})
+                                }),
+                                /*#__PURE__*/ jsx(Typography, {
+                                    tag: "span",
+                                    fontWeight: 600,
+                                    children: formatMessage({
+                                        id: 'content-manager.components.RelationInputModal.modal-title',
+                                        defaultMessage: 'Edit a relation'
+                                    })
+                                })
+                            ]
+                        })
+                    })
+                }),
+                /*#__PURE__*/ jsx(RelationModalBody, {}),
+                /*#__PURE__*/ jsx(Modal.Footer, {
+                    children: /*#__PURE__*/ jsx(Button, {
+                        onClick: onToggle,
+                        variant: "tertiary",
+                        children: formatMessage({
+                            id: 'app.components.Button.cancel',
+                            defaultMessage: 'Cancel'
+                        })
+                    })
+                })
+            ]
+        })
+    });
+};
+const RelationModalBody = ()=>{
+    const { formatMessage } = useIntl();
+    const documentMeta = useDocumentContext('RelationModalBody', (state)=>state.meta);
+    const documentResponse = useDocumentContext('RelationModalBody', (state)=>state.document);
+    const documentLayoutResponse = useDocumentLayout(documentMeta.model);
+    const plugins = useStrapiApp('RelationModalBody', (state)=>state.plugins);
+    const initialValues = documentResponse.getInitialFormValues();
+    const { permissions = [], isLoading: isLoadingPermissions, error } = useRBAC(PERMISSIONS.map((action)=>({
+            action,
+            subject: documentMeta.model
+        })));
+    const isLoading = isLoadingPermissions || documentLayoutResponse.isLoading || documentResponse.isLoading;
+    if (isLoading && !documentResponse.document?.documentId) {
+        return /*#__PURE__*/ jsx(Loader, {
+            small: true,
+            children: formatMessage({
+                id: 'content-manager.ListViewTable.relation-loading',
+                defaultMessage: 'Relations are loading'
+            })
+        });
+    }
+    if (error || !documentMeta.model || documentLayoutResponse.error || !documentResponse.document || !documentResponse.meta || !documentResponse.schema || !initialValues) {
+        return /*#__PURE__*/ jsx(Flex, {
+            alignItems: "center",
+            height: "100%",
+            justifyContent: "center",
+            children: /*#__PURE__*/ jsx(EmptyStateLayout, {
+                icon: /*#__PURE__*/ jsx(WarningCircle, {
+                    width: "16rem"
+                }),
+                content: formatMessage({
+                    id: 'anErrorOccurred',
+                    defaultMessage: 'Whoops! Something went wrong. Please, try again.'
+                })
+            })
+        });
+    }
+    const documentTitle = documentResponse.getTitle(documentLayoutResponse.edit.settings.mainField);
+    const hasDraftAndPublished = documentResponse.schema?.options?.draftAndPublish ?? false;
+    const props = {
+        activeTab: 'draft',
+        collectionType: documentMeta.collectionType,
+        model: documentMeta.model,
+        documentId: documentMeta.documentId,
+        document: documentResponse.document,
+        meta: documentResponse.meta
+    };
+    return /*#__PURE__*/ jsx(Modal.Body, {
+        children: /*#__PURE__*/ jsx(DocumentRBAC, {
+            permissions: permissions,
+            model: documentMeta.model,
+            children: /*#__PURE__*/ jsxs(Form, {
+                initialValues: initialValues,
+                validate: (values, options)=>{
+                    const yupSchema = createYupSchema(documentResponse.schema?.attributes, documentResponse.components, {
+                        status: documentResponse.document?.status,
+                        ...options
+                    });
+                    return yupSchema.validate(values, {
+                        abortEarly: false
+                    });
+                },
+                method: "PUT",
+                children: [
+                    /*#__PURE__*/ jsxs(Flex, {
+                        alignItems: "flex-start",
+                        direction: "column",
+                        gap: 2,
+                        children: [
+                            /*#__PURE__*/ jsxs(Flex, {
+                                width: "100%",
+                                justifyContent: "space-between",
+                                gap: 2,
+                                children: [
+                                    /*#__PURE__*/ jsx(Typography, {
+                                        tag: "h2",
+                                        variant: "alpha",
+                                        children: documentTitle
+                                    }),
+                                    /*#__PURE__*/ jsx(Flex, {
+                                        gap: 2,
+                                        children: /*#__PURE__*/ jsx(DescriptionComponentRenderer, {
+                                            props: props,
+                                            descriptions: plugins['content-manager'].apis.getDocumentActions('relation-modal'),
+                                            children: (actions)=>{
+                                                const filteredActions = actions.filter((action)=>{
+                                                    return [
+                                                        action.position
+                                                    ].flat().includes('relation-modal');
+                                                });
+                                                const [primaryAction, secondaryAction] = filteredActions;
+                                                if (!primaryAction && !secondaryAction) return null;
+                                                // Both actions are available when draft and publish enabled
+                                                if (primaryAction && secondaryAction) {
+                                                    return /*#__PURE__*/ jsxs(Fragment, {
+                                                        children: [
+                                                            /*#__PURE__*/ jsx(DocumentActionButton, {
+                                                                ...secondaryAction,
+                                                                variant: secondaryAction.variant || 'secondary'
+                                                            }),
+                                                            /*#__PURE__*/ jsx(DocumentActionButton, {
+                                                                ...primaryAction,
+                                                                variant: primaryAction.variant || 'default'
+                                                            })
+                                                        ]
+                                                    });
+                                                }
+                                                // Otherwise we just have the save action
+                                                return /*#__PURE__*/ jsx(DocumentActionButton, {
+                                                    ...primaryAction,
+                                                    variant: primaryAction.variant || 'secondary'
+                                                });
+                                            }
+                                        })
+                                    })
+                                ]
+                            }),
+                            hasDraftAndPublished ? /*#__PURE__*/ jsx(Box, {
+                                children: /*#__PURE__*/ jsx(DocumentStatus, {
+                                    status: documentResponse.document?.status
+                                })
+                            }) : null
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(Flex, {
+                        flex: 1,
+                        overflow: "auto",
+                        alignItems: "stretch",
+                        paddingTop: 7,
+                        children: /*#__PURE__*/ jsx(Box, {
+                            overflow: "auto",
+                            flex: 1,
+                            children: /*#__PURE__*/ jsx(FormLayout, {
+                                layout: documentLayoutResponse.edit.layout,
+                                hasBackground: false
+                            })
+                        })
+                    })
+                ]
+            })
+        })
+    });
+};
+
+/**
+ * Remove a relation, whether it's been already saved or not.
+ * It's used both in RelationsList, where the "remove relation" button is, and in the input,
+ * because we sometimes need to remove a previous relation when selecting a new one.
+ */ function useHandleDisconnect(fieldName, consumerName) {
+    const field = useField(fieldName);
+    const removeFieldRow = useForm(consumerName, (state)=>state.removeFieldRow);
+    const addFieldRow = useForm(consumerName, (state)=>state.addFieldRow);
+    const handleDisconnect = (relation)=>{
+        if (field.value && field.value.connect) {
+            /**
+       * A relation will exist in the `connect` array _if_ it has
+       * been added without saving. In this case, we just remove it
+       * from the connect array
+       */ const indexOfRelationInConnectArray = field.value.connect.findIndex((rel)=>rel.id === relation.id);
+            if (indexOfRelationInConnectArray >= 0) {
+                removeFieldRow(`${fieldName}.connect`, indexOfRelationInConnectArray);
+                return;
+            }
+        }
+        addFieldRow(`${fieldName}.disconnect`, {
+            id: relation.id,
+            apiData: {
+                id: relation.id,
+                documentId: relation.documentId,
+                locale: relation.locale
+            }
+        });
+    };
+    return handleDisconnect;
+}
+/* -------------------------------------------------------------------------------------------------
+ * RelationsField
+ * -----------------------------------------------------------------------------------------------*/ const RELATIONS_TO_DISPLAY = 5;
+const ONE_WAY_RELATIONS = [
+    'oneWay',
+    'oneToOne',
+    'manyToOne',
+    'oneToManyMorph',
+    'oneToOneMorph'
+];
+/**
+ * TODO: we get a rather ugly flash when we remove a single relation from the list leaving
+ * no other relations when we press save. The initial relation re-renders, probably because
+ * of the lag in the Form cleaning it's "disconnect" array, whilst our data has not been invalidated.
+ *
+ * Could we invalidate relation data on the document actions? Should we?
+ */ /**
+ * @internal
+ * @description The relations field holds a lot of domain logic for handling relations which is rather complicated
+ * At present we do not expose this to plugin developers, however, they are able to overwrite it themselves should
+ * they wish to do so.
+ */ const RelationsField = /*#__PURE__*/ React.forwardRef(({ disabled, label, ...props }, ref)=>{
+    const documentMeta = useDocumentContext('RelationsField', (state)=>state.meta);
+    const documentResponse = useDocumentContext('RelationsField', (state)=>state.document);
+    const [currentPage, setCurrentPage] = React.useState(1);
+    const documentId = documentResponse.document?.documentId;
+    const { formatMessage } = useIntl();
+    const [{ query }] = useQueryParams();
+    const params = buildValidParams(query);
+    const isMorph = props.attribute.relation.toLowerCase().includes('morph');
+    const isDisabled = isMorph || disabled;
+    const { componentId, componentUID } = useComponent('RelationsField', ({ uid, id })=>({
+            componentId: id,
+            componentUID: uid
+        }));
+    const isSubmitting = useForm('RelationsList', (state)=>state.isSubmitting);
+    React.useEffect(()=>{
+        setCurrentPage(1);
+    }, [
+        isSubmitting
+    ]);
+    /**
+     * We'll always have a documentId in a created entry, so we look for a componentId first.
+     * Same with `uid` and `documentModel`.
+     */ const id = componentId ? componentId.toString() : documentId;
+    const model = componentUID ?? documentMeta.model;
+    /**
+     * The `name` prop is a complete path to the field, e.g. `field1.field2.field3`.
+     * Where the above example would a nested field within two components, however
+     * we only require the field on the component not the complete path since we query
+     * individual components. Therefore we split the string and take the last item.
+     */ const [targetField] = props.name.split('.').slice(-1);
+    const { data, isLoading, isFetching } = useGetRelationsQuery({
+        model,
+        targetField,
+        // below we don't run the query if there is no id.
+        id,
+        params: {
+            ...params,
+            pageSize: RELATIONS_TO_DISPLAY,
+            page: currentPage
+        }
+    }, {
+        refetchOnMountOrArgChange: true,
+        skip: !id,
+        selectFromResult: (result)=>{
+            return {
+                ...result,
+                data: {
+                    ...result.data,
+                    results: result.data?.results ? result.data.results : []
+                }
+            };
+        }
+    });
+    const handleLoadMore = ()=>{
+        setCurrentPage((prev)=>prev + 1);
+    };
+    const field = useField(props.name);
+    const isFetchingMoreRelations = isLoading || isFetching;
+    const realServerRelationsCount = 'pagination' in data && data.pagination ? data.pagination.total : 0;
+    /**
+     * Items that are already connected, but reordered would be in
+     * this list, so to get an accurate figure, we remove them.
+     */ const relationsConnected = (field.value?.connect ?? []).filter((rel)=>data.results.findIndex((relation)=>relation.id === rel.id) === -1).length ?? 0;
+    const relationsDisconnected = field.value?.disconnect?.length ?? 0;
+    const relationsCount = realServerRelationsCount + relationsConnected - relationsDisconnected;
+    /**
+     * This is it, the source of truth for reordering in conjunction with partial loading & updating
+     * of relations. Relations on load are given __temp_key__ when fetched, because we don't want to
+     * create brand new keys everytime the data updates, just keep adding them onto the newly loaded ones.
+     */ const relations = React.useMemo(()=>{
+        const ctx = {
+            field: field.value,
+            // @ts-expect-error – targetModel does exist on the attribute. But it's not typed.
+            href: `../${COLLECTION_TYPES}/${props.attribute.targetModel}`,
+            mainField: props.mainField
+        };
+        /**
+       * Tidy up our data.
+       */ const transformations = pipe$1(removeConnected(ctx), removeDisconnected(ctx), addLabelAndHref(ctx));
+        const transformedRels = transformations([
+            ...data.results
+        ]);
+        /**
+       * THIS IS CRUCIAL. If you don't sort by the __temp_key__ which comes from fractional indexing
+       * then the list will be in the wrong order.
+       */ return [
+            ...transformedRels,
+            ...field.value?.connect ?? []
+        ].sort((a, b)=>{
+            if (a.__temp_key__ < b.__temp_key__) return -1;
+            if (a.__temp_key__ > b.__temp_key__) return 1;
+            return 0;
+        });
+    }, [
+        data.results,
+        field.value,
+        // @ts-expect-error – targetModel does exist on the attribute. But it's not typed.
+        props.attribute.targetModel,
+        props.mainField
+    ]);
+    const handleDisconnect = useHandleDisconnect(props.name, 'RelationsField');
+    const handleConnect = (relation)=>{
+        const [lastItemInList] = relations.slice(-1);
+        const item = {
+            id: relation.id,
+            apiData: {
+                id: relation.id,
+                documentId: relation.documentId,
+                locale: relation.locale
+            },
+            status: relation.status,
+            /**
+         * If there's a last item, that's the first key we use to generate out next one.
+         */ __temp_key__: generateNKeysBetween(lastItemInList?.__temp_key__ ?? null, null, 1)[0],
+            // Fallback to `id` if there is no `mainField` value, which will overwrite the above `id` property with the exact same data.
+            [props.mainField?.name ?? 'documentId']: relation[props.mainField?.name ?? 'documentId'],
+            label: getRelationLabel(relation, props.mainField),
+            // @ts-expect-error – targetModel does exist on the attribute, but it's not typed.
+            href: `../${COLLECTION_TYPES}/${props.attribute.targetModel}/${relation.documentId}?${relation.locale ? `plugins[i18n][locale]=${relation.locale}` : ''}`
+        };
+        if (ONE_WAY_RELATIONS.includes(props.attribute.relation)) {
+            // Remove any existing relation so they can be replaced with the new one
+            field.value?.connect?.forEach(handleDisconnect);
+            relations.forEach(handleDisconnect);
+            field.onChange(`${props.name}.connect`, [
+                item
+            ]);
+        } else {
+            field.onChange(`${props.name}.connect`, [
+                ...field.value?.connect ?? [],
+                item
+            ]);
+        }
+    };
+    return /*#__PURE__*/ jsxs(Flex, {
+        ref: ref,
+        direction: "column",
+        gap: 3,
+        justifyContent: "space-between",
+        alignItems: "stretch",
+        wrap: "wrap",
+        children: [
+            /*#__PURE__*/ jsxs(StyledFlex, {
+                direction: "column",
+                alignItems: "start",
+                gap: 2,
+                width: "100%",
+                children: [
+                    /*#__PURE__*/ jsx(RelationsInput, {
+                        disabled: isDisabled,
+                        // NOTE: we should not default to using the documentId if the component is being created (componentUID is undefined)
+                        id: componentUID ? componentId ? `${componentId}` : '' : documentId,
+                        label: `${label} ${relationsCount > 0 ? `(${relationsCount})` : ''}`,
+                        model: model,
+                        onChange: handleConnect,
+                        ...props
+                    }),
+                    'pagination' in data && data.pagination && data.pagination.pageCount > data.pagination.page ? /*#__PURE__*/ jsx(TextButton, {
+                        disabled: isFetchingMoreRelations,
+                        onClick: handleLoadMore,
+                        loading: isFetchingMoreRelations,
+                        startIcon: /*#__PURE__*/ jsx(ArrowClockwise, {}),
+                        // prevent the label from line-wrapping
+                        shrink: 0,
+                        children: formatMessage({
+                            id: getTranslation('relation.loadMore'),
+                            defaultMessage: 'Load More'
+                        })
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ jsx(RelationsList, {
+                data: relations,
+                serverData: data.results,
+                disabled: isDisabled,
+                name: props.name,
+                isLoading: isFetchingMoreRelations,
+                relationType: props.attribute.relation,
+                // @ts-expect-error – targetModel does exist on the attribute. But it's not typed.
+                targetModel: props.attribute.targetModel
+            })
+        ]
+    });
+});
+/**
+ * TODO: this can be removed once we stop shipping Inputs with
+ * labels wrapped round in DS@2.
+ */ const StyledFlex = styled(Flex)`
+  & > div {
+    width: 100%;
+  }
+`;
+/**
+ * If it's in the connected array, it can get out of our data array,
+ * we'll be putting it back in later and sorting it anyway.
+ */ const removeConnected = ({ field })=>(relations)=>{
+        return relations.filter((relation)=>{
+            const connectedRelations = field?.connect ?? [];
+            return connectedRelations.findIndex((rel)=>rel.id === relation.id) === -1;
+        });
+    };
+/**
+ * @description Removes relations that are in the `disconnect` array of the field
+ */ const removeDisconnected = ({ field })=>(relations)=>relations.filter((relation)=>{
+            const disconnectedRelations = field?.disconnect ?? [];
+            return disconnectedRelations.findIndex((rel)=>rel.id === relation.id) === -1;
+        });
+/**
+ * @description Adds a label and href to the relation object we use this to render
+ * a better UI where we can link to the relation and display a human-readable label.
+ */ const addLabelAndHref = ({ mainField, href })=>(relations)=>relations.map((relation)=>{
+            return {
+                ...relation,
+                // Fallback to `id` if there is no `mainField` value, which will overwrite the above `documentId` property with the exact same data.
+                [mainField?.name ?? 'documentId']: relation[mainField?.name ?? 'documentId'],
+                label: getRelationLabel(relation, mainField),
+                href: `${href}/${relation.documentId}?${relation.locale ? `plugins[i18n][locale]=${relation.locale}` : ''}`
+            };
+        });
+/**
+ * @description Contains all the logic for the combobox that can search
+ * for relations and then add them to the field's connect array.
+ */ const RelationsInput = ({ hint, id, model, label, labelAction, name, mainField, placeholder, required, unique: _unique, 'aria-label': _ariaLabel, onChange, ...props })=>{
+    const [textValue, setTextValue] = React.useState('');
+    const [searchParams, setSearchParams] = React.useState({
+        _q: '',
+        page: 1
+    });
+    const { toggleNotification } = useNotification();
+    const [{ query }] = useQueryParams();
+    const { formatMessage } = useIntl();
+    const fieldRef = useFocusInputField(name);
+    const field = useField(name);
+    const searchParamsDebounced = useDebounce(searchParams, 300);
+    const [searchForTrigger, { data, isLoading }] = useLazySearchRelationsQuery();
+    /**
+   * Because we're using a lazy query, we need to trigger the search
+   * when the component mounts and when the search params change.
+   * We also need to trigger the search when the field value changes
+   * so that we can filter out the relations that are already connected.
+   */ React.useEffect(()=>{
+        /**
+     * The `name` prop is a complete path to the field, e.g. `field1.field2.field3`.
+     * Where the above example would a nested field within two components, however
+     * we only require the field on the component not the complete path since we query
+     * individual components. Therefore we split the string and take the last item.
+     */ const [targetField] = name.split('.').slice(-1);
+        searchForTrigger({
+            model,
+            targetField,
+            params: {
+                ...buildValidParams(query),
+                id: id ?? '',
+                pageSize: 10,
+                idsToInclude: field.value?.disconnect?.map((rel)=>rel.id.toString()) ?? [],
+                idsToOmit: field.value?.connect?.map((rel)=>rel.id.toString()) ?? [],
+                ...searchParamsDebounced
+            }
+        });
+    }, [
+        field.value?.connect,
+        field.value?.disconnect,
+        id,
+        model,
+        name,
+        query,
+        searchForTrigger,
+        searchParamsDebounced
+    ]);
+    const handleSearch = async (search)=>{
+        setSearchParams((s)=>({
+                ...s,
+                _q: search,
+                page: 1
+            }));
+    };
+    const hasNextPage = data?.pagination ? data.pagination.page < data.pagination.pageCount : false;
+    const options = data?.results ?? [];
+    const handleChange = (relationId)=>{
+        if (!relationId) {
+            return;
+        }
+        const relation = options.find((opt)=>opt.id.toString() === relationId);
+        if (!relation) {
+            // This is very unlikely to happen, but it ensures we don't have any data for.
+            console.error("You've tried to add a relation with an id that does not exist in the options you can see, this is likely a bug with Strapi. Please open an issue.");
+            toggleNotification({
+                message: formatMessage({
+                    id: getTranslation('relation.error-adding-relation'),
+                    defaultMessage: 'An error occurred while trying to add the relation.'
+                }),
+                type: 'danger'
+            });
+            return;
+        }
+        /**
+     * You need to give this relation a correct _temp_key_ but
+     * this component doesn't know about those ones, you can't rely
+     * on the connect array because that doesn't hold items that haven't
+     * moved. So use a callback to fill in the gaps when connecting.
+     *
+     */ onChange(relation);
+    };
+    const handleLoadMore = ()=>{
+        if (!data || !data.pagination) {
+            return;
+        } else if (data.pagination.page < data.pagination.pageCount) {
+            setSearchParams((s)=>({
+                    ...s,
+                    page: s.page + 1
+                }));
+        }
+    };
+    React.useLayoutEffect(()=>{
+        setTextValue('');
+    }, [
+        field.value
+    ]);
+    return /*#__PURE__*/ jsxs(Field.Root, {
+        error: field.error,
+        hint: hint,
+        name: name,
+        required: required,
+        children: [
+            /*#__PURE__*/ jsx(Field.Label, {
+                action: labelAction,
+                children: label
+            }),
+            /*#__PURE__*/ jsx(Combobox, {
+                ref: fieldRef,
+                name: name,
+                autocomplete: "list",
+                placeholder: placeholder || formatMessage({
+                    id: getTranslation('relation.add'),
+                    defaultMessage: 'Add relation'
+                }),
+                hasMoreItems: hasNextPage,
+                loading: isLoading,
+                onOpenChange: ()=>{
+                    handleSearch(textValue ?? '');
+                },
+                noOptionsMessage: ()=>formatMessage({
+                        id: getTranslation('relation.notAvailable'),
+                        defaultMessage: 'No relations available'
+                    }),
+                loadingMessage: formatMessage({
+                    id: getTranslation('relation.isLoading'),
+                    defaultMessage: 'Relations are loading'
+                }),
+                onLoadMore: handleLoadMore,
+                textValue: textValue,
+                onChange: handleChange,
+                onTextValueChange: (text)=>{
+                    setTextValue(text);
+                },
+                onInputChange: (event)=>{
+                    handleSearch(event.currentTarget.value);
+                },
+                ...props,
+                children: options.map((opt)=>{
+                    const textValue = getRelationLabel(opt, mainField);
+                    return /*#__PURE__*/ jsx(ComboboxOption, {
+                        value: opt.id.toString(),
+                        textValue: textValue,
+                        children: /*#__PURE__*/ jsxs(Flex, {
+                            gap: 2,
+                            justifyContent: "space-between",
+                            children: [
+                                /*#__PURE__*/ jsx(Typography, {
+                                    ellipsis: true,
+                                    children: textValue
+                                }),
+                                opt.status ? /*#__PURE__*/ jsx(DocumentStatus, {
+                                    status: opt.status
+                                }) : null
+                            ]
+                        })
+                    }, opt.id);
+                })
+            }),
+            /*#__PURE__*/ jsx(Field.Error, {}),
+            /*#__PURE__*/ jsx(Field.Hint, {})
+        ]
+    });
+};
+/* -------------------------------------------------------------------------------------------------
+ * RelationsList
+ * -----------------------------------------------------------------------------------------------*/ const RELATION_ITEM_HEIGHT = 50;
+const RELATION_GUTTER = 4;
+const RelationsList = ({ data, serverData, disabled, name, isLoading, relationType, targetModel })=>{
+    const ariaDescriptionId = React.useId();
+    const { formatMessage } = useIntl();
+    const listRef = React.useRef(null);
+    const outerListRef = React.useRef(null);
+    const [overflow, setOverflow] = React.useState();
+    const [liveText, setLiveText] = React.useState('');
+    const field = useField(name);
+    React.useEffect(()=>{
+        if (data.length <= RELATIONS_TO_DISPLAY) {
+            return setOverflow(undefined);
+        }
+        const handleNativeScroll = (e)=>{
+            const el = e.target;
+            const parentScrollContainerHeight = el.parentNode.scrollHeight;
+            const maxScrollBottom = el.scrollHeight - el.scrollTop;
+            if (el.scrollTop === 0) {
+                return setOverflow('bottom');
+            }
+            if (maxScrollBottom === parentScrollContainerHeight) {
+                return setOverflow('top');
+            }
+            return setOverflow('top-bottom');
+        };
+        const outerListRefCurrent = outerListRef?.current;
+        if (!isLoading && data.length > 0 && outerListRefCurrent) {
+            outerListRef.current.addEventListener('scroll', handleNativeScroll);
+        }
+        return ()=>{
+            if (outerListRefCurrent) {
+                outerListRefCurrent.removeEventListener('scroll', handleNativeScroll);
+            }
+        };
+    }, [
+        isLoading,
+        data.length
+    ]);
+    const getItemPos = (index)=>`${index + 1} of ${data.length}`;
+    const handleMoveItem = (newIndex, oldIndex)=>{
+        const item = data[oldIndex];
+        setLiveText(formatMessage({
+            id: getTranslation('dnd.reorder'),
+            defaultMessage: '{item}, moved. New position in list: {position}.'
+        }, {
+            item: item.label ?? item.documentId,
+            position: getItemPos(newIndex)
+        }));
+        /**
+     * Splicing mutates the array, so we need to create a new array
+     */ const newData = [
+            ...data
+        ];
+        const currentRow = data[oldIndex];
+        const startKey = oldIndex > newIndex ? newData[newIndex - 1]?.__temp_key__ : newData[newIndex]?.__temp_key__;
+        const endKey = oldIndex > newIndex ? newData[newIndex]?.__temp_key__ : newData[newIndex + 1]?.__temp_key__;
+        /**
+     * We're moving the relation between two other relations, so
+     * we need to generate a new key that keeps the order
+     */ const [newKey] = generateNKeysBetween(startKey, endKey, 1);
+        newData.splice(oldIndex, 1);
+        newData.splice(newIndex, 0, {
+            ...currentRow,
+            __temp_key__: newKey
+        });
+        /**
+     * Now we diff against the server to understand what's different so we
+     * can keep the connect array nice and tidy. It also needs reversing because
+     * we reverse the relations from the server in the first place.
+     */ const connectedRelations = newData.reduce((acc, relation, currentIndex, array)=>{
+            const relationOnServer = serverData.find((oldRelation)=>oldRelation.id === relation.id);
+            const relationInFront = array[currentIndex + 1];
+            if (!relationOnServer || relationOnServer.__temp_key__ !== relation.__temp_key__) {
+                const position = relationInFront ? {
+                    before: relationInFront.documentId,
+                    locale: relationInFront.locale,
+                    status: 'publishedAt' in relationInFront && relationInFront.publishedAt ? 'published' : 'draft'
+                } : {
+                    end: true
+                };
+                const relationWithPosition = {
+                    ...relation,
+                    ...{
+                        apiData: {
+                            id: relation.id,
+                            documentId: relation.documentId,
+                            locale: relation.locale,
+                            position
+                        }
+                    }
+                };
+                return [
+                    ...acc,
+                    relationWithPosition
+                ];
+            }
+            return acc;
+        }, []).toReversed();
+        field.onChange(`${name}.connect`, connectedRelations);
+    };
+    const handleGrabItem = (index)=>{
+        const item = data[index];
+        setLiveText(formatMessage({
+            id: getTranslation('dnd.grab-item'),
+            defaultMessage: `{item}, grabbed. Current position in list: {position}. Press up and down arrow to change position, Spacebar to drop, Escape to cancel.`
+        }, {
+            item: item.label ?? item.documentId,
+            position: getItemPos(index)
+        }));
+    };
+    const handleDropItem = (index)=>{
+        const { href: _href, label, ...item } = data[index];
+        setLiveText(formatMessage({
+            id: getTranslation('dnd.drop-item'),
+            defaultMessage: `{item}, dropped. Final position in list: {position}.`
+        }, {
+            item: label ?? item.documentId,
+            position: getItemPos(index)
+        }));
+    };
+    const handleCancel = (index)=>{
+        const item = data[index];
+        setLiveText(formatMessage({
+            id: getTranslation('dnd.cancel-item'),
+            defaultMessage: '{item}, dropped. Re-order cancelled.'
+        }, {
+            item: item.label ?? item.documentId
+        }));
+    };
+    const handleDisconnect = useHandleDisconnect(name, 'RelationsList');
+    /**
+   * These relation types will only ever have one item
+   * in their list, so you can't reorder a single item!
+   */ const canReorder = !ONE_WAY_RELATIONS.includes(relationType);
+    const dynamicListHeight = data.length > RELATIONS_TO_DISPLAY ? Math.min(data.length, RELATIONS_TO_DISPLAY) * (RELATION_ITEM_HEIGHT + RELATION_GUTTER) + RELATION_ITEM_HEIGHT / 2 : Math.min(data.length, RELATIONS_TO_DISPLAY) * (RELATION_ITEM_HEIGHT + RELATION_GUTTER);
+    return /*#__PURE__*/ jsxs(ShadowBox, {
+        $overflowDirection: overflow,
+        children: [
+            /*#__PURE__*/ jsx(VisuallyHidden, {
+                id: ariaDescriptionId,
+                children: formatMessage({
+                    id: getTranslation('dnd.instructions'),
+                    defaultMessage: `Press spacebar to grab and re-order`
+                })
+            }),
+            /*#__PURE__*/ jsx(VisuallyHidden, {
+                "aria-live": "assertive",
+                children: liveText
+            }),
+            /*#__PURE__*/ jsx(FixedSizeList, {
+                height: dynamicListHeight,
+                ref: listRef,
+                outerRef: outerListRef,
+                itemCount: data.length,
+                itemSize: RELATION_ITEM_HEIGHT + RELATION_GUTTER,
+                itemData: {
+                    ariaDescribedBy: ariaDescriptionId,
+                    canDrag: canReorder,
+                    disabled,
+                    handleCancel,
+                    handleDropItem,
+                    handleGrabItem,
+                    handleMoveItem,
+                    name,
+                    handleDisconnect,
+                    relations: data,
+                    targetModel
+                },
+                itemKey: (index)=>data[index].id,
+                innerElementType: "ol",
+                children: ListItem
+            })
+        ]
+    });
+};
+const ShadowBox = styled(Box)`
+  position: relative;
+  overflow: hidden;
+  flex: 1;
+
+  &:before,
+  &:after {
+    position: absolute;
+    width: 100%;
+    height: 4px;
+    z-index: 1;
+  }
+
+  &:before {
+    /* TODO: as for DS Table component we would need this to be handled by the DS theme */
+    content: '';
+    background: linear-gradient(rgba(3, 3, 5, 0.2) 0%, rgba(0, 0, 0, 0) 100%);
+    top: 0;
+    opacity: ${({ $overflowDirection })=>$overflowDirection === 'top-bottom' || $overflowDirection === 'top' ? 1 : 0};
+    transition: opacity 0.2s ease-in-out;
+  }
+
+  &:after {
+    /* TODO: as for DS Table component we would need this to be handled by the DS theme */
+    content: '';
+    background: linear-gradient(0deg, rgba(3, 3, 5, 0.2) 0%, rgba(0, 0, 0, 0) 100%);
+    bottom: 0;
+    opacity: ${({ $overflowDirection })=>$overflowDirection === 'top-bottom' || $overflowDirection === 'bottom' ? 1 : 0};
+    transition: opacity 0.2s ease-in-out;
+  }
+`;
+const CustomTextButton = styled(TextButton)`
+  & > span {
+    font-size: ${({ theme })=>theme.fontSizes[2]};
+  }
+`;
+const ListItem = ({ data, index, style })=>{
+    const [triggerRefetchDocument] = useLazyGetDocumentQuery();
+    const { ariaDescribedBy, canDrag = false, disabled = false, handleCancel, handleDisconnect, handleDropItem, handleGrabItem, handleMoveItem, name, relations, targetModel } = data;
+    const changeDocument = useDocumentContext('RelationsList', (state)=>state.changeDocument);
+    const rootDocumentMeta = useDocumentContext('RelationsList', (state)=>state.rootDocumentMeta);
+    const { formatMessage } = useIntl();
+    const [isModalOpen, setIsModalOpen] = React.useState(false);
+    const { href, id, label, status, documentId, apiData, locale } = relations[index];
+    const [{ handlerId, isDragging, handleKeyDown }, relationRef, dropRef, dragRef, dragPreviewRef] = useDragAndDrop(canDrag && !disabled, {
+        type: `${ItemTypes.RELATION}_${name}`,
+        index,
+        item: {
+            displayedValue: label,
+            status,
+            id: id,
+            index
+        },
+        onMoveItem: handleMoveItem,
+        onDropItem: handleDropItem,
+        onGrabItem: handleGrabItem,
+        onCancel: handleCancel,
+        dropSensitivity: DROP_SENSITIVITY.REGULAR
+    });
+    const composedRefs = useComposedRefs(relationRef, dragRef);
+    const handleChangeModalContent = ()=>{
+        if (changeDocument) {
+            const newRelation = {
+                documentId: documentId ?? apiData?.documentId,
+                model: targetModel,
+                collectionType: getCollectionType(href),
+                params: {
+                    locale: locale || null
+                }
+            };
+            changeDocument(newRelation);
+        }
+    };
+    const handleToggleModal = ()=>{
+        if (isModalOpen) {
+            setIsModalOpen(false);
+            const document = {
+                collectionType: rootDocumentMeta.collectionType,
+                model: rootDocumentMeta.model,
+                documentId: rootDocumentMeta.documentId
+            };
+            // Change back to the root document
+            changeDocument(document);
+            // Read from cache or refetch root document
+            triggerRefetchDocument(document, // Favor the cache
+            true);
+        } else {
+            setIsModalOpen(true);
+        }
+    };
+    React.useEffect(()=>{
+        dragPreviewRef(getEmptyImage());
+    }, [
+        dragPreviewRef
+    ]);
+    return /*#__PURE__*/ jsx(Box, {
+        style: style,
+        tag: "li",
+        ref: dropRef,
+        "aria-describedby": ariaDescribedBy,
+        cursor: canDrag ? 'all-scroll' : 'default',
+        children: isDragging ? /*#__PURE__*/ jsx(RelationItemPlaceholder, {}) : /*#__PURE__*/ jsxs(Flex, {
+            paddingTop: 2,
+            paddingBottom: 2,
+            paddingLeft: canDrag ? 2 : 4,
+            paddingRight: 4,
+            hasRadius: true,
+            borderColor: "neutral200",
+            background: disabled ? 'neutral150' : 'neutral0',
+            justifyContent: "space-between",
+            ref: composedRefs,
+            "data-handler-id": handlerId,
+            children: [
+                /*#__PURE__*/ jsxs(FlexWrapper, {
+                    gap: 1,
+                    children: [
+                        canDrag ? /*#__PURE__*/ jsx(IconButton, {
+                            tag: "div",
+                            role: "button",
+                            tabIndex: 0,
+                            withTooltip: false,
+                            label: formatMessage({
+                                id: getTranslation('components.RelationInput.icon-button-aria-label'),
+                                defaultMessage: 'Drag'
+                            }),
+                            variant: "ghost",
+                            onKeyDown: handleKeyDown,
+                            disabled: disabled,
+                            children: /*#__PURE__*/ jsx(Drag, {})
+                        }) : null,
+                        /*#__PURE__*/ jsxs(Flex, {
+                            width: "100%",
+                            minWidth: 0,
+                            justifyContent: "space-between",
+                            children: [
+                                /*#__PURE__*/ jsx(Box, {
+                                    minWidth: 0,
+                                    paddingTop: 1,
+                                    paddingBottom: 1,
+                                    paddingRight: 4,
+                                    children: /*#__PURE__*/ jsx(Tooltip, {
+                                        description: label,
+                                        children: isModalOpen ? /*#__PURE__*/ jsx(CustomTextButton, {
+                                            onClick: handleChangeModalContent,
+                                            children: label
+                                        }) : /*#__PURE__*/ jsx(CustomTextButton, {
+                                            onClick: ()=>{
+                                                handleChangeModalContent();
+                                                setIsModalOpen(true);
+                                            },
+                                            children: label
+                                        })
+                                    })
+                                }),
+                                status ? /*#__PURE__*/ jsx(DocumentStatus, {
+                                    status: status
+                                }) : null,
+                                isModalOpen && /*#__PURE__*/ jsx(RelationModal, {
+                                    open: isModalOpen,
+                                    onToggle: handleToggleModal
+                                })
+                            ]
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsx(Box, {
+                    paddingLeft: 4,
+                    children: /*#__PURE__*/ jsx(IconButton, {
+                        onClick: ()=>handleDisconnect(relations[index]),
+                        disabled: disabled,
+                        label: formatMessage({
+                            id: getTranslation('relation.disconnect'),
+                            defaultMessage: 'Remove'
+                        }),
+                        variant: "ghost",
+                        size: "S",
+                        children: /*#__PURE__*/ jsx(Cross, {})
+                    })
+                })
+            ]
+        })
+    });
+};
+const FlexWrapper = styled(Flex)`
+  width: 100%;
+  /* Used to prevent endAction to be pushed out of container */
+  min-width: 0;
+
+  & > div[role='button'] {
+    cursor: all-scroll;
+  }
+`;
+const DisconnectButton = styled.button`
+  svg path {
+    fill: ${({ theme, disabled })=>disabled ? theme.colors.neutral600 : theme.colors.neutral500};
+  }
+
+  &:hover svg path,
+  &:focus svg path {
+    fill: ${({ theme, disabled })=>!disabled && theme.colors.neutral600};
+  }
+`;
+const LinkEllipsis = styled(Link$2)`
+  display: block;
+
+  & > span {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    display: block;
+  }
+`;
+const RelationItemPlaceholder = ()=>/*#__PURE__*/ jsx(Box, {
+        paddingTop: 2,
+        paddingBottom: 2,
+        paddingLeft: 4,
+        paddingRight: 4,
+        hasRadius: true,
+        borderStyle: "dashed",
+        borderColor: "primary600",
+        borderWidth: "1px",
+        background: "primary100",
+        height: `calc(100% - ${RELATION_GUTTER}px)`
+    });
+const MemoizedRelationsField = /*#__PURE__*/ React.memo(RelationsField);
+
 const uidApi = contentManagerApi.injectEndpoints({
     endpoints: (builder)=>({
             getDefaultUID: builder.query({
@@ -4467,7 +5531,7 @@ const UIDInput = /*#__PURE__*/ React.forwardRef(({ hint, label, labelAction, nam
                                     onMouseLeave: ()=>setShowRegenerate(false),
                                     children: isLoading ? /*#__PURE__*/ jsx(LoadingWrapper, {
                                         "data-testid": "loading-wrapper",
-                                        children: /*#__PURE__*/ jsx(Loader, {})
+                                        children: /*#__PURE__*/ jsx(Loader$1, {})
                                     }) : /*#__PURE__*/ jsx(ArrowClockwise, {})
                                 })
                             ]
@@ -6394,22 +7458,20 @@ const Wysiwyg = /*#__PURE__*/ React.forwardRef(({ hint, disabled, label, name, p
 });
 const MemoizedWysiwyg = /*#__PURE__*/ React.memo(Wysiwyg);
 
-/**
- * @internal
- *
- * @description An abstraction around the regular form input renderer designed
- * specifically to be used in the EditView of the content-manager this understands
- * the complete EditFieldLayout and will handle RBAC conditions and rendering CM specific
- * components such as Blocks / Relations.
- */ const InputRenderer = ({ visible, hint: providedHint, ...props })=>{
-    const { id, document, collectionType } = useDoc();
-    const isFormDisabled = useForm('InputRenderer', (state)=>state.disabled);
+const InputRenderer = ({ visible, hint: providedHint, ...props })=>{
+    const { id: rootId } = useDoc();
+    const documentMeta = useDocumentContext('InputRenderer', (state)=>state.meta);
+    const documentResponse = useDocumentContext('InputRenderer', (state)=>state.document);
+    const documentLayout = useDocumentLayout(documentMeta.model);
+    const document = documentResponse?.document;
+    const collectionType = documentMeta.collectionType;
     const isInDynamicZone = useDynamicZone('isInDynamicZone', (state)=>state.isInDynamicZone);
+    const isFormDisabled = useForm('InputRenderer', (state)=>state.disabled);
     const canCreateFields = useDocumentRBAC('InputRenderer', (rbac)=>rbac.canCreateFields);
     const canReadFields = useDocumentRBAC('InputRenderer', (rbac)=>rbac.canReadFields);
     const canUpdateFields = useDocumentRBAC('InputRenderer', (rbac)=>rbac.canUpdateFields);
     const canUserAction = useDocumentRBAC('InputRenderer', (rbac)=>rbac.canUserAction);
-    let idToCheck = id;
+    let idToCheck = rootId;
     if (collectionType === SINGLE_TYPES) {
         idToCheck = document?.documentId;
     }
@@ -6425,7 +7487,8 @@ const MemoizedWysiwyg = /*#__PURE__*/ React.memo(Wysiwyg);
         props.attribute.customField
     ] : undefined);
     const hint = useFieldHint(providedHint, props.attribute);
-    const { edit: { components } } = useDocLayout();
+    const { edit: { components: rootDocumentComponents } } = useDocLayout();
+    const components = Object.keys(rootDocumentComponents).length !== 0 ? rootDocumentComponents : documentLayout.edit.components;
     // We pass field in case of Custom Fields to keep backward compatibility
     const field = useField(props.name);
     if (!visible) {
@@ -6502,13 +7565,6 @@ const MemoizedWysiwyg = /*#__PURE__*/ React.memo(Wysiwyg);
                 disabled: fieldIsDisabled
             });
         case 'relation':
-            if (window.strapi.future.isEnabled('unstableRelationsOnTheFly')) {
-                return /*#__PURE__*/ jsx(MemoizedUnstableRelationsField, {
-                    ...props,
-                    hint: hint,
-                    disabled: fieldIsDisabled
-                });
-            }
             return /*#__PURE__*/ jsx(MemoizedRelationsField, {
                 ...props,
                 hint: hint,
@@ -6606,7 +7662,7 @@ const getMinMax = (attribute)=>{
         };
     }
 };
-const MemoizedInputRenderer = /*#__PURE__*/ memo(InputRenderer);
+const MemoizedInputRenderer = /*#__PURE__*/ React.memo(InputRenderer);
 
 const RESPONSIVE_CONTAINER_BREAKPOINTS = {
     sm: '27.5rem'
@@ -6614,16 +7670,21 @@ const RESPONSIVE_CONTAINER_BREAKPOINTS = {
 const ResponsiveGridRoot = styled(Grid$1.Root)`
   container-type: inline-size;
 `;
-const ResponsiveGridItem = styled(Grid$1.Item)`
-  grid-column: span 12;
-
-  @container (min-width: ${RESPONSIVE_CONTAINER_BREAKPOINTS.sm}) {
-    ${({ col })=>col && `grid-column: span ${col};`}
-  }
-`;
-const FormLayout = ({ layout, hasBackground = false })=>{
+// We need to use a different grid item for the responsive layout in the test environment
+// because @container is not supported in jsdom and it throws an error
+const ResponsiveGridItem = // TODO: we need to find a better solution to avoid using process.env.NODE_ENV in the code to fix the tests with this styled component
+process.env.NODE_ENV !== 'test' ? styled(Grid$1.Item)`
+        grid-column: span 12;
+        @container (min-width: ${RESPONSIVE_CONTAINER_BREAKPOINTS.sm}) {
+          ${({ col })=>col && `grid-column: span ${col};`}
+        }
+      ` : styled(Grid$1.Item)`
+        grid-column: span 12;
+      `;
+const FormLayout = ({ layout, hasBackground = true })=>{
     const { formatMessage } = useIntl();
-    const { model } = useDoc();
+    const documentMeta = useDocumentContext('FormLayout', (state)=>state.meta);
+    const model = documentMeta.model;
     return /*#__PURE__*/ jsx(Flex, {
         direction: "column",
         alignItems: "stretch",
@@ -6654,7 +7715,7 @@ const FormLayout = ({ layout, hasBackground = false })=>{
                 }, field.name);
             }
             return /*#__PURE__*/ jsx(Box, {
-                ...!hasBackground && {
+                ...hasBackground && {
                     padding: 6,
                     borderColor: 'neutral150',
                     background: 'neutral0',
@@ -6756,7 +7817,7 @@ const RepeatableComponent = ({ attribute, disabled, name, mainField, children, l
     const search = React.useMemo(()=>new URLSearchParams(searchString), [
         searchString
     ]);
-    const { components } = useDoc();
+    const components = useDocumentContext('RepeatableComponent', (state)=>state.document.components);
     const { value = [], error, rawError } = useField(name);
     const addFieldRow = useForm('RepeatableComponent', (state)=>state.addFieldRow);
     const moveFieldRow = useForm('RepeatableComponent', (state)=>state.moveFieldRow);
@@ -7121,7 +8182,7 @@ const ComponentInput = ({ label, required, name, attribute, disabled, labelActio
     const { formatMessage } = useIntl();
     const field = useField(name);
     const showResetComponent = !attribute.repeatable && field.value && !disabled;
-    const { components } = useDoc();
+    const components = useDocumentContext('ComponentInput', (state)=>state.document.components);
     const handleInitialisationClick = ()=>{
         const schema = components[attribute.component];
         const form = createDefaultForm(schema, components);
@@ -7186,5 +8247,5 @@ const ComponentInput = ({ label, required, name, attribute, disabled, labelActio
 };
 const MemoizedComponentInput = /*#__PURE__*/ React.memo(ComponentInput);
 
-export { DynamicZone as D, FormLayout as F, MemoizedUIDInput as M, NotAllowedInput as N, useDynamicZone as a, useFieldHint as b, MemoizedWysiwyg as c, MemoizedComponentInput as d, MemoizedBlocksInput as e, useLazyComponents as u };
-//# sourceMappingURL=Input-BexkC_pp.mjs.map
+export { DisconnectButton as D, FlexWrapper as F, LinkEllipsis as L, MemoizedUIDInput as M, NotAllowedInput as N, FormLayout as a, useDynamicZone as b, useFieldHint as c, MemoizedWysiwyg as d, DynamicZone as e, MemoizedComponentInput as f, MemoizedBlocksInput as g, useLazyComponents as u };
+//# sourceMappingURL=Input-BHucdqva.mjs.map