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

package/dist/admin/chunks/{Input-DLJZHw9Y.js → Input-BJCenRYN.js}

@@ -6,7 +6,7 @@ var strapiAdmin = require('@strapi/admin/strapi-admin');
 var designSystem = require('@strapi/design-system');
 var Icons = require('@strapi/icons');
 var reactIntl = require('react-intl');
-var index = require('./index-BHimg6jW.js');
+var index = require('./index-DoUQnFTk.js');
 var styledComponents = require('styled-components');
 var slate = require('slate');
 var slateHistory = require('slate-history');
@@ -62,16 +62,15 @@ require('prismjs/components/prism-typescript');
 require('prismjs/components/prism-tsx');
 require('prismjs/components/prism-vbnet');
 require('prismjs/components/prism-yaml');
-var usePrev = require('./usePrev-DIYl-IAL.js');
-var useDragAndDrop = require('./useDragAndDrop-gcqEJMnO.js');
+var usePrev = require('./usePrev-Cm_0-qRC.js');
+var objects = require('./objects-BJTP843m.js');
 var Toolbar = require('@radix-ui/react-toolbar');
 var reactDndHtml5Backend = require('react-dnd-html5-backend');
 var reactRouterDom = require('react-router-dom');
-var objects = require('./objects-C3EebVVe.js');
-var Relations = require('./Relations-o7_hVGyK.js');
 var pipe$1 = require('lodash/fp/pipe');
 var ComponentIcon = require('./ComponentIcon-C-EjOUPA.js');
-var relations = require('./relations-XOYEEqMz.js');
+var fractionalIndexing = require('fractional-indexing');
+var reactWindow = require('react-window');
 var CodeMirror = require('codemirror5');
 var sanitizeHtml = require('sanitize-html');
 var highlight_js = require('highlight.js');
@@ -2428,8 +2427,8 @@ const DropPlaceholder = styledComponents.styled(designSystem.Box)`
 
   // Show drop placeholder 8px above or below the drop target
   ${({ dragDirection, theme, placeholderMargin })=>styledComponents.css`
-    top: ${dragDirection === useDragAndDrop.DIRECTIONS.UPWARD && `-${theme.spaces[placeholderMargin]}`};
-    bottom: ${dragDirection === useDragAndDrop.DIRECTIONS.DOWNWARD && `-${theme.spaces[placeholderMargin]}`};
+    top: ${dragDirection === objects.DIRECTIONS.UPWARD && `-${theme.spaces[placeholderMargin]}`};
+    bottom: ${dragDirection === objects.DIRECTIONS.DOWNWARD && `-${theme.spaces[placeholderMargin]}`};
   `}
 `;
 const DragItem = styledComponents.styled(designSystem.Flex)`
@@ -2513,8 +2512,8 @@ const DragAndDropElement = ({ children, index: index$1, setDragDirection, dragDi
         name1,
         setLiveText
     ]);
-    const [{ handlerId, isDragging, isOverDropTarget, direction }, blockRef, dropRef, dragRef] = useDragAndDrop.useDragAndDrop(!disabled, {
-        type: `${useDragAndDrop.ItemTypes.BLOCKS}_${name1}`,
+    const [{ handlerId, isDragging, isOverDropTarget, direction }, blockRef, dropRef, dragRef] = objects.useDragAndDrop(!disabled, {
+        type: `${objects.ItemTypes.BLOCKS}_${name1}`,
         index: index$1,
         item: {
             index: index$1,
@@ -3485,6 +3484,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] = strapiAdmin.createContext('ComponentContext', {
+    id: undefined,
+    level: -1,
+    uid: undefined,
+    type: undefined
+});
+
 const AddComponentButton = ({ hasError, isDisabled, isOpen, children, onClick })=>{
     return /*#__PURE__*/ jsxRuntime.jsx(StyledButton, {
         type: "button",
@@ -3663,7 +3676,8 @@ const ComponentPicker = ({ dynamicComponentsByCategory = {}, isOpen, onClickAddC
 const DynamicComponent = ({ componentUid, disabled, index: index$1, name, onRemoveComponentClick, onMoveComponent, onGrabItem, onDropItem, onCancel, dynamicComponentsByCategory = {}, onAddComponent, children })=>{
     const { formatMessage } = reactIntl.useIntl();
     const formValues = strapiAdmin.useForm('DynamicComponent', (state)=>state.values);
-    const { edit: { components } } = index.useDocLayout();
+    const documentMeta = index.useDocumentContext('DynamicComponent', (state)=>state.meta);
+    const { edit: { components } } = index.useDocumentLayout(documentMeta.model);
     const title = React__namespace.useMemo(()=>{
         const { mainField } = components[componentUid]?.settings ?? {
             mainField: 'id'
@@ -3693,8 +3707,8 @@ const DynamicComponent = ({ componentUid, disabled, index: index$1, name, onRemo
         componentUid,
         dynamicComponentsByCategory
     ]);
-    const [{ handlerId, isDragging, handleKeyDown }, boxRef, dropRef, dragRef, dragPreviewRef] = useDragAndDrop.useDragAndDrop(!disabled, {
-        type: `${useDragAndDrop.ItemTypes.DYNAMIC_ZONE}_${name}`,
+    const [{ handlerId, isDragging, handleKeyDown }, boxRef, dropRef, dragRef, dragPreviewRef] = objects.useDragAndDrop(!disabled, {
+        type: `${objects.ItemTypes.DYNAMIC_ZONE}_${name}`,
         index: index$1,
         item: {
             index: index$1,
@@ -4015,7 +4029,8 @@ const DynamicZone = ({ attribute, disabled: disabledProp, hint, label, labelActi
     const { max = Infinity, min = -Infinity } = attribute ?? {};
     const [addComponentIsOpen, setAddComponentIsOpen] = React__namespace.useState(false);
     const [liveText, setLiveText] = React__namespace.useState('');
-    const { components, isLoading } = index.useDoc();
+    const document = index.useDocumentContext('DynamicZone', (state)=>state.document);
+    const { components, isLoading } = document;
     const disabled = disabledProp || isLoading;
     const { addFieldRow, removeFieldRow, moveFieldRow } = strapiAdmin.useForm('DynamicZone', ({ addFieldRow, removeFieldRow, moveFieldRow })=>({
             addFieldRow,
@@ -4143,7 +4158,7 @@ const DynamicZone = ({ attribute, disabled: disabledProp, hint, label, labelActi
             componentName: label || name
         });
     };
-    const level = Relations.useComponent('DynamicZone', (state)=>state.level);
+    const level = useComponent('DynamicZone', (state)=>state.level);
     const ariaDescriptionId = React__namespace.useId();
     return /*#__PURE__*/ jsxRuntime.jsx(DynamicZoneProvider, {
         isInDynamicZone: true,
@@ -4175,7 +4190,7 @@ const DynamicZone = ({ attribute, disabled: disabledProp, hint, label, labelActi
                         }),
                         /*#__PURE__*/ jsxRuntime.jsx("ol", {
                             "aria-describedby": ariaDescriptionId,
-                            children: value.map((field, index)=>/*#__PURE__*/ jsxRuntime.jsx(Relations.ComponentProvider, {
+                            children: value.map((field, index)=>/*#__PURE__*/ jsxRuntime.jsx(ComponentProvider, {
                                     level: level + 1,
                                     uid: field.__component,
                                     // id is always a number in a dynamic zone.
@@ -4248,6 +4263,1055 @@ const NotAllowedInput = ({ hint, label, required, name })=>{
     });
 };
 
+function getCollectionType(url) {
+    const regex = new RegExp(`(${index.COLLECTION_TYPES}|${index.SINGLE_TYPES})`);
+    const match = url.match(regex);
+    return match ? match[1] : undefined;
+}
+const CustomModalContent = styledComponents.styled(designSystem.Modal.Content)`
+  width: 90%;
+  max-width: 100%;
+  height: 90%;
+  max-height: 100%;
+`;
+const RelationModal = ({ open, onToggle })=>{
+    const { formatMessage } = reactIntl.useIntl();
+    return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Modal.Root, {
+        open: open,
+        onOpenChange: onToggle,
+        children: /*#__PURE__*/ jsxRuntime.jsxs(CustomModalContent, {
+            children: [
+                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Modal.Header, {
+                    gap: 2,
+                    children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                        justifyContent: "space-between",
+                        alignItems: "center",
+                        width: "100%",
+                        children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                            gap: 2,
+                            children: [
+                                /*#__PURE__*/ jsxRuntime.jsx(designSystem.IconButton, {
+                                    withTooltip: false,
+                                    label: "Back",
+                                    variant: "ghost",
+                                    disabled: true,
+                                    onClick: ()=>{},
+                                    marginRight: 1,
+                                    children: /*#__PURE__*/ jsxRuntime.jsx(Icons.ArrowLeft, {})
+                                }),
+                                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+                                    tag: "span",
+                                    fontWeight: 600,
+                                    children: formatMessage({
+                                        id: 'content-manager.components.RelationInputModal.modal-title',
+                                        defaultMessage: 'Edit a relation'
+                                    })
+                                })
+                            ]
+                        })
+                    })
+                }),
+                /*#__PURE__*/ jsxRuntime.jsx(RelationModalBody, {}),
+                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Modal.Footer, {
+                    children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
+                        onClick: onToggle,
+                        variant: "tertiary",
+                        children: formatMessage({
+                            id: 'app.components.Button.cancel',
+                            defaultMessage: 'Cancel'
+                        })
+                    })
+                })
+            ]
+        })
+    });
+};
+const RelationModalBody = ()=>{
+    const { formatMessage } = reactIntl.useIntl();
+    const documentMeta = index.useDocumentContext('RelationModalBody', (state)=>state.meta);
+    const documentResponse = index.useDocumentContext('RelationModalBody', (state)=>state.document);
+    const documentLayoutResponse = index.useDocumentLayout(documentMeta.model);
+    const plugins = strapiAdmin.useStrapiApp('RelationModalBody', (state)=>state.plugins);
+    const initialValues = documentResponse.getInitialFormValues();
+    const { permissions = [], isLoading: isLoadingPermissions, error } = strapiAdmin.useRBAC(index.PERMISSIONS.map((action)=>({
+            action,
+            subject: documentMeta.model
+        })));
+    const isLoading = isLoadingPermissions || documentLayoutResponse.isLoading || documentResponse.isLoading;
+    if (isLoading && !documentResponse.document?.documentId) {
+        return /*#__PURE__*/ jsxRuntime.jsx(designSystem.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__*/ jsxRuntime.jsx(designSystem.Flex, {
+            alignItems: "center",
+            height: "100%",
+            justifyContent: "center",
+            children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.EmptyStateLayout, {
+                icon: /*#__PURE__*/ jsxRuntime.jsx(Icons.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__*/ jsxRuntime.jsx(designSystem.Modal.Body, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(index.DocumentRBAC, {
+            permissions: permissions,
+            model: documentMeta.model,
+            children: /*#__PURE__*/ jsxRuntime.jsxs(strapiAdmin.Form, {
+                initialValues: initialValues,
+                validate: (values, options)=>{
+                    const yupSchema = index.createYupSchema(documentResponse.schema?.attributes, documentResponse.components, {
+                        status: documentResponse.document?.status,
+                        ...options
+                    });
+                    return yupSchema.validate(values, {
+                        abortEarly: false
+                    });
+                },
+                method: "PUT",
+                children: [
+                    /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                        alignItems: "flex-start",
+                        direction: "column",
+                        gap: 2,
+                        children: [
+                            /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                                width: "100%",
+                                justifyContent: "space-between",
+                                gap: 2,
+                                children: [
+                                    /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+                                        tag: "h2",
+                                        variant: "alpha",
+                                        children: documentTitle
+                                    }),
+                                    /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                                        gap: 2,
+                                        children: /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.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__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+                                                        children: [
+                                                            /*#__PURE__*/ jsxRuntime.jsx(index.DocumentActionButton, {
+                                                                ...secondaryAction,
+                                                                variant: secondaryAction.variant || 'secondary'
+                                                            }),
+                                                            /*#__PURE__*/ jsxRuntime.jsx(index.DocumentActionButton, {
+                                                                ...primaryAction,
+                                                                variant: primaryAction.variant || 'default'
+                                                            })
+                                                        ]
+                                                    });
+                                                }
+                                                // Otherwise we just have the save action
+                                                return /*#__PURE__*/ jsxRuntime.jsx(index.DocumentActionButton, {
+                                                    ...primaryAction,
+                                                    variant: primaryAction.variant || 'secondary'
+                                                });
+                                            }
+                                        })
+                                    })
+                                ]
+                            }),
+                            hasDraftAndPublished ? /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
+                                children: /*#__PURE__*/ jsxRuntime.jsx(index.DocumentStatus, {
+                                    status: documentResponse.document?.status
+                                })
+                            }) : null
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                        flex: 1,
+                        overflow: "auto",
+                        alignItems: "stretch",
+                        paddingTop: 7,
+                        children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
+                            overflow: "auto",
+                            flex: 1,
+                            children: /*#__PURE__*/ jsxRuntime.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 = strapiAdmin.useField(fieldName);
+    const removeFieldRow = strapiAdmin.useForm(consumerName, (state)=>state.removeFieldRow);
+    const addFieldRow = strapiAdmin.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__namespace.forwardRef(({ disabled, label, ...props }, ref)=>{
+    const documentMeta = index.useDocumentContext('RelationsField', (state)=>state.meta);
+    const documentResponse = index.useDocumentContext('RelationsField', (state)=>state.document);
+    const [currentPage, setCurrentPage] = React__namespace.useState(1);
+    const documentId = documentResponse.document?.documentId;
+    const { formatMessage } = reactIntl.useIntl();
+    const [{ query }] = strapiAdmin.useQueryParams();
+    const params = index.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 = strapiAdmin.useForm('RelationsList', (state)=>state.isSubmitting);
+    React__namespace.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 } = usePrev.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 = strapiAdmin.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__namespace.useMemo(()=>{
+        const ctx = {
+            field: field.value,
+            // @ts-expect-error – targetModel does exist on the attribute. But it's not typed.
+            href: `../${index.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__: fractionalIndexing.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: usePrev.getRelationLabel(relation, props.mainField),
+            // @ts-expect-error – targetModel does exist on the attribute, but it's not typed.
+            href: `../${index.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__*/ jsxRuntime.jsxs(designSystem.Flex, {
+        ref: ref,
+        direction: "column",
+        gap: 3,
+        justifyContent: "space-between",
+        alignItems: "stretch",
+        wrap: "wrap",
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsxs(StyledFlex, {
+                direction: "column",
+                alignItems: "start",
+                gap: 2,
+                width: "100%",
+                children: [
+                    /*#__PURE__*/ jsxRuntime.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__*/ jsxRuntime.jsx(designSystem.TextButton, {
+                        disabled: isFetchingMoreRelations,
+                        onClick: handleLoadMore,
+                        loading: isFetchingMoreRelations,
+                        startIcon: /*#__PURE__*/ jsxRuntime.jsx(Icons.ArrowClockwise, {}),
+                        // prevent the label from line-wrapping
+                        shrink: 0,
+                        children: formatMessage({
+                            id: index.getTranslation('relation.loadMore'),
+                            defaultMessage: 'Load More'
+                        })
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ jsxRuntime.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 = styledComponents.styled(designSystem.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: usePrev.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__namespace.useState('');
+    const [searchParams, setSearchParams] = React__namespace.useState({
+        _q: '',
+        page: 1
+    });
+    const { toggleNotification } = strapiAdmin.useNotification();
+    const [{ query }] = strapiAdmin.useQueryParams();
+    const { formatMessage } = reactIntl.useIntl();
+    const fieldRef = strapiAdmin.useFocusInputField(name);
+    const field = strapiAdmin.useField(name);
+    const searchParamsDebounced = usePrev.useDebounce(searchParams, 300);
+    const [searchForTrigger, { data, isLoading }] = usePrev.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__namespace.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: {
+                ...index.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: index.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__namespace.useLayoutEffect(()=>{
+        setTextValue('');
+    }, [
+        field.value
+    ]);
+    return /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Field.Root, {
+        error: field.error,
+        hint: hint,
+        name: name,
+        required: required,
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Field.Label, {
+                action: labelAction,
+                children: label
+            }),
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Combobox, {
+                ref: fieldRef,
+                name: name,
+                autocomplete: "list",
+                placeholder: placeholder || formatMessage({
+                    id: index.getTranslation('relation.add'),
+                    defaultMessage: 'Add relation'
+                }),
+                hasMoreItems: hasNextPage,
+                loading: isLoading,
+                onOpenChange: ()=>{
+                    handleSearch(textValue ?? '');
+                },
+                noOptionsMessage: ()=>formatMessage({
+                        id: index.getTranslation('relation.notAvailable'),
+                        defaultMessage: 'No relations available'
+                    }),
+                loadingMessage: formatMessage({
+                    id: index.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 = usePrev.getRelationLabel(opt, mainField);
+                    return /*#__PURE__*/ jsxRuntime.jsx(designSystem.ComboboxOption, {
+                        value: opt.id.toString(),
+                        textValue: textValue,
+                        children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                            gap: 2,
+                            justifyContent: "space-between",
+                            children: [
+                                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+                                    ellipsis: true,
+                                    children: textValue
+                                }),
+                                opt.status ? /*#__PURE__*/ jsxRuntime.jsx(index.DocumentStatus, {
+                                    status: opt.status
+                                }) : null
+                            ]
+                        })
+                    }, opt.id);
+                })
+            }),
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Field.Error, {}),
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Field.Hint, {})
+        ]
+    });
+};
+/* -------------------------------------------------------------------------------------------------
+ * RelationsList
+ * -----------------------------------------------------------------------------------------------*/ const RELATION_ITEM_HEIGHT = 50;
+const RELATION_GUTTER = 4;
+const RelationsList = ({ data, serverData, disabled, name, isLoading, relationType, targetModel })=>{
+    const ariaDescriptionId = React__namespace.useId();
+    const { formatMessage } = reactIntl.useIntl();
+    const listRef = React__namespace.useRef(null);
+    const outerListRef = React__namespace.useRef(null);
+    const [overflow, setOverflow] = React__namespace.useState();
+    const [liveText, setLiveText] = React__namespace.useState('');
+    const field = strapiAdmin.useField(name);
+    React__namespace.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: index.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] = fractionalIndexing.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$1)=>{
+        const item = data[index$1];
+        setLiveText(formatMessage({
+            id: index.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$1)
+        }));
+    };
+    const handleDropItem = (index$1)=>{
+        const { href: _href, label, ...item } = data[index$1];
+        setLiveText(formatMessage({
+            id: index.getTranslation('dnd.drop-item'),
+            defaultMessage: `{item}, dropped. Final position in list: {position}.`
+        }, {
+            item: label ?? item.documentId,
+            position: getItemPos(index$1)
+        }));
+    };
+    const handleCancel = (index$1)=>{
+        const item = data[index$1];
+        setLiveText(formatMessage({
+            id: index.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__*/ jsxRuntime.jsxs(ShadowBox, {
+        $overflowDirection: overflow,
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.VisuallyHidden, {
+                id: ariaDescriptionId,
+                children: formatMessage({
+                    id: index.getTranslation('dnd.instructions'),
+                    defaultMessage: `Press spacebar to grab and re-order`
+                })
+            }),
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.VisuallyHidden, {
+                "aria-live": "assertive",
+                children: liveText
+            }),
+            /*#__PURE__*/ jsxRuntime.jsx(reactWindow.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 = styledComponents.styled(designSystem.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 = styledComponents.styled(designSystem.TextButton)`
+  & > span {
+    font-size: ${({ theme })=>theme.fontSizes[2]};
+  }
+`;
+const ListItem = ({ data, index: index$1, style })=>{
+    const [triggerRefetchDocument] = index.useLazyGetDocumentQuery();
+    const { ariaDescribedBy, canDrag = false, disabled = false, handleCancel, handleDisconnect, handleDropItem, handleGrabItem, handleMoveItem, name, relations, targetModel } = data;
+    const changeDocument = index.useDocumentContext('RelationsList', (state)=>state.changeDocument);
+    const rootDocumentMeta = index.useDocumentContext('RelationsList', (state)=>state.rootDocumentMeta);
+    const { formatMessage } = reactIntl.useIntl();
+    const [isModalOpen, setIsModalOpen] = React__namespace.useState(false);
+    const { href, id, label, status, documentId, apiData, locale } = relations[index$1];
+    const [{ handlerId, isDragging, handleKeyDown }, relationRef, dropRef, dragRef, dragPreviewRef] = objects.useDragAndDrop(canDrag && !disabled, {
+        type: `${objects.ItemTypes.RELATION}_${name}`,
+        index: index$1,
+        item: {
+            displayedValue: label,
+            status,
+            id: id,
+            index: index$1
+        },
+        onMoveItem: handleMoveItem,
+        onDropItem: handleDropItem,
+        onGrabItem: handleGrabItem,
+        onCancel: handleCancel,
+        dropSensitivity: objects.DROP_SENSITIVITY.REGULAR
+    });
+    const composedRefs = designSystem.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__namespace.useEffect(()=>{
+        dragPreviewRef(reactDndHtml5Backend.getEmptyImage());
+    }, [
+        dragPreviewRef
+    ]);
+    return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
+        style: style,
+        tag: "li",
+        ref: dropRef,
+        "aria-describedby": ariaDescribedBy,
+        cursor: canDrag ? 'all-scroll' : 'default',
+        children: isDragging ? /*#__PURE__*/ jsxRuntime.jsx(RelationItemPlaceholder, {}) : /*#__PURE__*/ jsxRuntime.jsxs(designSystem.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__*/ jsxRuntime.jsxs(FlexWrapper, {
+                    gap: 1,
+                    children: [
+                        canDrag ? /*#__PURE__*/ jsxRuntime.jsx(designSystem.IconButton, {
+                            tag: "div",
+                            role: "button",
+                            tabIndex: 0,
+                            withTooltip: false,
+                            label: formatMessage({
+                                id: index.getTranslation('components.RelationInput.icon-button-aria-label'),
+                                defaultMessage: 'Drag'
+                            }),
+                            variant: "ghost",
+                            onKeyDown: handleKeyDown,
+                            disabled: disabled,
+                            children: /*#__PURE__*/ jsxRuntime.jsx(Icons.Drag, {})
+                        }) : null,
+                        /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                            width: "100%",
+                            minWidth: 0,
+                            justifyContent: "space-between",
+                            children: [
+                                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
+                                    minWidth: 0,
+                                    paddingTop: 1,
+                                    paddingBottom: 1,
+                                    paddingRight: 4,
+                                    children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Tooltip, {
+                                        description: label,
+                                        children: isModalOpen ? /*#__PURE__*/ jsxRuntime.jsx(CustomTextButton, {
+                                            onClick: handleChangeModalContent,
+                                            children: label
+                                        }) : /*#__PURE__*/ jsxRuntime.jsx(CustomTextButton, {
+                                            onClick: ()=>{
+                                                handleChangeModalContent();
+                                                setIsModalOpen(true);
+                                            },
+                                            children: label
+                                        })
+                                    })
+                                }),
+                                status ? /*#__PURE__*/ jsxRuntime.jsx(index.DocumentStatus, {
+                                    status: status
+                                }) : null,
+                                isModalOpen && /*#__PURE__*/ jsxRuntime.jsx(RelationModal, {
+                                    open: isModalOpen,
+                                    onToggle: handleToggleModal
+                                })
+                            ]
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
+                    paddingLeft: 4,
+                    children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.IconButton, {
+                        onClick: ()=>handleDisconnect(relations[index$1]),
+                        disabled: disabled,
+                        label: formatMessage({
+                            id: index.getTranslation('relation.disconnect'),
+                            defaultMessage: 'Remove'
+                        }),
+                        variant: "ghost",
+                        size: "S",
+                        children: /*#__PURE__*/ jsxRuntime.jsx(Icons.Cross, {})
+                    })
+                })
+            ]
+        })
+    });
+};
+const FlexWrapper = styledComponents.styled(designSystem.Flex)`
+  width: 100%;
+  /* Used to prevent endAction to be pushed out of container */
+  min-width: 0;
+
+  & > div[role='button'] {
+    cursor: all-scroll;
+  }
+`;
+const DisconnectButton = styledComponents.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 = styledComponents.styled(designSystem.Link)`
+  display: block;
+
+  & > span {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    display: block;
+  }
+`;
+const RelationItemPlaceholder = ()=>/*#__PURE__*/ jsxRuntime.jsx(designSystem.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__namespace.memo(RelationsField);
+
 const uidApi = index.contentManagerApi.injectEndpoints({
     endpoints: (builder)=>({
             getDefaultUID: builder.query({
@@ -4304,7 +5368,7 @@ const UIDInput = /*#__PURE__*/ React__namespace.forwardRef(({ hint, label, label
     const [showRegenerate, setShowRegenerate] = React__namespace.useState(false);
     const isCloning = reactRouterDom.useMatch(index.CLONE_PATH) !== null;
     const field = strapiAdmin.useField(name);
-    const debouncedValue = relations.useDebounce(field.value, 300);
+    const debouncedValue = usePrev.useDebounce(field.value, 300);
     const hasChanged = debouncedValue !== field.initialValue;
     const { toggleNotification } = strapiAdmin.useNotification();
     const { _unstableFormatAPIError: formatAPIError } = strapiAdmin.useAPIErrorHandler();
@@ -6416,22 +7480,20 @@ const Wysiwyg = /*#__PURE__*/ React__namespace.forwardRef(({ hint, disabled, lab
 });
 const MemoizedWysiwyg = /*#__PURE__*/ React__namespace.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 } = index.useDoc();
-    const isFormDisabled = strapiAdmin.useForm('InputRenderer', (state)=>state.disabled);
+const InputRenderer = ({ visible, hint: providedHint, ...props })=>{
+    const { id: rootId } = index.useDoc();
+    const documentMeta = index.useDocumentContext('InputRenderer', (state)=>state.meta);
+    const documentResponse = index.useDocumentContext('InputRenderer', (state)=>state.document);
+    const documentLayout = index.useDocumentLayout(documentMeta.model);
+    const document = documentResponse?.document;
+    const collectionType = documentMeta.collectionType;
     const isInDynamicZone = useDynamicZone('isInDynamicZone', (state)=>state.isInDynamicZone);
+    const isFormDisabled = strapiAdmin.useForm('InputRenderer', (state)=>state.disabled);
     const canCreateFields = index.useDocumentRBAC('InputRenderer', (rbac)=>rbac.canCreateFields);
     const canReadFields = index.useDocumentRBAC('InputRenderer', (rbac)=>rbac.canReadFields);
     const canUpdateFields = index.useDocumentRBAC('InputRenderer', (rbac)=>rbac.canUpdateFields);
     const canUserAction = index.useDocumentRBAC('InputRenderer', (rbac)=>rbac.canUserAction);
-    let idToCheck = id;
+    let idToCheck = rootId;
     if (collectionType === index.SINGLE_TYPES) {
         idToCheck = document?.documentId;
     }
@@ -6447,7 +7509,8 @@ const MemoizedWysiwyg = /*#__PURE__*/ React__namespace.memo(Wysiwyg);
         props.attribute.customField
     ] : undefined);
     const hint = useFieldHint(providedHint, props.attribute);
-    const { edit: { components } } = index.useDocLayout();
+    const { edit: { components: rootDocumentComponents } } = index.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 = strapiAdmin.useField(props.name);
     if (!visible) {
@@ -6524,14 +7587,7 @@ const MemoizedWysiwyg = /*#__PURE__*/ React__namespace.memo(Wysiwyg);
                 disabled: fieldIsDisabled
             });
         case 'relation':
-            if (window.strapi.future.isEnabled('unstableRelationsOnTheFly')) {
-                return /*#__PURE__*/ jsxRuntime.jsx(Relations.MemoizedUnstableRelationsField, {
-                    ...props,
-                    hint: hint,
-                    disabled: fieldIsDisabled
-                });
-            }
-            return /*#__PURE__*/ jsxRuntime.jsx(Relations.MemoizedRelationsField, {
+            return /*#__PURE__*/ jsxRuntime.jsx(MemoizedRelationsField, {
                 ...props,
                 hint: hint,
                 disabled: fieldIsDisabled
@@ -6628,7 +7684,7 @@ const getMinMax = (attribute)=>{
         };
     }
 };
-const MemoizedInputRenderer = /*#__PURE__*/ React.memo(InputRenderer);
+const MemoizedInputRenderer = /*#__PURE__*/ React__namespace.memo(InputRenderer);
 
 const RESPONSIVE_CONTAINER_BREAKPOINTS = {
     sm: '27.5rem'
@@ -6636,16 +7692,21 @@ const RESPONSIVE_CONTAINER_BREAKPOINTS = {
 const ResponsiveGridRoot = styledComponents.styled(designSystem.Grid.Root)`
   container-type: inline-size;
 `;
-const ResponsiveGridItem = styledComponents.styled(designSystem.Grid.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' ? styledComponents.styled(designSystem.Grid.Item)`
+        grid-column: span 12;
+        @container (min-width: ${RESPONSIVE_CONTAINER_BREAKPOINTS.sm}) {
+          ${({ col })=>col && `grid-column: span ${col};`}
+        }
+      ` : styledComponents.styled(designSystem.Grid.Item)`
+        grid-column: span 12;
+      `;
+const FormLayout = ({ layout, hasBackground = true })=>{
     const { formatMessage } = reactIntl.useIntl();
-    const { model } = index.useDoc();
+    const documentMeta = index.useDocumentContext('FormLayout', (state)=>state.meta);
+    const model = documentMeta.model;
     return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
         direction: "column",
         alignItems: "stretch",
@@ -6676,7 +7737,7 @@ const FormLayout = ({ layout, hasBackground = false })=>{
                 }, field.name);
             }
             return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
-                ...!hasBackground && {
+                ...hasBackground && {
                     padding: 6,
                     borderColor: 'neutral150',
                     background: 'neutral0',
@@ -6718,9 +7779,9 @@ const FormLayout = ({ layout, hasBackground = false })=>{
 const NonRepeatableComponent = ({ attribute, name, children, layout })=>{
     const { formatMessage } = reactIntl.useIntl();
     const { value } = strapiAdmin.useField(name);
-    const level = Relations.useComponent('NonRepeatableComponent', (state)=>state.level);
+    const level = useComponent('NonRepeatableComponent', (state)=>state.level);
     const isNested = level > 0;
-    return /*#__PURE__*/ jsxRuntime.jsx(Relations.ComponentProvider, {
+    return /*#__PURE__*/ jsxRuntime.jsx(ComponentProvider, {
         id: value?.id,
         uid: attribute.component,
         level: level + 1,
@@ -6778,7 +7839,7 @@ const RepeatableComponent = ({ attribute, disabled, name, mainField, children, l
     const search = React__namespace.useMemo(()=>new URLSearchParams(searchString), [
         searchString
     ]);
-    const { components } = index.useDoc();
+    const components = index.useDocumentContext('RepeatableComponent', (state)=>state.document.components);
     const { value = [], error, rawError } = strapiAdmin.useField(name);
     const addFieldRow = strapiAdmin.useForm('RepeatableComponent', (state)=>state.addFieldRow);
     const moveFieldRow = strapiAdmin.useForm('RepeatableComponent', (state)=>state.moveFieldRow);
@@ -6906,7 +7967,7 @@ const RepeatableComponent = ({ attribute, disabled, name, mainField, children, l
         }));
     };
     const ariaDescriptionId = React__namespace.useId();
-    const level = Relations.useComponent('RepeatableComponent', (state)=>state.level);
+    const level = useComponent('RepeatableComponent', (state)=>state.level);
     if (value.length === 0) {
         return /*#__PURE__*/ jsxRuntime.jsx(Initializer, {
             disabled: disabled,
@@ -6936,7 +7997,7 @@ const RepeatableComponent = ({ attribute, disabled, name, mainField, children, l
                 children: [
                     value.map(({ __temp_key__: key, id }, index)=>{
                         const nameWithIndex = `${name}.${index}`;
-                        return /*#__PURE__*/ jsxRuntime.jsx(Relations.ComponentProvider, {
+                        return /*#__PURE__*/ jsxRuntime.jsx(ComponentProvider, {
                             // id is always a number in a component
                             id: id,
                             uid: attribute.component,
@@ -7052,8 +8113,8 @@ const Component = ({ disabled, index: index$1, name, mainField = {
    * components are not affected by the drag and drop of the parent component in
    * their own re-ordering context.
    */ const componentKey = name.split('.').slice(0, -1).join('.');
-    const [{ handlerId, isDragging, handleKeyDown }, boxRef, dropRef, dragRef, dragPreviewRef] = useDragAndDrop.useDragAndDrop(!disabled, {
-        type: `${useDragAndDrop.ItemTypes.COMPONENT}_${componentKey}`,
+    const [{ handlerId, isDragging, handleKeyDown }, boxRef, dropRef, dragRef, dragPreviewRef] = objects.useDragAndDrop(!disabled, {
+        type: `${objects.ItemTypes.COMPONENT}_${componentKey}`,
         index: index$1,
         item: {
             index: index$1,
@@ -7143,7 +8204,7 @@ const ComponentInput = ({ label, required, name, attribute, disabled, labelActio
     const { formatMessage } = reactIntl.useIntl();
     const field = strapiAdmin.useField(name);
     const showResetComponent = !attribute.repeatable && field.value && !disabled;
-    const { components } = index.useDoc();
+    const components = index.useDocumentContext('ComponentInput', (state)=>state.document.components);
     const handleInitialisationClick = ()=>{
         const schema = components[attribute.component];
         const form = index.createDefaultForm(schema, components);
@@ -7208,8 +8269,11 @@ const ComponentInput = ({ label, required, name, attribute, disabled, labelActio
 };
 const MemoizedComponentInput = /*#__PURE__*/ React__namespace.memo(ComponentInput);
 
+exports.DisconnectButton = DisconnectButton;
 exports.DynamicZone = DynamicZone;
+exports.FlexWrapper = FlexWrapper;
 exports.FormLayout = FormLayout;
+exports.LinkEllipsis = LinkEllipsis;
 exports.MemoizedBlocksInput = MemoizedBlocksInput;
 exports.MemoizedComponentInput = MemoizedComponentInput;
 exports.MemoizedUIDInput = MemoizedUIDInput;
@@ -7218,4 +8282,4 @@ exports.NotAllowedInput = NotAllowedInput;
 exports.useDynamicZone = useDynamicZone;
 exports.useFieldHint = useFieldHint;
 exports.useLazyComponents = useLazyComponents;
-//# sourceMappingURL=Input-DLJZHw9Y.js.map
+//# sourceMappingURL=Input-BJCenRYN.js.map