@akbarsafari00/bonyan-content-manager 5.52.1-fa.2

package/dist/admin/pages/EditView/components/DocumentActions.js

@@ -0,0 +1,1358 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var strapiAdmin = require('@strapi/admin/strapi-admin');
+var designSystem = require('@strapi/design-system');
+var Icons = require('@strapi/icons');
+var reactIntl = require('react-intl');
+var reactRouterDom = require('react-router-dom');
+var attributes = require('../../../constants/attributes.js');
+var collections = require('../../../constants/collections.js');
+var DocumentRBAC = require('../../../features/DocumentRBAC.js');
+var useDocument = require('../../../hooks/useDocument.js');
+var useDocumentActions = require('../../../hooks/useDocumentActions.js');
+var useDocumentContext = require('../../../hooks/useDocumentContext.js');
+var Preview = require('../../../preview/pages/Preview.js');
+var router = require('../../../router.js');
+var documents = require('../../../services/documents.js');
+var api = require('../../../utils/api.js');
+var objects = require('../../../utils/objects.js');
+var translations = require('../../../utils/translations.js');
+var data = require('../utils/data.js');
+var draftRelationCounts = require('../utils/draftRelationCounts.js');
+var keyboardShortcuts = require('../utils/keyboardShortcuts.js');
+var RelationModal = require('./FormInputs/Relations/RelationModal.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+const publishConfirmDialogOpeners = new Map();
+const openPublishConfirmDialog = (scope)=>{
+    publishConfirmDialogOpeners.get(scope)?.();
+};
+const connectRelationToParent = (parentDataToUpdate, fieldToConnect, data, fieldToConnectUID)=>{
+    const relationToConnect = {
+        id: data.documentId,
+        documentId: data.documentId,
+        locale: data.locale
+    };
+    /*
+   * Check if the fieldToConnect is already present in the parentDataToUpdate.
+   * This happens in particular when in the parentDocument you have created
+   * a new component without saving.
+   */ const fieldValue = objects.getIn(parentDataToUpdate, fieldToConnect);
+    const relationFieldValue = objects.isObject(fieldValue) ? fieldValue : undefined;
+    const isFieldPresent = relationFieldValue !== undefined;
+    const fieldPath = fieldToConnect.split('.');
+    const fieldName = fieldPath.at(-1);
+    if (!fieldName) {
+        return parentDataToUpdate;
+    }
+    const parentPath = fieldPath.slice(0, -1).join('.');
+    const existingConnect = Array.isArray(relationFieldValue?.connect) ? relationFieldValue.connect : [];
+    // A relation is identified by documentId and locale; numeric ids are not stable across locales.
+    const connect = existingConnect.some((relation)=>relation.documentId === relationToConnect.documentId && relation.locale === relationToConnect.locale) ? existingConnect : [
+        ...existingConnect,
+        relationToConnect
+    ];
+    const relationValue = isFieldPresent ? {
+        ...relationFieldValue,
+        connect
+    } : {
+        connect,
+        disconnect: []
+    };
+    const dataWithRelation = objects.setIn(parentDataToUpdate, fieldToConnect, relationValue);
+    if (!isFieldPresent && fieldToConnectUID && parentPath) {
+        return objects.setIn(dataWithRelation, `${parentPath}.__component`, fieldToConnectUID);
+    }
+    return dataWithRelation;
+};
+const DocumentActions = ({ actions })=>{
+    const { formatMessage } = reactIntl.useIntl();
+    const isDesktop = strapiAdmin.useIsDesktop();
+    const [primaryAction, secondaryAction, ...restActions] = actions.filter((action)=>{
+        if (action.position === undefined) {
+            return true;
+        }
+        const positions = Array.isArray(action.position) ? action.position : [
+            action.position
+        ];
+        return positions.includes('panel');
+    });
+    if (!primaryAction) {
+        return null;
+    }
+    const addHintTooltip = (action, children)=>{
+        if (action.disabled) {
+            return children;
+        }
+        const hint = action.type === 'publish' ? formatMessage({
+            id: 'content-manager.containers.EditView.publishHint',
+            defaultMessage: 'Ctrl / Cmd + Shift + Enter to publish'
+        }) : formatMessage({
+            id: 'content-manager.containers.EditView.saveHint',
+            defaultMessage: 'Ctrl / Cmd + Enter to save'
+        });
+        return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Tooltip, {
+            label: hint,
+            children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                width: "100%",
+                children: children
+            })
+        });
+    };
+    const primaryActionContent = /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                flex: 1,
+                alignItems: "stretch",
+                direction: "column",
+                children: addHintTooltip(primaryAction, /*#__PURE__*/ jsxRuntime.jsx(DocumentActionButton, {
+                    ...primaryAction,
+                    variant: primaryAction.variant || 'default',
+                    buttonType: primaryAction.type === 'publish' ? undefined : 'submit'
+                }))
+            }),
+            restActions.length > 0 ? /*#__PURE__*/ jsxRuntime.jsx(DocumentActionsMenu, {
+                actions: restActions,
+                label: formatMessage({
+                    id: 'content-manager.containers.edit.panels.default.more-actions',
+                    defaultMessage: 'More document actions'
+                })
+            }) : null
+        ]
+    });
+    return /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+        direction: {
+            initial: 'row',
+            large: 'column'
+        },
+        gap: 2,
+        alignItems: "stretch",
+        width: "100%",
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.tours.contentManager.Publish, {
+                children: isDesktop ? /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                    gap: 2,
+                    children: primaryActionContent
+                }) : primaryActionContent
+            }),
+            secondaryAction ? /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                flex: 1,
+                order: {
+                    initial: -1,
+                    large: 0
+                },
+                alignItems: "stretch",
+                direction: "column",
+                children: secondaryAction.type === 'publish' ? /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.tours.contentManager.Publish, {
+                    children: addHintTooltip(secondaryAction, /*#__PURE__*/ jsxRuntime.jsx(DocumentActionButton, {
+                        ...secondaryAction,
+                        variant: secondaryAction.variant || 'secondary'
+                    }))
+                }) : addHintTooltip(secondaryAction, /*#__PURE__*/ jsxRuntime.jsx(DocumentActionButton, {
+                    ...secondaryAction,
+                    variant: secondaryAction.variant || 'secondary',
+                    buttonType: "submit"
+                }))
+            }) : null
+        ]
+    });
+};
+const DocumentActionButton = ({ buttonType = 'button', ...action })=>{
+    const [dialogId, setDialogId] = React__namespace.useState(null);
+    const { toggleNotification } = strapiAdmin.useNotification();
+    React__namespace.useEffect(()=>{
+        const scope = action.publishConfirmScope;
+        if (action.type !== 'publish' || !action.dialog || !scope) {
+            return;
+        }
+        const open = ()=>setDialogId(action.id);
+        publishConfirmDialogOpeners.set(scope, open);
+        return ()=>{
+            if (publishConfirmDialogOpeners.get(scope) === open) {
+                publishConfirmDialogOpeners.delete(scope);
+            }
+        };
+    }, [
+        action.type,
+        action.dialog,
+        action.id,
+        action.publishConfirmScope
+    ]);
+    const handleClick = (action)=>async (e)=>{
+            const { onClick = ()=>false, dialog, id } = action;
+            const muteDialog = await onClick(e);
+            if (dialog && !muteDialog) {
+                switch(dialog.type){
+                    case 'notification':
+                        toggleNotification({
+                            title: dialog.title,
+                            message: dialog.content,
+                            type: dialog.status,
+                            timeout: dialog.timeout,
+                            onClose: dialog.onClose
+                        });
+                        break;
+                    case 'dialog':
+                    case 'modal':
+                        e.preventDefault();
+                        setDialogId(id);
+                }
+            }
+        };
+    const handleClose = ()=>{
+        setDialogId(null);
+    };
+    return /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
+                flex: "auto",
+                startIcon: action.icon,
+                disabled: action.disabled,
+                onClick: handleClick(action),
+                justifyContent: "center",
+                variant: action.variant || 'default',
+                paddingTop: "7px",
+                paddingBottom: "7px",
+                loading: action.loading,
+                type: buttonType,
+                children: action.label
+            }),
+            action.dialog?.type === 'dialog' ? /*#__PURE__*/ jsxRuntime.jsx(DocumentActionConfirmDialog, {
+                ...action.dialog,
+                variant: action.dialog?.variant ?? action.variant,
+                isOpen: dialogId === action.id,
+                onClose: handleClose
+            }) : null,
+            action.dialog?.type === 'modal' ? /*#__PURE__*/ jsxRuntime.jsx(DocumentActionModal, {
+                ...action.dialog,
+                onModalClose: handleClose,
+                isOpen: dialogId === action.id
+            }) : null
+        ]
+    });
+};
+const DocumentActionsMenu = ({ actions, children, label, variant = 'tertiary' })=>{
+    const [isOpen, setIsOpen] = React__namespace.useState(false);
+    const [dialogId, setDialogId] = React__namespace.useState(null);
+    const { formatMessage } = reactIntl.useIntl();
+    const { toggleNotification } = strapiAdmin.useNotification();
+    const isDisabled = actions.every((action)=>action.disabled);
+    const triggerRef = React__namespace.useRef(null);
+    const handleClick = (action)=>async (e)=>{
+            const { onClick = ()=>false, dialog, id } = action;
+            const muteDialog = await onClick(e);
+            if (dialog && !muteDialog) {
+                switch(dialog.type){
+                    case 'notification':
+                        toggleNotification({
+                            title: dialog.title,
+                            message: dialog.content,
+                            type: dialog.status,
+                            timeout: dialog.timeout,
+                            onClose: dialog.onClose
+                        });
+                        break;
+                    case 'dialog':
+                    case 'modal':
+                        setDialogId(id);
+                }
+            }
+        };
+    const handleClose = ()=>{
+        setDialogId(null);
+        setIsOpen(false);
+    };
+    const handleOpenChange = (open)=>{
+        if (!isDisabled) {
+            setIsOpen(open);
+        }
+    };
+    return /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Menu.Root, {
+        open: isOpen,
+        onOpenChange: handleOpenChange,
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Menu.Trigger, {
+                ref: triggerRef,
+                disabled: isDisabled,
+                label: label || formatMessage({
+                    id: 'content-manager.containers.edit.panels.default.more-actions',
+                    defaultMessage: 'More document actions'
+                }),
+                tag: designSystem.IconButton,
+                icon: /*#__PURE__*/ jsxRuntime.jsx(Icons.More, {}),
+                variant: variant
+            }),
+            /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Menu.Content, {
+                maxHeight: undefined,
+                popoverPlacement: "bottom-end",
+                maxWidth: "25rem",
+                children: [
+                    actions.map((action)=>{
+                        return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Menu.Item, {
+                            disabled: action.disabled,
+                            /* @ts-expect-error – TODO: this is an error in the DS where it is most likely a synthetic event, not regular. */ onSelect: handleClick(action),
+                            display: "block",
+                            variant: action.variant === 'danger' ? action.variant : 'default',
+                            startIcon: action.icon,
+                            children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                                justifyContent: "space-between",
+                                gap: 4,
+                                children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                                    gap: 2,
+                                    tag: "span",
+                                    children: action.label
+                                })
+                            })
+                        }, action.id);
+                    }),
+                    children
+                ]
+            }),
+            actions.map((action)=>{
+                return /*#__PURE__*/ jsxRuntime.jsxs(React__namespace.Fragment, {
+                    children: [
+                        action.dialog?.type === 'dialog' ? /*#__PURE__*/ jsxRuntime.jsx(DocumentActionConfirmDialog, {
+                            ...action.dialog,
+                            variant: action.variant,
+                            isOpen: dialogId === action.id,
+                            onClose: handleClose
+                        }) : null,
+                        action.dialog?.type === 'modal' ? /*#__PURE__*/ jsxRuntime.jsx(DocumentActionModal, {
+                            ...action.dialog,
+                            onModalClose: handleClose,
+                            isOpen: dialogId === action.id
+                        }) : null
+                    ]
+                }, action.id);
+            })
+        ]
+    });
+};
+const DocumentActionConfirmDialog = ({ onClose, onCancel, onConfirm, title, content, bodyIcon, confirmLabel, isOpen, variant = 'secondary', loading })=>{
+    const { formatMessage } = reactIntl.useIntl();
+    const handleClose = async ()=>{
+        if (onCancel) {
+            await onCancel();
+        }
+        onClose();
+    };
+    const handleConfirm = async ()=>{
+        if (onConfirm) {
+            await onConfirm();
+        }
+        onClose();
+    };
+    const dialogBody = bodyIcon ? /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+        direction: "column",
+        alignItems: "stretch",
+        gap: 2,
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
+                justifyContent: "center",
+                children: /*#__PURE__*/ jsxRuntime.jsx(Icons.WarningCircle, {
+                    width: "24px",
+                    height: "24px",
+                    fill: bodyIcon === 'danger' ? 'danger600' : 'primary600'
+                })
+            }),
+            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+                id: "confirm-description",
+                tag: "p",
+                variant: "omega",
+                textAlign: "center",
+                children: content
+            })
+        ]
+    }) : content;
+    return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Dialog.Root, {
+        open: isOpen,
+        onOpenChange: handleClose,
+        children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Dialog.Content, {
+            children: [
+                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Dialog.Header, {
+                    children: title
+                }),
+                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Dialog.Body, {
+                    children: dialogBody
+                }),
+                /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Dialog.Footer, {
+                    children: [
+                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Dialog.Cancel, {
+                            children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
+                                variant: "tertiary",
+                                fullWidth: true,
+                                children: formatMessage({
+                                    id: 'app.components.Button.cancel',
+                                    defaultMessage: 'Cancel'
+                                })
+                            })
+                        }),
+                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
+                            onClick: handleConfirm,
+                            variant: variant,
+                            fullWidth: true,
+                            loading: loading,
+                            children: confirmLabel ?? formatMessage({
+                                id: 'app.components.Button.confirm',
+                                defaultMessage: 'Confirm'
+                            })
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+};
+const DocumentActionModal = ({ isOpen, title, onClose, footer: Footer, content: Content, onModalClose })=>{
+    const handleClose = ()=>{
+        if (onClose) {
+            onClose();
+        }
+        onModalClose();
+    };
+    return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Modal.Root, {
+        open: isOpen,
+        onOpenChange: handleClose,
+        children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Modal.Content, {
+            children: [
+                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Modal.Header, {
+                    children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Modal.Title, {
+                        children: title
+                    })
+                }),
+                typeof Content === 'function' ? /*#__PURE__*/ jsxRuntime.jsx(Content, {
+                    onClose: handleClose
+                }) : /*#__PURE__*/ jsxRuntime.jsx(designSystem.Modal.Body, {
+                    children: Content
+                }),
+                typeof Footer === 'function' ? /*#__PURE__*/ jsxRuntime.jsx(Footer, {
+                    onClose: handleClose
+                }) : Footer
+            ]
+        })
+    });
+};
+const transformData = (data)=>{
+    if (Array.isArray(data)) {
+        return data.map((value)=>transformData(value));
+    }
+    if (typeof data === 'object' && data !== null) {
+        if ('apiData' in data) {
+            return data.apiData;
+        }
+        return Object.fromEntries(Object.entries(data).map(([key, value])=>[
+                key,
+                transformData(value)
+            ]));
+    }
+    return data;
+};
+const transformDocumentData = (data)=>transformData(data);
+const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentFormValues, options)=>{
+    const parentDataToUpdate = parentFormValues ?? fallbackParentFormValues;
+    if (!parentDataToUpdate) {
+        return parentDataToUpdate;
+    }
+    const { data: data$1 } = data.handleInvisibleAttributes(transformDocumentData(parentDataToUpdate), {
+        ...options,
+        // The live snapshot can omit saved invisible fields, so retain the parent's saved initial values.
+        initialValues: fallbackParentFormValues
+    });
+    return data$1;
+};
+/* -------------------------------------------------------------------------------------------------
+ * DocumentActionComponents
+ * -----------------------------------------------------------------------------------------------*/ const PublishAction = ({ activeTab, documentId, model, collectionType, meta, document })=>{
+    const { currentDocument: { schema } } = useDocumentContext.useDocumentContext('PublishAction');
+    const navigate = reactRouterDom.useNavigate();
+    const { toggleNotification } = strapiAdmin.useNotification();
+    const { _unstableFormatValidationErrors: formatValidationErrors } = strapiAdmin.useAPIErrorHandler();
+    const isListView = reactRouterDom.useMatch(router.LIST_PATH) !== null;
+    const isCloning = reactRouterDom.useMatch(router.CLONE_PATH) !== null;
+    const { id } = reactRouterDom.useParams();
+    const { formatMessage } = reactIntl.useIntl();
+    const { canPublish, canReadFields } = DocumentRBAC.useDocumentRBAC('PublishAction', ({ canPublish, canReadFields })=>({
+            canPublish,
+            canReadFields
+        }));
+    const { publish, isLoading } = useDocumentActions.useDocumentActions();
+    const onPreview = Preview.usePreviewContext('PublishAction', (state)=>state.onPreview, false);
+    const [countDraftRelations, { isError: isErrorDraftRelations }] = documents.useGetDraftRelationCountQuery();
+    const [localDraftRelationCounts, setLocalDraftRelationCounts] = React__namespace.useState(draftRelationCounts.EMPTY_DRAFT_RELATION_COUNTS);
+    const [serverDraftRelationCounts, setServerDraftRelationCounts] = React__namespace.useState(draftRelationCounts.EMPTY_DRAFT_RELATION_COUNTS);
+    const [isFetchingDraftRelations, setIsFetchingDraftRelations] = React__namespace.useState(false);
+    const [{ rawQuery }] = strapiAdmin.useQueryParams();
+    const modified = strapiAdmin.useForm('PublishAction', ({ modified })=>modified);
+    const setSubmitting = strapiAdmin.useForm('PublishAction', ({ setSubmitting })=>setSubmitting);
+    const isSubmitting = strapiAdmin.useForm('PublishAction', ({ isSubmitting })=>isSubmitting);
+    const validate = strapiAdmin.useForm('PublishAction', (state)=>state.validate);
+    const setErrors = strapiAdmin.useForm('PublishAction', (state)=>state.setErrors);
+    const getValues = strapiAdmin.useForm('PublishAction', (state)=>state.getValues);
+    const formValues = strapiAdmin.useForm('PublishAction', ({ values })=>values);
+    const resetForm = strapiAdmin.useForm('PublishAction', ({ resetForm })=>resetForm);
+    const { currentDocument: { components } } = useDocumentContext.useDocumentContext('PublishAction');
+    // need to discriminate if the publish is coming from a relation modal or in the edit view
+    const relationContext = RelationModal.useRelationModal('PublishAction', ()=>true, false);
+    const fromRelationModal = relationContext != undefined;
+    const isRelationModalOpen = RelationModal.useRelationModal('PublishAction', (state)=>state.state.isModalOpen, false);
+    const publishConfirmScope = fromRelationModal ? 'relation-modal' : onPreview ? 'preview' : 'panel';
+    const dispatch = RelationModal.useRelationModal('PublishAction', (state)=>state.dispatch);
+    const fieldToConnect = RelationModal.useRelationModal('PublishAction', (state)=>state.state.fieldToConnect, false);
+    const fieldToConnectUID = RelationModal.useRelationModal('PublishAction', (state)=>state.state.fieldToConnectUID, false);
+    const getParentFormValues = RelationModal.useRelationModal('PublishAction', (state)=>state.state.getParentFormValues, false);
+    const documentHistory = RelationModal.useRelationModal('PublishAction', (state)=>state.state.documentHistory, false);
+    const rootDocumentMeta = RelationModal.useRelationModal('PublishAction', (state)=>state.rootDocumentMeta);
+    const dispatchGuidedTour = strapiAdmin.useGuidedTour('PublishAction', (s)=>s.dispatch);
+    const { currentDocumentMeta } = useDocumentContext.useDocumentContext('PublishAction');
+    const [updateDocumentMutation] = documents.useUpdateDocumentMutation();
+    const { _unstableFormatAPIError: formatAPIError } = strapiAdmin.useAPIErrorHandler();
+    const idToPublish = currentDocumentMeta.documentId || id;
+    React__namespace.useEffect(()=>{
+        if (isErrorDraftRelations) {
+            toggleNotification({
+                type: 'danger',
+                message: formatMessage({
+                    id: translations.getTranslation('error.records.fetch-draft-relatons'),
+                    defaultMessage: 'An error occurred while fetching draft relations on this document.'
+                })
+            });
+        }
+    }, [
+        isErrorDraftRelations,
+        toggleNotification,
+        formatMessage
+    ]);
+    React__namespace.useEffect(()=>{
+        setLocalDraftRelationCounts(draftRelationCounts.countLocalDraftRelations(formValues, schema, components, model));
+    }, [
+        components,
+        formValues,
+        model,
+        schema
+    ]);
+    const fetchDraftRelationsCount = React__namespace.useCallback(async ()=>{
+        if (!document?.documentId || isListView || !schema?.options?.draftAndPublish) {
+            return;
+        }
+        setIsFetchingDraftRelations(true);
+        try {
+            const { data, error } = await countDraftRelations({
+                collectionType,
+                model,
+                documentId,
+                params: currentDocumentMeta.params
+            });
+            if (error) {
+                throw error;
+            }
+            if (data) {
+                setServerDraftRelationCounts(draftRelationCounts.normalizeDraftRelationCounts(data));
+            }
+        } finally{
+            setIsFetchingDraftRelations(false);
+        }
+    }, [
+        collectionType,
+        countDraftRelations,
+        currentDocumentMeta.params,
+        document?.documentId,
+        documentId,
+        isListView,
+        model,
+        schema?.options?.draftAndPublish
+    ]);
+    React__namespace.useEffect(()=>{
+        fetchDraftRelationsCount();
+    }, [
+        fetchDraftRelationsCount,
+        document?.updatedAt
+    ]);
+    React__namespace.useEffect(()=>{
+        const handleWindowFocus = ()=>{
+            fetchDraftRelationsCount();
+        };
+        window.addEventListener('focus', handleWindowFocus);
+        return ()=>{
+            window.removeEventListener('focus', handleWindowFocus);
+        };
+    }, [
+        fetchDraftRelationsCount
+    ]);
+    const parentDocumentMetaToUpdate = documentHistory?.at(-2) ?? rootDocumentMeta;
+    const parentDocumentData = useDocument.useDocument({
+        documentId: parentDocumentMetaToUpdate?.documentId,
+        model: parentDocumentMetaToUpdate?.model,
+        collectionType: parentDocumentMetaToUpdate?.collectionType,
+        params: parentDocumentMetaToUpdate?.params
+    }, {
+        skip: !parentDocumentMetaToUpdate
+    });
+    const { getInitialFormValues } = useDocument.useDoc();
+    const isDocumentPublished = (document?.[attributes.PUBLISHED_AT_ATTRIBUTE_NAME] || meta?.availableStatus.some((doc)=>doc[attributes.PUBLISHED_AT_ATTRIBUTE_NAME] !== null)) && document?.status !== 'modified';
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const performPublish = async ()=>{
+        setSubmitting(true);
+        try {
+            /**
+       * Yield one microtask so React can flush any pending field updates from the same task
+       * (common with fast local runners / Playwright) before we read values and validate.
+       * TODO: replace with an explicit form flush contract when we can (same concern as Save flow).
+       */ await Promise.resolve();
+            const { errors } = await validate(true, {
+                status: 'published'
+            });
+            if (errors) {
+                const hasUnreadableRequiredField = schema && Object.keys(schema.attributes).some((fieldName)=>{
+                    const attribute = schema.attributes[fieldName];
+                    // For components, check if any of the component fields are readable
+                    if (attribute.type === 'component') {
+                        const componentFields = (canReadFields ?? []).filter((field)=>field.startsWith(`${fieldName}.`));
+                        return componentFields.length === 0;
+                    }
+                    // For regular fields, check if the field itself is readable
+                    return attribute?.required && !(canReadFields ?? []).includes(fieldName);
+                });
+                if (hasUnreadableRequiredField) {
+                    toggleNotification({
+                        type: 'danger',
+                        message: formatMessage({
+                            id: 'content-manager.validation.error.unreadable-required-field',
+                            defaultMessage: 'Your current permissions prevent access to certain required fields. Please request access from an administrator to proceed.'
+                        })
+                    });
+                } else {
+                    toggleNotification({
+                        type: 'danger',
+                        message: formatMessage({
+                            id: 'content-manager.validation.error',
+                            defaultMessage: 'There are validation errors in your document. Please fix them before saving.'
+                        })
+                    });
+                }
+                return;
+            }
+            const { data: data$1 } = data.handleInvisibleAttributes(transformDocumentData(getValues()), {
+                schema,
+                components
+            });
+            const res = await publish({
+                collectionType,
+                model,
+                documentId,
+                params: currentDocumentMeta.params
+            }, data$1);
+            // Reset form with current values as new initial values (clears errors/submitting and sets modified to false)
+            if ('data' in res) {
+                resetForm(getValues());
+                dispatchGuidedTour({
+                    type: 'set_completed_actions',
+                    payload: [
+                        strapiAdmin.GUIDED_TOUR_REQUIRED_ACTIONS.contentManager.createContent
+                    ]
+                });
+            }
+            if ('data' in res && collectionType !== collections.SINGLE_TYPES) {
+                /**
+         * TODO: refactor the router so we can just do `../${res.data.documentId}` instead of this.
+         */ if (idToPublish === 'create' && !fromRelationModal) {
+                    navigate({
+                        pathname: `../${collectionType}/${model}/${res.data.documentId}`,
+                        search: rawQuery
+                    });
+                } else if (fromRelationModal) {
+                    const newRelation = {
+                        documentId: res.data.documentId,
+                        collectionType,
+                        model,
+                        params: currentDocumentMeta.params
+                    };
+                    /*
+           * Update, if needed, the parent relation with the newly published document.
+           * Check if in history we have the parent relation otherwise use the
+           * rootDocument
+           */ if (fieldToConnect && documentHistory && (parentDocumentMetaToUpdate.documentId || parentDocumentMetaToUpdate.collectionType === collections.SINGLE_TYPES)) {
+                        const fallbackParentFormValues = parentDocumentMetaToUpdate.collectionType === collections.SINGLE_TYPES ? getInitialFormValues() : parentDocumentData.getInitialFormValues();
+                        const parentDataToUpdate = prepareParentDataForRelationUpdate(getParentFormValues?.(), fallbackParentFormValues, {
+                            schema: parentDocumentData.schema,
+                            components: parentDocumentData.components
+                        });
+                        const metaDocumentToUpdate = documentHistory.at(-2) ?? rootDocumentMeta;
+                        if (parentDataToUpdate) {
+                            const dataToUpdate = connectRelationToParent(parentDataToUpdate, fieldToConnect, res.data, fieldToConnectUID);
+                            try {
+                                const updateRes = await updateDocumentMutation({
+                                    collectionType: metaDocumentToUpdate.collectionType,
+                                    model: metaDocumentToUpdate.model,
+                                    documentId: metaDocumentToUpdate.collectionType !== collections.SINGLE_TYPES ? metaDocumentToUpdate.documentId : undefined,
+                                    params: metaDocumentToUpdate.params,
+                                    data: dataToUpdate
+                                });
+                                if ('error' in updateRes) {
+                                    toggleNotification({
+                                        type: 'danger',
+                                        message: formatAPIError(updateRes.error)
+                                    });
+                                    return;
+                                }
+                            } catch (err) {
+                                toggleNotification({
+                                    type: 'danger',
+                                    message: formatMessage({
+                                        id: 'notification.error',
+                                        defaultMessage: 'An error occurred'
+                                    })
+                                });
+                                throw err;
+                            }
+                        }
+                    }
+                    dispatch({
+                        type: 'GO_TO_CREATED_RELATION',
+                        payload: {
+                            document: newRelation,
+                            shouldBypassConfirmation: true
+                        }
+                    });
+                }
+            } else if ('error' in res && api.isBaseQueryError(res.error) && res.error.name === 'ValidationError') {
+                setErrors(formatValidationErrors(res.error));
+            }
+        } finally{
+            setSubmitting(false);
+            if (onPreview) {
+                onPreview();
+            }
+        }
+    };
+    const getFreshDraftRelationCounts = React__namespace.useCallback(()=>draftRelationCounts.resolveDraftRelationCounts(documentId, modified, draftRelationCounts.countLocalDraftRelations(getValues(), schema, components, model), serverDraftRelationCounts), [
+        components,
+        documentId,
+        getValues,
+        model,
+        modified,
+        schema,
+        serverDraftRelationCounts
+    ]);
+    const draftRelationCounts$1 = draftRelationCounts.resolveDraftRelationCounts(documentId, modified, localDraftRelationCounts, serverDraftRelationCounts);
+    const { hasUnpublishedRelations, hasDraftM2mLinks, dialogVariant, bodyIcon, confirmLabel } = draftRelationCounts.getDraftRelationsPublishState(draftRelationCounts$1);
+    const supportsDraftRelationWarning = Boolean(schema?.options?.draftAndPublish);
+    /**
+   * Disabled when:
+   *  - currently if you're cloning a document we don't support publish & clone at the same time.
+   *  - the form is submitting
+   *  - the active tab is the published tab
+   *  - the document is already published & not modified
+   *  - the document is being created & not modified
+   *  - the user doesn't have the permission to publish
+   */ const isDisabled = isCloning || isSubmitting || isFetchingDraftRelations || activeTab === 'published' || !modified && isDocumentPublished || !modified && !document?.documentId || !canPublish;
+    // Publish on CMD+Shift+Enter (macOS) / CTRL+Shift+Enter (Windows/Linux).
+    // Saving a draft (CMD/CTRL+Enter) is handled by the UpdateAction.
+    React__namespace.useEffect(()=>{
+        if (!schema?.options?.draftAndPublish) {
+            return;
+        }
+        const handleKeyDown = (e)=>{
+            if (keyboardShortcuts.getEditViewShortcut(e) !== 'publish') {
+                return;
+            }
+            e.preventDefault();
+            if (!fromRelationModal && isRelationModalOpen) {
+                return;
+            }
+            if (isDisabled) {
+                return;
+            }
+            if (draftRelationCounts.getDraftRelationsPublishState(getFreshDraftRelationCounts()).hasDraftRelations) {
+                openPublishConfirmDialog(publishConfirmScope);
+                return;
+            }
+            performPublish();
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        return ()=>{
+            window.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [
+        fromRelationModal,
+        getFreshDraftRelationCounts,
+        isDisabled,
+        isRelationModalOpen,
+        performPublish,
+        publishConfirmScope,
+        schema?.options?.draftAndPublish
+    ]);
+    if (!schema?.options?.draftAndPublish) {
+        return null;
+    }
+    return {
+        type: 'publish',
+        loading: isLoading,
+        position: [
+            'panel',
+            'preview',
+            'relation-modal'
+        ],
+        disabled: isDisabled,
+        publishConfirmScope: supportsDraftRelationWarning ? publishConfirmScope : undefined,
+        label: formatMessage({
+            id: 'app.utils.publish',
+            defaultMessage: 'Publish'
+        }),
+        onClick: async ()=>{
+            if (draftRelationCounts.getDraftRelationsPublishState(getFreshDraftRelationCounts()).hasDraftRelations) {
+                // Let DocumentActionButton open the confirmation dialog.
+                return;
+            }
+            await performPublish();
+            // Skip the registered dialog when publishing directly.
+            return true;
+        },
+        dialog: supportsDraftRelationWarning ? {
+            type: 'dialog',
+            variant: dialogVariant,
+            bodyIcon,
+            title: formatMessage({
+                id: translations.getTranslation('popUpWarning.warning.has-draft-relations.title'),
+                defaultMessage: 'Confirmation'
+            }),
+            content: /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+                children: [
+                    hasUnpublishedRelations ? formatMessage({
+                        id: translations.getTranslation('popUpWarning.warning.has-draft-relations.message'),
+                        defaultMessage: 'This entry is related to {count, plural, one {# draft entry} other {# draft entries}}. {count, plural, one {That relation will not be included in the published version.} other {Those relations will not be included in the published version.}}'
+                    }, {
+                        count: draftRelationCounts$1.unpublishedRelations
+                    }) : formatMessage({
+                        id: translations.getTranslation('popUpWarning.warning.has-draft-m2m-relations.message'),
+                        defaultMessage: '{count, plural, one {# linked entry is still in draft. It will appear on the live site once that entry is published.} other {# linked entries are still in draft. They will appear on the live site once those entries are published.}}'
+                    }, {
+                        count: draftRelationCounts$1.draftM2mLinks
+                    }),
+                    hasUnpublishedRelations && hasDraftM2mLinks ? ` ${formatMessage({
+                        id: translations.getTranslation('popUpWarning.warning.has-draft-m2m-relations.additional'),
+                        defaultMessage: '{count, plural, one {# many-to-many link points} other {# many-to-many links point}} to draft entries that will become visible once published.'
+                    }, {
+                        count: draftRelationCounts$1.draftM2mLinks
+                    })}` : null,
+                    ' ',
+                    formatMessage({
+                        id: translations.getTranslation('popUpWarning.warning.publish-question'),
+                        defaultMessage: 'Do you still want to publish?'
+                    })
+                ]
+            }),
+            confirmLabel: confirmLabel === 'publish' ? formatMessage({
+                id: 'app.utils.publish',
+                defaultMessage: 'Publish'
+            }) : formatMessage({
+                id: translations.getTranslation('popUpwarning.warning.has-draft-relations.button-confirm'),
+                defaultMessage: 'Publish without relations'
+            }),
+            onConfirm: async ()=>{
+                await performPublish();
+            }
+        } : undefined
+    };
+};
+PublishAction.type = 'publish';
+PublishAction.position = [
+    'panel',
+    'preview',
+    'relation-modal'
+];
+const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
+    const dispatchGuidedTour = strapiAdmin.useGuidedTour('UpdateAction', (s)=>s.dispatch);
+    const navigate = reactRouterDom.useNavigate();
+    const { toggleNotification } = strapiAdmin.useNotification();
+    const { _unstableFormatValidationErrors: formatValidationErrors } = strapiAdmin.useAPIErrorHandler();
+    const cloneMatch = reactRouterDom.useMatch(router.CLONE_PATH);
+    const isCloning = cloneMatch !== null;
+    const { formatMessage } = reactIntl.useIntl();
+    const { create, update, clone, isLoading } = useDocumentActions.useDocumentActions();
+    const { currentDocument: { components } } = useDocumentContext.useDocumentContext('UpdateAction');
+    const [{ rawQuery }] = strapiAdmin.useQueryParams();
+    const onPreview = Preview.usePreviewContext('UpdateAction', (state)=>state.onPreview, false);
+    const { getInitialFormValues } = useDocument.useDoc();
+    const isSubmitting = strapiAdmin.useForm('UpdateAction', ({ isSubmitting })=>isSubmitting);
+    const modified = strapiAdmin.useForm('UpdateAction', ({ modified })=>modified);
+    const setSubmitting = strapiAdmin.useForm('UpdateAction', ({ setSubmitting })=>setSubmitting);
+    const initialValues = strapiAdmin.useForm('UpdateAction', ({ initialValues })=>initialValues);
+    const getValues = strapiAdmin.useForm('UpdateAction', (state)=>state.getValues);
+    const validate = strapiAdmin.useForm('UpdateAction', (state)=>state.validate);
+    const setErrors = strapiAdmin.useForm('UpdateAction', (state)=>state.setErrors);
+    const resetForm = strapiAdmin.useForm('UpdateAction', ({ resetForm })=>resetForm);
+    const dispatch = RelationModal.useRelationModal('UpdateAction', (state)=>state.dispatch);
+    // need to discriminate if the update is coming from a relation modal or in the edit view
+    const relationContext = RelationModal.useRelationModal('UpdateAction', ()=>true, false);
+    const relationalModalSchema = RelationModal.useRelationModal('UpdateAction', (state)=>state.currentDocument.schema, false);
+    const fieldToConnect = RelationModal.useRelationModal('UpdateAction', (state)=>state.state.fieldToConnect, false);
+    const fieldToConnectUID = RelationModal.useRelationModal('PublishAction', (state)=>state.state.fieldToConnectUID, false);
+    const getParentFormValues = RelationModal.useRelationModal('UpdateAction', (state)=>state.state.getParentFormValues, false);
+    const documentHistory = RelationModal.useRelationModal('UpdateAction', (state)=>state.state.documentHistory, false);
+    const rootDocumentMeta = RelationModal.useRelationModal('UpdateAction', (state)=>state.rootDocumentMeta);
+    const fromRelationModal = relationContext != undefined;
+    const { currentDocumentMeta } = useDocumentContext.useDocumentContext('UpdateAction');
+    const [updateDocumentMutation] = documents.useUpdateDocumentMutation();
+    const { _unstableFormatAPIError: formatAPIError } = strapiAdmin.useAPIErrorHandler();
+    const parentDocumentMetaToUpdate = documentHistory?.at(-2) ?? rootDocumentMeta;
+    const parentDocumentData = useDocument.useDocument({
+        documentId: parentDocumentMetaToUpdate?.documentId,
+        model: parentDocumentMetaToUpdate?.model,
+        collectionType: parentDocumentMetaToUpdate?.collectionType,
+        params: parentDocumentMetaToUpdate?.params
+    }, {
+        skip: !parentDocumentMetaToUpdate
+    });
+    const { schema } = useDocument.useDoc();
+    const suitableSchema = fromRelationModal ? relationalModalSchema : schema;
+    const hasDraftAndPublished = suitableSchema?.options?.draftAndPublish ?? false;
+    /**
+   * Disabled when:
+   * - the form is submitting
+   * - the document is not modified & we're not cloning (you can save a clone entity straight away)
+   * - the active tab is the published tab
+   */ const isDisabled = isSubmitting || !modified && !isCloning || activeTab === 'published';
+    const handleUpdate = async ()=>{
+        setSubmitting(true);
+        try {
+            if (!modified) {
+                return;
+            }
+            // Blur the active element so inputs that debounce into the form (e.g. blocks editor) flush
+            // before validate/getValues — on fast clients Save can otherwise read stale field state.
+            // Use the global DOM document — form values are not in scope here (avoid shadowing `document`).
+            globalThis.document?.activeElement?.blur();
+            // Yield microtasks so batched React updates after blur/onChange can settle before validate
+            // (same idea as performPublish; two ticks vs one gives a bit more room after focus/blur).
+            // TODO: replace with an explicit field/form flush contract when available.
+            await Promise.resolve();
+            await Promise.resolve();
+            const { errors } = await validate(true, {
+                // enforce "published" validation if not using "draft and published"
+                status: !hasDraftAndPublished ? 'published' : 'draft'
+            });
+            if (errors) {
+                toggleNotification({
+                    type: 'danger',
+                    message: formatMessage({
+                        id: 'content-manager.validation.error',
+                        defaultMessage: 'There are validation errors in your document. Please fix them before saving.'
+                    })
+                });
+                return;
+            }
+            const latestValues = getValues();
+            if (isCloning) {
+                const res = await clone({
+                    model,
+                    documentId: cloneMatch.params.origin,
+                    params: currentDocumentMeta.params
+                }, transformDocumentData(latestValues));
+                if ('data' in res) {
+                    navigate({
+                        pathname: `../${res.data.documentId}`,
+                        search: rawQuery
+                    }, {
+                        relative: 'path'
+                    });
+                } else if ('error' in res && api.isBaseQueryError(res.error) && res.error.name === 'ValidationError') {
+                    setErrors(formatValidationErrors(res.error));
+                }
+            } else if (documentId || collectionType === collections.SINGLE_TYPES) {
+                const { data: data$1 } = data.handleInvisibleAttributes(transformDocumentData(latestValues), {
+                    schema: suitableSchema,
+                    initialValues,
+                    components
+                });
+                const res = await update({
+                    collectionType,
+                    model,
+                    documentId,
+                    params: currentDocumentMeta.params
+                }, data$1);
+                if ('error' in res && api.isBaseQueryError(res.error) && res.error.name === 'ValidationError') {
+                    setErrors(formatValidationErrors(res.error));
+                } else {
+                    resetForm(latestValues);
+                }
+            } else {
+                const { data: data$1 } = data.handleInvisibleAttributes(transformDocumentData(latestValues), {
+                    schema: suitableSchema,
+                    initialValues,
+                    components
+                });
+                const res = await create({
+                    model,
+                    params: currentDocumentMeta.params
+                }, data$1);
+                if ('data' in res && collectionType !== collections.SINGLE_TYPES) {
+                    if (fromRelationModal) {
+                        const createdRelation = {
+                            documentId: res.data.documentId,
+                            collectionType,
+                            model,
+                            params: currentDocumentMeta.params
+                        };
+                        /*
+             * Update, if needed, the parent relation with the newly published document.
+             * Check if in history we have the parent relation otherwise use the
+             * rootDocument
+             */ if (fieldToConnect && documentHistory && (parentDocumentMetaToUpdate.documentId || parentDocumentMetaToUpdate.collectionType === collections.SINGLE_TYPES)) {
+                            const fallbackParentFormValues = parentDocumentMetaToUpdate.collectionType === collections.SINGLE_TYPES ? getInitialFormValues() : parentDocumentData.getInitialFormValues();
+                            const parentDataToUpdate = prepareParentDataForRelationUpdate(getParentFormValues?.(), fallbackParentFormValues, {
+                                schema: parentDocumentData.schema,
+                                components: parentDocumentData.components
+                            });
+                            if (parentDataToUpdate) {
+                                const dataToUpdate = connectRelationToParent(parentDataToUpdate, fieldToConnect, res.data, fieldToConnectUID);
+                                try {
+                                    const updateRes = await updateDocumentMutation({
+                                        collectionType: parentDocumentMetaToUpdate.collectionType,
+                                        model: parentDocumentMetaToUpdate.model,
+                                        documentId: parentDocumentMetaToUpdate.collectionType !== collections.SINGLE_TYPES ? parentDocumentMetaToUpdate.documentId : undefined,
+                                        params: parentDocumentMetaToUpdate.params,
+                                        data: {
+                                            ...dataToUpdate
+                                        }
+                                    });
+                                    if ('error' in updateRes) {
+                                        toggleNotification({
+                                            type: 'danger',
+                                            message: formatAPIError(updateRes.error)
+                                        });
+                                        return;
+                                    }
+                                } catch (err) {
+                                    toggleNotification({
+                                        type: 'danger',
+                                        message: formatMessage({
+                                            id: 'notification.error',
+                                            defaultMessage: 'An error occurred'
+                                        })
+                                    });
+                                    throw err;
+                                }
+                            }
+                        }
+                        dispatch({
+                            type: 'GO_TO_CREATED_RELATION',
+                            payload: {
+                                document: createdRelation,
+                                shouldBypassConfirmation: true
+                            }
+                        });
+                    } else {
+                        navigate({
+                            pathname: `../${res.data.documentId}`,
+                            search: rawQuery
+                        }, {
+                            replace: true,
+                            relative: 'path'
+                        });
+                    }
+                } else if ('error' in res && api.isBaseQueryError(res.error) && res.error.name === 'ValidationError') {
+                    setErrors(formatValidationErrors(res.error));
+                }
+            }
+        } finally{
+            dispatchGuidedTour({
+                type: 'set_completed_actions',
+                payload: [
+                    strapiAdmin.GUIDED_TOUR_REQUIRED_ACTIONS.contentManager.createContent
+                ]
+            });
+            setSubmitting(false);
+            if (onPreview) {
+                onPreview();
+            }
+        }
+    };
+    // Save a draft on CMD+Enter (macOS) / CTRL+Enter (Windows/Linux), with CMD/CTRL+S as an alias.
+    // Publishing (CMD/CTRL+Shift+Enter) is handled by the PublishAction.
+    // `handleUpdate` is recreated on every render, so we read the latest version (and the latest
+    // disabled state) through refs and register the listener only once.
+    const handleUpdateRef = React__namespace.useRef(handleUpdate);
+    handleUpdateRef.current = handleUpdate;
+    const isDisabledRef = React__namespace.useRef(isDisabled);
+    isDisabledRef.current = isDisabled;
+    React__namespace.useEffect(()=>{
+        const handleKeyDown = (e)=>{
+            if (keyboardShortcuts.getEditViewShortcut(e) !== 'save') {
+                return;
+            }
+            e.preventDefault();
+            if (!isDisabledRef.current) {
+                handleUpdateRef.current();
+            }
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        return ()=>{
+            window.removeEventListener('keydown', handleKeyDown);
+        };
+    }, []);
+    return {
+        loading: isLoading,
+        disabled: isDisabled,
+        label: formatMessage({
+            id: 'global.save',
+            defaultMessage: 'Save'
+        }),
+        onClick: handleUpdate,
+        position: [
+            'panel',
+            'preview',
+            'relation-modal'
+        ]
+    };
+};
+UpdateAction.type = 'update';
+UpdateAction.position = [
+    'panel',
+    'preview',
+    'relation-modal'
+];
+const UNPUBLISH_DRAFT_OPTIONS = {
+    KEEP: 'keep',
+    DISCARD: 'discard'
+};
+const UnpublishAction = ({ activeTab, documentId, model, collectionType, document })=>{
+    const { formatMessage } = reactIntl.useIntl();
+    const { schema } = useDocument.useDoc();
+    const canPublish = DocumentRBAC.useDocumentRBAC('UnpublishAction', ({ canPublish })=>canPublish);
+    const { unpublish } = useDocumentActions.useDocumentActions();
+    const [{ query }] = strapiAdmin.useQueryParams();
+    const params = React__namespace.useMemo(()=>api.buildValidParams(query), [
+        query
+    ]);
+    const { toggleNotification } = strapiAdmin.useNotification();
+    const [shouldKeepDraft, setShouldKeepDraft] = React__namespace.useState(true);
+    const isDocumentModified = document?.status === 'modified';
+    const handleChange = (value)=>{
+        setShouldKeepDraft(value === UNPUBLISH_DRAFT_OPTIONS.KEEP);
+    };
+    if (!schema?.options?.draftAndPublish) {
+        return null;
+    }
+    return {
+        disabled: !canPublish || activeTab === 'published' || document?.status !== 'published' && document?.status !== 'modified',
+        label: formatMessage({
+            id: 'app.utils.unpublish',
+            defaultMessage: 'Unpublish'
+        }),
+        icon: /*#__PURE__*/ jsxRuntime.jsx(Icons.Cross, {}),
+        onClick: async ()=>{
+            /**
+       * return if there's no id & we're in a collection type, or the status modified
+       * for either collection type because we use a dialog to handle the process in
+       * the latter case.
+       */ if (!documentId && collectionType !== collections.SINGLE_TYPES || isDocumentModified) {
+                if (!documentId) {
+                    // This should never, ever, happen.
+                    console.error("You're trying to unpublish a document without an id, this is likely a bug with Strapi. Please open an issue.");
+                    toggleNotification({
+                        message: formatMessage({
+                            id: 'content-manager.actions.unpublish.error',
+                            defaultMessage: 'An error occurred while trying to unpublish the document.'
+                        }),
+                        type: 'danger'
+                    });
+                }
+                return;
+            }
+            await unpublish({
+                collectionType,
+                model,
+                documentId,
+                params
+            });
+        },
+        dialog: isDocumentModified ? {
+            type: 'dialog',
+            title: formatMessage({
+                id: 'app.components.ConfirmDialog.title',
+                defaultMessage: 'Confirmation'
+            }),
+            content: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                alignItems: "flex-start",
+                direction: "column",
+                gap: 6,
+                children: [
+                    /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                        width: "100%",
+                        direction: "column",
+                        gap: 2,
+                        children: [
+                            /*#__PURE__*/ jsxRuntime.jsx(Icons.WarningCircle, {
+                                width: "24px",
+                                height: "24px",
+                                fill: "danger600"
+                            }),
+                            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+                                tag: "p",
+                                variant: "omega",
+                                textAlign: "center",
+                                children: formatMessage({
+                                    id: 'content-manager.actions.unpublish.dialog.body',
+                                    defaultMessage: 'Are you sure?'
+                                })
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Radio.Group, {
+                        defaultValue: UNPUBLISH_DRAFT_OPTIONS.KEEP,
+                        name: "discard-options",
+                        "aria-label": formatMessage({
+                            id: 'content-manager.actions.unpublish.dialog.radio-label',
+                            defaultMessage: 'Choose an option to unpublish the document.'
+                        }),
+                        onValueChange: handleChange,
+                        children: [
+                            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Radio.Item, {
+                                checked: shouldKeepDraft,
+                                value: UNPUBLISH_DRAFT_OPTIONS.KEEP,
+                                children: formatMessage({
+                                    id: 'content-manager.actions.unpublish.dialog.option.keep-draft',
+                                    defaultMessage: 'Keep draft'
+                                })
+                            }),
+                            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Radio.Item, {
+                                checked: !shouldKeepDraft,
+                                value: UNPUBLISH_DRAFT_OPTIONS.DISCARD,
+                                children: formatMessage({
+                                    id: 'content-manager.actions.unpublish.dialog.option.replace-draft',
+                                    defaultMessage: 'Replace draft'
+                                })
+                            })
+                        ]
+                    })
+                ]
+            }),
+            onConfirm: async ()=>{
+                if (!documentId && collectionType !== collections.SINGLE_TYPES) {
+                    // This should never, ever, happen.
+                    console.error("You're trying to unpublish a document without an id, this is likely a bug with Strapi. Please open an issue.");
+                    toggleNotification({
+                        message: formatMessage({
+                            id: 'content-manager.actions.unpublish.error',
+                            defaultMessage: 'An error occurred while trying to unpublish the document.'
+                        }),
+                        type: 'danger'
+                    });
+                }
+                await unpublish({
+                    collectionType,
+                    model,
+                    documentId,
+                    params
+                }, !shouldKeepDraft);
+            }
+        } : undefined,
+        variant: 'danger',
+        position: [
+            'panel',
+            'table-row'
+        ]
+    };
+};
+UnpublishAction.type = 'unpublish';
+UnpublishAction.position = 'panel';
+const DiscardAction = ({ activeTab, documentId, model, collectionType, document })=>{
+    const { formatMessage } = reactIntl.useIntl();
+    const { schema } = useDocument.useDoc();
+    const canUpdate = DocumentRBAC.useDocumentRBAC('DiscardAction', ({ canUpdate })=>canUpdate);
+    const { discard, isLoading } = useDocumentActions.useDocumentActions();
+    const [{ query }] = strapiAdmin.useQueryParams();
+    const params = React__namespace.useMemo(()=>api.buildValidParams(query), [
+        query
+    ]);
+    if (!schema?.options?.draftAndPublish) {
+        return null;
+    }
+    return {
+        disabled: !canUpdate || activeTab === 'published' || document?.status !== 'modified',
+        label: formatMessage({
+            id: 'content-manager.actions.discard.label',
+            defaultMessage: 'Discard changes'
+        }),
+        icon: /*#__PURE__*/ jsxRuntime.jsx(Icons.Cross, {}),
+        position: [
+            'panel',
+            'table-row'
+        ],
+        variant: 'danger',
+        dialog: {
+            type: 'dialog',
+            title: formatMessage({
+                id: 'app.components.ConfirmDialog.title',
+                defaultMessage: 'Confirmation'
+            }),
+            content: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                direction: "column",
+                gap: 2,
+                children: [
+                    /*#__PURE__*/ jsxRuntime.jsx(Icons.WarningCircle, {
+                        width: "24px",
+                        height: "24px",
+                        fill: "danger600"
+                    }),
+                    /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+                        tag: "p",
+                        variant: "omega",
+                        textAlign: "center",
+                        children: formatMessage({
+                            id: 'content-manager.actions.discard.dialog.body',
+                            defaultMessage: 'Are you sure?'
+                        })
+                    })
+                ]
+            }),
+            loading: isLoading,
+            onConfirm: async ()=>{
+                await discard({
+                    collectionType,
+                    model,
+                    documentId,
+                    params
+                });
+            }
+        }
+    };
+};
+DiscardAction.type = 'discard';
+DiscardAction.position = 'panel';
+const DEFAULT_ACTIONS = [
+    PublishAction,
+    UpdateAction,
+    UnpublishAction,
+    DiscardAction
+];
+
+exports.DEFAULT_ACTIONS = DEFAULT_ACTIONS;
+exports.DocumentActionButton = DocumentActionButton;
+exports.DocumentActions = DocumentActions;
+exports.DocumentActionsMenu = DocumentActionsMenu;
+exports.PublishAction = PublishAction;
+exports.UpdateAction = UpdateAction;
+exports.openPublishConfirmDialog = openPublishConfirmDialog;
+//# sourceMappingURL=DocumentActions.js.map