@strapi/content-releases 5.12.1 → 5.12.2

package/dist/admin/chunks/index-vjWrvGN3.js

@@ -1,1658 +0,0 @@
-'use strict';
-
-var icons = require('@strapi/icons');
-var jsxRuntime = require('react/jsx-runtime');
-var React = require('react');
-var strapiAdmin = require('@strapi/admin/strapi-admin');
-var designSystem = require('@strapi/design-system');
-var formik = require('formik');
-var reactIntl = require('react-intl');
-var strapiAdmin$1 = require('@strapi/content-manager/strapi-admin');
-var symbols = require('@strapi/icons/symbols');
-var reactRouterDom = require('react-router-dom');
-var yup = require('yup');
-var styledComponents = require('styled-components');
-
-function _interopNamespaceDefault(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__*/_interopNamespaceDefault(React);
-var yup__namespace = /*#__PURE__*/_interopNamespaceDefault(yup);
-
-const PERMISSIONS = {
-    main: [
-        {
-            action: 'plugin::content-releases.read',
-            subject: null,
-            id: '',
-            actionParameters: {},
-            properties: {},
-            conditions: []
-        }
-    ],
-    create: [
-        {
-            action: 'plugin::content-releases.create',
-            subject: null,
-            id: '',
-            actionParameters: {},
-            properties: {},
-            conditions: []
-        }
-    ],
-    update: [
-        {
-            action: 'plugin::content-releases.update',
-            subject: null,
-            id: '',
-            actionParameters: {},
-            properties: {},
-            conditions: []
-        }
-    ],
-    delete: [
-        {
-            action: 'plugin::content-releases.delete',
-            subject: null,
-            id: '',
-            actionParameters: {},
-            properties: {},
-            conditions: []
-        }
-    ],
-    createAction: [
-        {
-            action: 'plugin::content-releases.create-action',
-            subject: null,
-            id: '',
-            actionParameters: {},
-            properties: {},
-            conditions: []
-        }
-    ],
-    deleteAction: [
-        {
-            action: 'plugin::content-releases.delete-action',
-            subject: null,
-            id: '',
-            actionParameters: {},
-            properties: {},
-            conditions: []
-        }
-    ],
-    publish: [
-        {
-            action: 'plugin::content-releases.publish',
-            subject: null,
-            id: '',
-            actionParameters: {},
-            properties: {},
-            conditions: []
-        }
-    ]
-};
-
-// TODO: move this into the admin code & expose an improved version of enhanceEndpoints or a new function
-const extendInvalidatesTags = (endpoint, extraTags)=>{
-    if (!endpoint) {
-        return;
-    }
-    const originalInvalidatesTags = endpoint.invalidatesTags;
-    const newInvalidatesTags = (result, err, args, meta)=>{
-        const originalTags = typeof originalInvalidatesTags === 'function' ? originalInvalidatesTags(result, err, args, meta) : originalInvalidatesTags;
-        return [
-            ...originalTags ?? [],
-            ...extraTags
-        ];
-    };
-    Object.assign(endpoint, {
-        invalidatesTags: newInvalidatesTags
-    });
-};
-const releaseApi = strapiAdmin.adminApi.enhanceEndpoints({
-    addTagTypes: [
-        'Release',
-        'ReleaseAction',
-        'EntriesInRelease',
-        'ReleaseSettings',
-        'Document'
-    ],
-    endpoints: {
-        updateDocument (endpoint) {
-            extendInvalidatesTags(endpoint, [
-                {
-                    type: 'Release',
-                    id: 'LIST'
-                },
-                {
-                    type: 'ReleaseAction',
-                    id: 'LIST'
-                }
-            ]);
-        },
-        deleteDocument (endpoint) {
-            extendInvalidatesTags(endpoint, [
-                {
-                    type: 'Release',
-                    id: 'LIST'
-                },
-                {
-                    type: 'ReleaseAction',
-                    id: 'LIST'
-                }
-            ]);
-        },
-        deleteManyDocuments (endpoint) {
-            extendInvalidatesTags(endpoint, [
-                {
-                    type: 'Release',
-                    id: 'LIST'
-                },
-                {
-                    type: 'ReleaseAction',
-                    id: 'LIST'
-                }
-            ]);
-        },
-        discardDocument (endpoint) {
-            extendInvalidatesTags(endpoint, [
-                {
-                    type: 'Release',
-                    id: 'LIST'
-                },
-                {
-                    type: 'ReleaseAction',
-                    id: 'LIST'
-                }
-            ]);
-        },
-        createWorkflow (endpoint) {
-            extendInvalidatesTags(endpoint, [
-                {
-                    type: 'Release',
-                    id: 'LIST'
-                },
-                {
-                    type: 'ReleaseAction',
-                    id: 'LIST'
-                }
-            ]);
-        },
-        updateWorkflow (endpoint) {
-            extendInvalidatesTags(endpoint, [
-                {
-                    type: 'Release',
-                    id: 'LIST'
-                },
-                {
-                    type: 'ReleaseAction',
-                    id: 'LIST'
-                }
-            ]);
-        },
-        deleteWorkflow (endpoint) {
-            extendInvalidatesTags(endpoint, [
-                {
-                    type: 'Release',
-                    id: 'LIST'
-                },
-                {
-                    type: 'ReleaseAction',
-                    id: 'LIST'
-                }
-            ]);
-        }
-    }
-}).injectEndpoints({
-    endpoints: (build)=>{
-        return {
-            getReleasesForEntry: build.query({
-                query (params) {
-                    return {
-                        url: '/content-releases/getByDocumentAttached',
-                        method: 'GET',
-                        config: {
-                            params
-                        }
-                    };
-                },
-                providesTags: (result)=>result ? [
-                        ...result.data.map(({ id })=>({
-                                type: 'Release',
-                                id
-                            })),
-                        {
-                            type: 'Release',
-                            id: 'LIST'
-                        }
-                    ] : []
-            }),
-            getReleases: build.query({
-                query ({ page, pageSize, filters } = {
-                    page: 1,
-                    pageSize: 16,
-                    filters: {
-                        releasedAt: {
-                            $notNull: false
-                        }
-                    }
-                }) {
-                    return {
-                        url: '/content-releases',
-                        method: 'GET',
-                        config: {
-                            params: {
-                                page: page || 1,
-                                pageSize: pageSize || 16,
-                                filters: filters || {
-                                    releasedAt: {
-                                        $notNull: false
-                                    }
-                                }
-                            }
-                        }
-                    };
-                },
-                transformResponse (response, meta, arg) {
-                    const releasedAtValue = arg?.filters?.releasedAt?.$notNull;
-                    const isActiveDoneTab = releasedAtValue === 'true';
-                    const newResponse = {
-                        ...response,
-                        meta: {
-                            ...response.meta,
-                            activeTab: isActiveDoneTab ? 'done' : 'pending'
-                        }
-                    };
-                    return newResponse;
-                },
-                providesTags: (result)=>result ? [
-                        ...result.data.map(({ id })=>({
-                                type: 'Release',
-                                id
-                            })),
-                        {
-                            type: 'Release',
-                            id: 'LIST'
-                        }
-                    ] : [
-                        {
-                            type: 'Release',
-                            id: 'LIST'
-                        }
-                    ]
-            }),
-            getRelease: build.query({
-                query ({ id }) {
-                    return {
-                        url: `/content-releases/${id}`,
-                        method: 'GET'
-                    };
-                },
-                providesTags: (result, error, arg)=>[
-                        {
-                            type: 'Release',
-                            id: 'LIST'
-                        },
-                        {
-                            type: 'Release',
-                            id: arg.id
-                        }
-                    ]
-            }),
-            getReleaseActions: build.query({
-                query ({ releaseId, ...params }) {
-                    return {
-                        url: `/content-releases/${releaseId}/actions`,
-                        method: 'GET',
-                        config: {
-                            params
-                        }
-                    };
-                },
-                providesTags: [
-                    {
-                        type: 'ReleaseAction',
-                        id: 'LIST'
-                    }
-                ]
-            }),
-            createRelease: build.mutation({
-                query (data) {
-                    return {
-                        url: '/content-releases',
-                        method: 'POST',
-                        data
-                    };
-                },
-                invalidatesTags: [
-                    {
-                        type: 'Release',
-                        id: 'LIST'
-                    }
-                ]
-            }),
-            updateRelease: build.mutation({
-                query ({ id, ...data }) {
-                    return {
-                        url: `/content-releases/${id}`,
-                        method: 'PUT',
-                        data
-                    };
-                },
-                invalidatesTags: (result, error, arg)=>[
-                        {
-                            type: 'Release',
-                            id: arg.id
-                        }
-                    ]
-            }),
-            createReleaseAction: build.mutation({
-                query ({ body, params }) {
-                    return {
-                        url: `/content-releases/${params.releaseId}/actions`,
-                        method: 'POST',
-                        data: body
-                    };
-                },
-                invalidatesTags: [
-                    {
-                        type: 'Release',
-                        id: 'LIST'
-                    },
-                    {
-                        type: 'ReleaseAction',
-                        id: 'LIST'
-                    }
-                ]
-            }),
-            createManyReleaseActions: build.mutation({
-                query ({ body, params }) {
-                    return {
-                        url: `/content-releases/${params.releaseId}/actions/bulk`,
-                        method: 'POST',
-                        data: body
-                    };
-                },
-                invalidatesTags: [
-                    {
-                        type: 'Release',
-                        id: 'LIST'
-                    },
-                    {
-                        type: 'ReleaseAction',
-                        id: 'LIST'
-                    },
-                    {
-                        type: 'EntriesInRelease'
-                    }
-                ]
-            }),
-            updateReleaseAction: build.mutation({
-                query ({ body, params }) {
-                    return {
-                        url: `/content-releases/${params.releaseId}/actions/${params.actionId}`,
-                        method: 'PUT',
-                        data: body
-                    };
-                },
-                invalidatesTags: (res, error, arg)=>[
-                        {
-                            type: 'ReleaseAction',
-                            id: 'LIST'
-                        },
-                        {
-                            type: 'Release',
-                            id: 'LIST'
-                        },
-                        {
-                            type: 'Release',
-                            id: arg.params.releaseId
-                        }
-                    ],
-                async onQueryStarted ({ body, params, query, actionPath }, { dispatch, queryFulfilled }) {
-                    // We need to mimic the same params received by the getReleaseActions query
-                    const paramsWithoutActionId = {
-                        releaseId: params.releaseId,
-                        ...query
-                    };
-                    const patchResult = dispatch(releaseApi.util.updateQueryData('getReleaseActions', paramsWithoutActionId, (draft)=>{
-                        const [key, index] = actionPath;
-                        const action = draft.data[key][index];
-                        if (action) {
-                            action.type = body.type;
-                        }
-                    }));
-                    try {
-                        await queryFulfilled;
-                    } catch  {
-                        patchResult.undo();
-                    }
-                }
-            }),
-            deleteReleaseAction: build.mutation({
-                query ({ params }) {
-                    return {
-                        url: `/content-releases/${params.releaseId}/actions/${params.actionId}`,
-                        method: 'DELETE'
-                    };
-                },
-                invalidatesTags: (result, error, arg)=>[
-                        {
-                            type: 'Release',
-                            id: 'LIST'
-                        },
-                        {
-                            type: 'Release',
-                            id: arg.params.releaseId
-                        },
-                        {
-                            type: 'ReleaseAction',
-                            id: 'LIST'
-                        },
-                        {
-                            type: 'EntriesInRelease'
-                        }
-                    ]
-            }),
-            publishRelease: build.mutation({
-                query ({ id }) {
-                    return {
-                        url: `/content-releases/${id}/publish`,
-                        method: 'POST'
-                    };
-                },
-                invalidatesTags: (result, error, arg)=>[
-                        {
-                            type: 'Release',
-                            id: arg.id
-                        },
-                        {
-                            type: 'Document',
-                            id: `ALL_LIST`
-                        }
-                    ]
-            }),
-            deleteRelease: build.mutation({
-                query ({ id }) {
-                    return {
-                        url: `/content-releases/${id}`,
-                        method: 'DELETE'
-                    };
-                },
-                invalidatesTags: ()=>[
-                        {
-                            type: 'Release',
-                            id: 'LIST'
-                        },
-                        {
-                            type: 'EntriesInRelease'
-                        }
-                    ]
-            }),
-            getMappedEntriesInReleases: build.query({
-                query (params) {
-                    return {
-                        url: '/content-releases/mapEntriesToReleases',
-                        method: 'GET',
-                        config: {
-                            params
-                        }
-                    };
-                },
-                transformResponse (response) {
-                    return response.data;
-                },
-                providesTags: [
-                    {
-                        type: 'EntriesInRelease'
-                    }
-                ]
-            }),
-            getReleaseSettings: build.query({
-                query: ()=>'/content-releases/settings',
-                providesTags: [
-                    {
-                        type: 'ReleaseSettings'
-                    }
-                ]
-            }),
-            updateReleaseSettings: build.mutation({
-                query (data) {
-                    return {
-                        url: '/content-releases/settings',
-                        method: 'PUT',
-                        data
-                    };
-                },
-                invalidatesTags: [
-                    {
-                        type: 'ReleaseSettings'
-                    }
-                ]
-            })
-        };
-    }
-});
-const { useGetReleasesQuery, useGetReleasesForEntryQuery, useGetReleaseQuery, useGetReleaseActionsQuery, useCreateReleaseMutation, useCreateReleaseActionMutation, useCreateManyReleaseActionsMutation, useUpdateReleaseMutation, useUpdateReleaseActionMutation, usePublishReleaseMutation, useDeleteReleaseActionMutation, useDeleteReleaseMutation, useGetMappedEntriesInReleasesQuery, useGetReleaseSettingsQuery, useUpdateReleaseSettingsMutation } = releaseApi;
-
-const getBorderLeftRadiusValue = (actionType)=>{
-    return actionType === 'publish' ? 1 : 0;
-};
-const getBorderRightRadiusValue = (actionType)=>{
-    return actionType === 'publish' ? 0 : 1;
-};
-const FieldWrapper = styledComponents.styled(designSystem.Field.Root)`
-  border-top-left-radius: ${({ $actionType, theme })=>theme.spaces[getBorderLeftRadiusValue($actionType)]};
-  border-bottom-left-radius: ${({ $actionType, theme })=>theme.spaces[getBorderLeftRadiusValue($actionType)]};
-  border-top-right-radius: ${({ $actionType, theme })=>theme.spaces[getBorderRightRadiusValue($actionType)]};
-  border-bottom-right-radius: ${({ $actionType, theme })=>theme.spaces[getBorderRightRadiusValue($actionType)]};
-
-  > label {
-    color: inherit;
-    padding: ${({ theme })=>`${theme.spaces[2]} ${theme.spaces[3]}`};
-    text-align: center;
-    vertical-align: middle;
-    text-transform: capitalize;
-  }
-
-  &[data-checked='true'] {
-    color: ${({ theme, $actionType })=>$actionType === 'publish' ? theme.colors.primary700 : theme.colors.danger600};
-    background-color: ${({ theme, $actionType })=>$actionType === 'publish' ? theme.colors.primary100 : theme.colors.danger100};
-    border-color: ${({ theme, $actionType })=>$actionType === 'publish' ? theme.colors.primary700 : theme.colors.danger600};
-  }
-
-  &[data-checked='false'] {
-    border-left: ${({ $actionType })=>$actionType === 'unpublish' && 'none'};
-    border-right: ${({ $actionType })=>$actionType === 'publish' && 'none'};
-  }
-
-  &[data-checked='false'][data-disabled='false']:hover {
-    color: ${({ theme })=>theme.colors.neutral700};
-    background-color: ${({ theme })=>theme.colors.neutral100};
-    border-color: ${({ theme })=>theme.colors.neutral200};
-
-    & > label {
-      cursor: pointer;
-    }
-  }
-
-  &[data-disabled='true'] {
-    color: ${({ theme })=>theme.colors.neutral600};
-    background-color: ${({ theme })=>theme.colors.neutral150};
-    border-color: ${({ theme })=>theme.colors.neutral300};
-  }
-`;
-const ActionOption = ({ selected, actionType, handleChange, name, disabled = false })=>{
-    return /*#__PURE__*/ jsxRuntime.jsx(FieldWrapper, {
-        $actionType: actionType,
-        background: "primary0",
-        borderColor: "neutral200",
-        color: selected === actionType ? 'primary600' : 'neutral600',
-        position: "relative",
-        cursor: "pointer",
-        "data-checked": selected === actionType,
-        "data-disabled": disabled && selected !== actionType,
-        children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Field.Label, {
-            children: [
-                /*#__PURE__*/ jsxRuntime.jsx(designSystem.VisuallyHidden, {
-                    children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Field.Input, {
-                        type: "radio",
-                        name: name,
-                        checked: selected === actionType,
-                        onChange: handleChange,
-                        value: actionType,
-                        disabled: disabled
-                    })
-                }),
-                actionType
-            ]
-        })
-    });
-};
-const ReleaseActionOptions = ({ selected, handleChange, name, disabled = false })=>{
-    return /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
-        children: [
-            /*#__PURE__*/ jsxRuntime.jsx(ActionOption, {
-                actionType: "publish",
-                selected: selected,
-                handleChange: handleChange,
-                name: name,
-                disabled: disabled
-            }),
-            /*#__PURE__*/ jsxRuntime.jsx(ActionOption, {
-                actionType: "unpublish",
-                selected: selected,
-                handleChange: handleChange,
-                name: name,
-                disabled: disabled
-            })
-        ]
-    });
-};
-
-/* -------------------------------------------------------------------------------------------------
- * AddActionToReleaseModal
- * -----------------------------------------------------------------------------------------------*/ const RELEASE_ACTION_FORM_SCHEMA = yup__namespace.object().shape({
-    type: yup__namespace.string().oneOf([
-        'publish',
-        'unpublish'
-    ]).required(),
-    releaseId: yup__namespace.string().required()
-});
-const INITIAL_VALUES = {
-    type: 'publish',
-    releaseId: ''
-};
-const NoReleases = ()=>{
-    const { formatMessage } = reactIntl.useIntl();
-    return /*#__PURE__*/ jsxRuntime.jsx(designSystem.EmptyStateLayout, {
-        icon: /*#__PURE__*/ jsxRuntime.jsx(symbols.EmptyDocuments, {
-            width: "16rem"
-        }),
-        content: formatMessage({
-            id: 'content-releases.content-manager-edit-view.add-to-release.no-releases-message',
-            defaultMessage: 'No available releases. Open the list of releases and create a new one from there.'
-        }),
-        action: /*#__PURE__*/ jsxRuntime.jsx(designSystem.LinkButton, {
-            to: {
-                pathname: '/plugins/content-releases'
-            },
-            tag: reactRouterDom.Link,
-            variant: "secondary",
-            children: formatMessage({
-                id: 'content-releases.content-manager-edit-view.add-to-release.redirect-button',
-                defaultMessage: 'Open the list of releases'
-            })
-        }),
-        shadow: "none"
-    });
-};
-const AddActionToReleaseModal = ({ contentType, documentId, onInputChange, values })=>{
-    const { formatMessage } = reactIntl.useIntl();
-    const [{ query }] = strapiAdmin.useQueryParams();
-    const locale = query.plugins?.i18n?.locale;
-    // Get all 'pending' releases that do not have the entry attached
-    const response = useGetReleasesForEntryQuery({
-        contentType,
-        entryDocumentId: documentId,
-        hasEntryAttached: false,
-        locale
-    });
-    const releases = response.data?.data;
-    if (releases?.length === 0) {
-        return /*#__PURE__*/ jsxRuntime.jsx(NoReleases, {});
-    }
-    return /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
-        direction: "column",
-        alignItems: "stretch",
-        gap: 2,
-        children: [
-            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
-                paddingBottom: 6,
-                children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Field.Root, {
-                    required: true,
-                    children: [
-                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Field.Label, {
-                            children: formatMessage({
-                                id: 'content-releases.content-manager-edit-view.add-to-release.select-label',
-                                defaultMessage: 'Select a release'
-                            })
-                        }),
-                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.SingleSelect, {
-                            required: true,
-                            placeholder: formatMessage({
-                                id: 'content-releases.content-manager-edit-view.add-to-release.select-placeholder',
-                                defaultMessage: 'Select'
-                            }),
-                            name: "releaseId",
-                            onChange: (value)=>onInputChange('releaseId', value),
-                            value: values.releaseId,
-                            children: releases?.map((release)=>/*#__PURE__*/ jsxRuntime.jsx(designSystem.SingleSelectOption, {
-                                    value: release.id,
-                                    children: release.name
-                                }, release.id))
-                        })
-                    ]
-                })
-            }),
-            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Field.Label, {
-                children: formatMessage({
-                    id: 'content-releases.content-manager-edit-view.add-to-release.action-type-label',
-                    defaultMessage: 'What do you want to do with this entry?'
-                })
-            }),
-            /*#__PURE__*/ jsxRuntime.jsx(ReleaseActionOptions, {
-                selected: values.type,
-                handleChange: (e)=>onInputChange('type', e.target.value),
-                name: "type"
-            })
-        ]
-    });
-};
-/* -------------------------------------------------------------------------------------------------
- * ReleaseActionModalForm
- * -----------------------------------------------------------------------------------------------*/ const ReleaseActionModalForm = ({ documentId, document, model, collectionType })=>{
-    const { formatMessage } = reactIntl.useIntl();
-    const { allowedActions } = strapiAdmin.useRBAC(PERMISSIONS);
-    const { canCreateAction } = allowedActions;
-    const [createReleaseAction, { isLoading }] = useCreateReleaseActionMutation();
-    const { toggleNotification } = strapiAdmin.useNotification();
-    const { formatAPIError } = strapiAdmin.useAPIErrorHandler();
-    const [{ query }] = strapiAdmin.useQueryParams();
-    const locale = query.plugins?.i18n?.locale;
-    const handleSubmit = async (e, onClose)=>{
-        try {
-            await formik$1.handleSubmit(e);
-            onClose();
-        } catch (error) {
-            if (strapiAdmin.isFetchError(error)) {
-                // Handle axios error
-                toggleNotification({
-                    type: 'danger',
-                    message: formatAPIError(error)
-                });
-            } else {
-                // Handle generic error
-                toggleNotification({
-                    type: 'danger',
-                    message: formatMessage({
-                        id: 'notification.error',
-                        defaultMessage: 'An error occurred'
-                    })
-                });
-            }
-        }
-    };
-    const formik$1 = formik.useFormik({
-        initialValues: INITIAL_VALUES,
-        validationSchema: RELEASE_ACTION_FORM_SCHEMA,
-        onSubmit: async (values)=>{
-            if (collectionType === 'collection-types' && !documentId) {
-                throw new Error('Document id is required');
-            }
-            const response = await createReleaseAction({
-                body: {
-                    type: values.type,
-                    contentType: model,
-                    entryDocumentId: documentId,
-                    locale
-                },
-                params: {
-                    releaseId: values.releaseId
-                }
-            });
-            if ('data' in response) {
-                // Handle success
-                toggleNotification({
-                    type: 'success',
-                    message: formatMessage({
-                        id: 'content-releases.content-manager-edit-view.add-to-release.notification.success',
-                        defaultMessage: 'Entry added to release'
-                    })
-                });
-                return;
-            }
-            if ('error' in response) {
-                throw response.error;
-            }
-        }
-    });
-    const { edit: { options } } = strapiAdmin$1.unstable_useDocumentLayout(model);
-    // Project is not EE or contentType does not have draftAndPublish enabled
-    if (!window.strapi.isEE || !options?.draftAndPublish || !canCreateAction) {
-        return null;
-    }
-    if (collectionType === 'collection-types' && (!documentId || documentId === 'create')) {
-        return null;
-    }
-    return {
-        label: formatMessage({
-            id: 'content-releases.content-manager-edit-view.add-to-release',
-            defaultMessage: 'Add to release'
-        }),
-        icon: /*#__PURE__*/ jsxRuntime.jsx(icons.PaperPlane, {}),
-        // Entry is creating so we don't want to allow adding it to a release
-        disabled: !document,
-        position: [
-            'panel',
-            'table-row'
-        ],
-        dialog: {
-            type: 'modal',
-            title: formatMessage({
-                id: 'content-releases.content-manager-edit-view.add-to-release',
-                defaultMessage: 'Add to release'
-            }),
-            content: /*#__PURE__*/ jsxRuntime.jsx(AddActionToReleaseModal, {
-                contentType: model,
-                documentId: documentId,
-                onInputChange: formik$1.setFieldValue,
-                values: formik$1.values
-            }),
-            footer: ({ onClose })=>/*#__PURE__*/ jsxRuntime.jsxs(designSystem.Modal.Footer, {
-                    children: [
-                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
-                            onClick: onClose,
-                            variant: "tertiary",
-                            name: "cancel",
-                            children: formatMessage({
-                                id: 'content-releases.content-manager-edit-view.add-to-release.cancel-button',
-                                defaultMessage: 'Cancel'
-                            })
-                        }),
-                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
-                            type: "submit",
-                            // @ts-expect-error - formik ReactEvent types don't match button onClick types as they expect a MouseEvent
-                            onClick: (e)=>handleSubmit(e, onClose),
-                            disabled: !formik$1.values.releaseId,
-                            loading: isLoading,
-                            children: formatMessage({
-                                id: 'content-releases.content-manager-edit-view.add-to-release.continue-button',
-                                defaultMessage: 'Continue'
-                            })
-                        })
-                    ]
-                })
-        }
-    };
-};
-
-const getContentPermissions = (subject)=>{
-    const permissions = {
-        publish: [
-            {
-                action: 'plugin::content-manager.explorer.publish',
-                subject,
-                id: '',
-                actionParameters: {},
-                properties: {},
-                conditions: []
-            }
-        ]
-    };
-    return permissions;
-};
-const ReleaseAction = ({ documents, model })=>{
-    const { formatMessage } = reactIntl.useIntl();
-    const { toggleNotification } = strapiAdmin.useNotification();
-    const { formatAPIError } = strapiAdmin.useAPIErrorHandler();
-    const [{ query }] = strapiAdmin.useQueryParams();
-    const contentPermissions = getContentPermissions(model);
-    const { allowedActions: { canPublish } } = strapiAdmin.useRBAC(contentPermissions);
-    const { allowedActions: { canCreate } } = strapiAdmin.useRBAC(PERMISSIONS);
-    // Get all the releases not published
-    const response = useGetReleasesQuery();
-    const releases = response.data?.data;
-    const [createManyReleaseActions, { isLoading }] = useCreateManyReleaseActionsMutation();
-    const documentIds = documents.map((doc)=>doc.documentId);
-    const handleSubmit = async (values)=>{
-        const locale = query.plugins?.i18n?.locale;
-        const releaseActionEntries = documentIds.map((entryDocumentId)=>({
-                type: values.type,
-                contentType: model,
-                entryDocumentId,
-                locale
-            }));
-        const response = await createManyReleaseActions({
-            body: releaseActionEntries,
-            params: {
-                releaseId: values.releaseId
-            }
-        });
-        if ('data' in response) {
-            // Handle success
-            const notificationMessage = formatMessage({
-                id: 'content-releases.content-manager-list-view.add-to-release.notification.success.message',
-                defaultMessage: '{entriesAlreadyInRelease} out of {totalEntries} entries were already in the release.'
-            }, {
-                entriesAlreadyInRelease: response.data.meta.entriesAlreadyInRelease,
-                totalEntries: response.data.meta.totalEntries
-            });
-            const notification = {
-                type: 'success',
-                title: formatMessage({
-                    id: 'content-releases.content-manager-list-view.add-to-release.notification.success.title',
-                    defaultMessage: 'Successfully added to release.'
-                }, {
-                    entriesAlreadyInRelease: response.data.meta.entriesAlreadyInRelease,
-                    totalEntries: response.data.meta.totalEntries
-                }),
-                message: response.data.meta.entriesAlreadyInRelease ? notificationMessage : ''
-            };
-            toggleNotification(notification);
-            return true;
-        }
-        if ('error' in response) {
-            if (strapiAdmin.isFetchError(response.error)) {
-                // Handle fetch error
-                toggleNotification({
-                    type: 'warning',
-                    message: formatAPIError(response.error)
-                });
-            } else {
-                // Handle generic error
-                toggleNotification({
-                    type: 'warning',
-                    message: formatMessage({
-                        id: 'notification.error',
-                        defaultMessage: 'An error occurred'
-                    })
-                });
-            }
-        }
-    };
-    if (!canCreate || !canPublish) return null;
-    return {
-        actionType: 'release',
-        variant: 'tertiary',
-        label: formatMessage({
-            id: 'content-manager-list-view.add-to-release',
-            defaultMessage: 'Add to Release'
-        }),
-        dialog: {
-            type: 'modal',
-            title: formatMessage({
-                id: 'content-manager-list-view.add-to-release',
-                defaultMessage: 'Add to Release'
-            }),
-            content: ({ onClose })=>{
-                return /*#__PURE__*/ jsxRuntime.jsx(formik.Formik, {
-                    onSubmit: async (values)=>{
-                        const data = await handleSubmit(values);
-                        if (data) {
-                            return onClose();
-                        }
-                    },
-                    validationSchema: RELEASE_ACTION_FORM_SCHEMA,
-                    initialValues: INITIAL_VALUES,
-                    children: ({ values, setFieldValue })=>/*#__PURE__*/ jsxRuntime.jsxs(formik.Form, {
-                            children: [
-                                releases?.length === 0 ? /*#__PURE__*/ jsxRuntime.jsx(NoReleases, {}) : /*#__PURE__*/ jsxRuntime.jsx(designSystem.Modal.Body, {
-                                    children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
-                                        direction: "column",
-                                        alignItems: "stretch",
-                                        gap: 2,
-                                        children: [
-                                            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
-                                                paddingBottom: 6,
-                                                children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Field.Root, {
-                                                    required: true,
-                                                    children: [
-                                                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Field.Label, {
-                                                            children: formatMessage({
-                                                                id: 'content-releases.content-manager-list-view.add-to-release.select-label',
-                                                                defaultMessage: 'Select a release'
-                                                            })
-                                                        }),
-                                                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.SingleSelect, {
-                                                            placeholder: formatMessage({
-                                                                id: 'content-releases.content-manager-list-view.add-to-release.select-placeholder',
-                                                                defaultMessage: 'Select'
-                                                            }),
-                                                            onChange: (value)=>setFieldValue('releaseId', value),
-                                                            value: values.releaseId,
-                                                            children: releases?.map((release)=>/*#__PURE__*/ jsxRuntime.jsx(designSystem.SingleSelectOption, {
-                                                                    value: release.id,
-                                                                    children: release.name
-                                                                }, release.id))
-                                                        })
-                                                    ]
-                                                })
-                                            }),
-                                            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Field.Label, {
-                                                children: formatMessage({
-                                                    id: 'content-releases.content-manager-list-view.add-to-release.action-type-label',
-                                                    defaultMessage: 'What do you want to do with these entries?'
-                                                })
-                                            }),
-                                            /*#__PURE__*/ jsxRuntime.jsx(ReleaseActionOptions, {
-                                                selected: values.type,
-                                                handleChange: (e)=>setFieldValue('type', e.target.value),
-                                                name: "type"
-                                            })
-                                        ]
-                                    })
-                                }),
-                                /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Modal.Footer, {
-                                    children: [
-                                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
-                                            onClick: onClose,
-                                            variant: "tertiary",
-                                            name: "cancel",
-                                            children: formatMessage({
-                                                id: 'content-releases.content-manager-list-view.add-to-release.cancel-button',
-                                                defaultMessage: 'Cancel'
-                                            })
-                                        }),
-                                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
-                                            type: "submit",
-                                            disabled: !values.releaseId,
-                                            loading: isLoading,
-                                            children: formatMessage({
-                                                id: 'content-releases.content-manager-list-view.add-to-release.continue-button',
-                                                defaultMessage: 'Continue'
-                                            })
-                                        })
-                                    ]
-                                })
-                            ]
-                        })
-                });
-            }
-        }
-    };
-};
-
-const useReleasesList = (contentTypeUid, documentId)=>{
-    const listViewData = strapiAdmin.useTable('ListView', (state)=>state.rows);
-    const documentIds = listViewData.map((entry)=>entry.documentId);
-    const [{ query }] = strapiAdmin.useQueryParams();
-    const locale = query?.plugins?.i18n?.locale || undefined;
-    const response = useGetMappedEntriesInReleasesQuery({
-        contentTypeUid,
-        documentIds,
-        locale
-    }, {
-        skip: !documentIds || !contentTypeUid || documentIds.length === 0
-    });
-    const mappedEntriesInReleases = response.data || {};
-    return mappedEntriesInReleases?.[documentId] || [];
-};
-const addColumnToTableHook = ({ displayedHeaders, layout })=>{
-    const { options } = layout;
-    if (!options?.draftAndPublish) {
-        return {
-            displayedHeaders,
-            layout
-        };
-    }
-    return {
-        displayedHeaders: [
-            ...displayedHeaders,
-            {
-                searchable: false,
-                sortable: false,
-                name: 'releases',
-                label: {
-                    id: 'content-releases.content-manager.list-view.releases.header',
-                    defaultMessage: 'To be released in'
-                },
-                cellFormatter: (props, _, { model })=>/*#__PURE__*/ jsxRuntime.jsx(ReleaseListCell, {
-                        ...props,
-                        model: model
-                    })
-            }
-        ],
-        layout
-    };
-};
-const ReleaseListCell = ({ documentId, model })=>{
-    const releases = useReleasesList(model, documentId);
-    const { formatMessage } = reactIntl.useIntl();
-    return /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Popover.Root, {
-        children: [
-            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Popover.Trigger, {
-                children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
-                    variant: "ghost",
-                    onClick: (e)=>e.stopPropagation(),
-                    // TODO: find a way in the DS to define the widht and height of the icon
-                    endIcon: releases.length > 0 ? /*#__PURE__*/ jsxRuntime.jsx(icons.CaretDown, {
-                        width: "1.2rem",
-                        height: "1.2rem"
-                    }) : null,
-                    children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
-                        style: {
-                            maxWidth: '252px',
-                            cursor: 'pointer'
-                        },
-                        textColor: "neutral800",
-                        fontWeight: "regular",
-                        children: releases.length > 0 ? formatMessage({
-                            id: 'content-releases.content-manager.list-view.releases-number',
-                            defaultMessage: '{number} {number, plural, one {release} other {releases}}'
-                        }, {
-                            number: releases.length
-                        }) : '-'
-                    })
-                })
-            }),
-            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Popover.Content, {
-                children: /*#__PURE__*/ jsxRuntime.jsx("ul", {
-                    children: releases.map(({ id, name })=>/*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
-                            padding: 3,
-                            tag: "li",
-                            children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Link, {
-                                href: `/admin/plugins/content-releases/${id}`,
-                                isExternal: false,
-                                children: name
-                            })
-                        }, id))
-                })
-            })
-        ]
-    });
-};
-
-const getTimezoneOffset = (timezone, date)=>{
-    try {
-        const offsetPart = new Intl.DateTimeFormat('en', {
-            timeZone: timezone,
-            timeZoneName: 'longOffset'
-        }).formatToParts(date).find((part)=>part.type === 'timeZoneName');
-        const offset = offsetPart ? offsetPart.value : '';
-        // We want to show time based on UTC, not GMT so we swap that.
-        let utcOffset = offset.replace('GMT', 'UTC');
-        // For perfect UTC (UTC+0:00) we only get the string UTC, So we need to append the 0's.
-        if (!utcOffset.includes('+') && !utcOffset.includes('-')) {
-            utcOffset = `${utcOffset}+00:00`;
-        }
-        return utcOffset;
-    } catch (error) {
-        // When timezone is invalid we catch the error and return empty to don't break the app
-        return '';
-    }
-};
-const getTimezones = (selectedDate)=>{
-    const timezoneList = Intl.supportedValuesOf('timeZone').map((timezone)=>{
-        // Timezone will be in the format GMT${OFFSET} where offset could be nothing,
-        // a four digit string e.g. +05:00 or -08:00
-        const utcOffset = getTimezoneOffset(timezone, selectedDate);
-        // Offset and timezone are concatenated with '&', so to split and save the required timezone in DB
-        return {
-            offset: utcOffset,
-            value: `${utcOffset}&${timezone}`
-        };
-    });
-    const systemTimezone = timezoneList.find((timezone)=>timezone.value.split('&')[1] === Intl.DateTimeFormat().resolvedOptions().timeZone);
-    return {
-        timezoneList,
-        systemTimezone
-    };
-};
-
-const StyledMenuItem = styledComponents.styled(designSystem.Menu.Item)`
-  &:hover {
-    background: ${({ theme, $variant = 'neutral' })=>theme.colors[`${$variant}100`]};
-
-    svg {
-      fill: ${({ theme, $variant = 'neutral' })=>theme.colors[`${$variant}600`]};
-    }
-
-    a {
-      color: ${({ theme })=>theme.colors.neutral800};
-    }
-  }
-
-  svg {
-    color: ${({ theme, $variant = 'neutral' })=>theme.colors[`${$variant}500`]};
-  }
-
-  span {
-    color: ${({ theme, $variant = 'neutral' })=>theme.colors[`${$variant}800`]};
-  }
-
-  span,
-  a {
-    width: 100%;
-  }
-`;
-const DeleteReleaseActionItem = ({ releaseId, actionId })=>{
-    const { formatMessage } = reactIntl.useIntl();
-    const { toggleNotification } = strapiAdmin.useNotification();
-    const { formatAPIError } = strapiAdmin.useAPIErrorHandler();
-    const [deleteReleaseAction] = useDeleteReleaseActionMutation();
-    const { allowedActions: { canDeleteAction } } = strapiAdmin.useRBAC(PERMISSIONS);
-    const handleDeleteAction = async ()=>{
-        const response = await deleteReleaseAction({
-            params: {
-                releaseId,
-                actionId
-            }
-        });
-        if ('data' in response) {
-            // Handle success
-            toggleNotification({
-                type: 'success',
-                message: formatMessage({
-                    id: 'content-releases.content-manager-edit-view.remove-from-release.notification.success',
-                    defaultMessage: 'Entry removed from release'
-                })
-            });
-            return;
-        }
-        if ('error' in response) {
-            if (strapiAdmin.isFetchError(response.error)) {
-                // Handle fetch error
-                toggleNotification({
-                    type: 'danger',
-                    message: formatAPIError(response.error)
-                });
-            } else {
-                // Handle generic error
-                toggleNotification({
-                    type: 'danger',
-                    message: formatMessage({
-                        id: 'notification.error',
-                        defaultMessage: 'An error occurred'
-                    })
-                });
-            }
-        }
-    };
-    if (!canDeleteAction) {
-        return null;
-    }
-    return /*#__PURE__*/ jsxRuntime.jsx(StyledMenuItem, {
-        $variant: "danger",
-        onSelect: handleDeleteAction,
-        children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
-            gap: 2,
-            children: [
-                /*#__PURE__*/ jsxRuntime.jsx(icons.Cross, {
-                    width: "1.6rem",
-                    height: "1.6rem"
-                }),
-                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
-                    textColor: "danger600",
-                    variant: "omega",
-                    children: formatMessage({
-                        id: 'content-releases.content-manager-edit-view.remove-from-release',
-                        defaultMessage: 'Remove from release'
-                    })
-                })
-            ]
-        })
-    });
-};
-const ReleaseActionEntryLinkItem = ({ contentTypeUid, documentId, locale })=>{
-    const { formatMessage } = reactIntl.useIntl();
-    const userPermissions = strapiAdmin.useAuth('ReleaseActionEntryLinkItem', (state)=>state.permissions);
-    // Confirm user has permissions to access the entry for the given locale
-    const canUpdateEntryForLocale = React__namespace.useMemo(()=>{
-        const updatePermissions = userPermissions.find((permission)=>permission.subject === contentTypeUid && permission.action === 'plugin::content-manager.explorer.update');
-        if (!updatePermissions) {
-            return false;
-        }
-        return Boolean(!locale || updatePermissions.properties?.locales?.includes(locale));
-    }, [
-        contentTypeUid,
-        locale,
-        userPermissions
-    ]);
-    const { allowedActions: { canUpdate: canUpdateContentType } } = strapiAdmin.useRBAC({
-        updateContentType: [
-            {
-                action: 'plugin::content-manager.explorer.update',
-                subject: contentTypeUid
-            }
-        ]
-    });
-    if (!canUpdateContentType || !canUpdateEntryForLocale) {
-        return null;
-    }
-    return /*#__PURE__*/ jsxRuntime.jsx(StyledMenuItem, {
-        /* @ts-expect-error inference isn't working in DS */ tag: reactRouterDom.NavLink,
-        isLink: true,
-        to: {
-            pathname: `/content-manager/collection-types/${contentTypeUid}/${documentId}`,
-            search: locale && `?plugins[i18n][locale]=${locale}`
-        },
-        children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
-            gap: 2,
-            children: [
-                /*#__PURE__*/ jsxRuntime.jsx(icons.Pencil, {
-                    width: "1.6rem",
-                    height: "1.6rem"
-                }),
-                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
-                    variant: "omega",
-                    children: formatMessage({
-                        id: 'content-releases.content-manager-edit-view.edit-entry',
-                        defaultMessage: 'Edit entry'
-                    })
-                })
-            ]
-        })
-    });
-};
-const EditReleaseItem = ({ releaseId })=>{
-    const { formatMessage } = reactIntl.useIntl();
-    return /* @ts-expect-error inference isn't working in DS */ /*#__PURE__*/ jsxRuntime.jsx(StyledMenuItem, {
-        tag: reactRouterDom.NavLink,
-        isLink: true,
-        to: `/plugins/content-releases/${releaseId}`,
-        children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
-            gap: 2,
-            children: [
-                /*#__PURE__*/ jsxRuntime.jsx(icons.Pencil, {
-                    width: "1.6rem",
-                    height: "1.6rem"
-                }),
-                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
-                    textColor: "neutral800",
-                    variant: "omega",
-                    children: formatMessage({
-                        id: 'content-releases.content-manager-edit-view.edit-release',
-                        defaultMessage: 'Edit release'
-                    })
-                })
-            ]
-        })
-    });
-};
-const Root = ({ children })=>{
-    const { formatMessage } = reactIntl.useIntl();
-    const { allowedActions } = strapiAdmin.useRBAC(PERMISSIONS);
-    return(// A user can access the dropdown if they have permissions to delete a release-action OR update a release
-    allowedActions.canDeleteAction || allowedActions.canUpdate ? /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Menu.Root, {
-        children: [
-            /*#__PURE__*/ jsxRuntime.jsx(StyledMoreButton, {
-                variant: "tertiary",
-                endIcon: null,
-                paddingLeft: "7px",
-                paddingRight: "7px",
-                children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.AccessibleIcon, {
-                    label: formatMessage({
-                        id: 'content-releases.content-manager-edit-view.release-action-menu',
-                        defaultMessage: 'Release action options'
-                    }),
-                    children: /*#__PURE__*/ jsxRuntime.jsx(icons.More, {})
-                })
-            }),
-            /*#__PURE__*/ jsxRuntime.jsx(designSystem.Menu.Content, {
-                top: 1,
-                popoverPlacement: "bottom-end",
-                children: children
-            })
-        ]
-    }) : null);
-};
-const StyledMoreButton = styledComponents.styled(designSystem.Menu.Trigger)`
-  & > span {
-    display: flex;
-  }
-`;
-const ReleaseActionMenu = {
-    Root,
-    EditReleaseItem,
-    DeleteReleaseActionItem,
-    ReleaseActionEntryLinkItem
-};
-
-const Panel = ({ model, document, documentId, collectionType })=>{
-    const [{ query }] = strapiAdmin.useQueryParams();
-    const locale = query.plugins?.i18n?.locale;
-    const { edit: { options } } = strapiAdmin$1.unstable_useDocumentLayout(model);
-    const { formatMessage, formatDate, formatTime } = reactIntl.useIntl();
-    const { allowedActions } = strapiAdmin.useRBAC(PERMISSIONS);
-    const { canRead, canDeleteAction } = allowedActions;
-    const response = useGetReleasesForEntryQuery({
-        contentType: model,
-        entryDocumentId: documentId,
-        locale,
-        hasEntryAttached: true
-    }, {
-        skip: !document
-    });
-    const releases = response.data?.data;
-    const getReleaseColorVariant = (actionType, shade)=>{
-        if (actionType === 'unpublish') {
-            return `secondary${shade}`;
-        }
-        return `success${shade}`;
-    };
-    // Project is not EE or contentType does not have draftAndPublish enabled
-    if (!window.strapi.isEE || !options?.draftAndPublish || !canRead) {
-        return null;
-    }
-    if (collectionType === 'collection-types' && (!documentId || documentId === 'create')) {
-        return null;
-    }
-    if (!releases || releases.length === 0) {
-        return null;
-    }
-    return {
-        title: formatMessage({
-            id: 'content-releases.plugin.name',
-            defaultMessage: 'Releases'
-        }),
-        content: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
-            direction: "column",
-            alignItems: "stretch",
-            gap: 3,
-            width: "100%",
-            children: releases?.map((release)=>/*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
-                    direction: "column",
-                    alignItems: "start",
-                    borderWidth: "1px",
-                    borderStyle: "solid",
-                    borderColor: getReleaseColorVariant(release.actions[0].type, '200'),
-                    overflow: "hidden",
-                    hasRadius: true,
-                    children: [
-                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
-                            paddingTop: 3,
-                            paddingBottom: 3,
-                            paddingLeft: 4,
-                            paddingRight: 4,
-                            background: getReleaseColorVariant(release.actions[0].type, '100'),
-                            width: "100%",
-                            children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
-                                fontSize: 1,
-                                variant: "pi",
-                                textColor: getReleaseColorVariant(release.actions[0].type, '600'),
-                                children: formatMessage({
-                                    id: 'content-releases.content-manager-edit-view.list-releases.title',
-                                    defaultMessage: '{isPublish, select, true {Will be published in} other {Will be unpublished in}}'
-                                }, {
-                                    isPublish: release.actions[0].type === 'publish'
-                                })
-                            })
-                        }),
-                        /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
-                            padding: 4,
-                            direction: "column",
-                            gap: 2,
-                            width: "100%",
-                            alignItems: "flex-start",
-                            children: [
-                                /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
-                                    fontSize: 2,
-                                    fontWeight: "bold",
-                                    variant: "omega",
-                                    textColor: "neutral700",
-                                    children: release.name
-                                }),
-                                release.scheduledAt && release.timezone && /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
-                                    variant: "pi",
-                                    textColor: "neutral600",
-                                    children: formatMessage({
-                                        id: 'content-releases.content-manager-edit-view.scheduled.date',
-                                        defaultMessage: '{date} at {time} ({offset})'
-                                    }, {
-                                        date: formatDate(new Date(release.scheduledAt), {
-                                            day: '2-digit',
-                                            month: '2-digit',
-                                            year: 'numeric',
-                                            timeZone: release.timezone
-                                        }),
-                                        time: formatTime(new Date(release.scheduledAt), {
-                                            hourCycle: 'h23',
-                                            timeZone: release.timezone
-                                        }),
-                                        offset: getTimezoneOffset(release.timezone, new Date(release.scheduledAt))
-                                    })
-                                }),
-                                canDeleteAction ? /*#__PURE__*/ jsxRuntime.jsxs(ReleaseActionMenu.Root, {
-                                    hasTriggerBorder: true,
-                                    children: [
-                                        /*#__PURE__*/ jsxRuntime.jsx(ReleaseActionMenu.EditReleaseItem, {
-                                            releaseId: release.id
-                                        }),
-                                        /*#__PURE__*/ jsxRuntime.jsx(ReleaseActionMenu.DeleteReleaseActionItem, {
-                                            releaseId: release.id,
-                                            actionId: release.actions[0].id
-                                        })
-                                    ]
-                                }) : null
-                            ]
-                        })
-                    ]
-                }, release.id))
-        })
-    };
-};
-
-const pluginId = 'content-releases';
-
-const prefixPluginTranslations = (trad, pluginId)=>{
-    return Object.keys(trad).reduce((acc, current)=>{
-        acc[`${pluginId}.${current}`] = trad[current];
-        return acc;
-    }, {});
-};
-
-function __variableDynamicImportRuntime3__(path) {
-  switch (path) {
-    case './translations/en.json': return Promise.resolve().then(function () { return require('./en-BOpqX2t_.js'); });
-    case './translations/uk.json': return Promise.resolve().then(function () { return require('./uk-9T9su-bj.js'); });
-    default: return new Promise(function(resolve, reject) {
-      (typeof queueMicrotask === 'function' ? queueMicrotask : setTimeout)(
-        reject.bind(null, new Error("Unknown variable dynamic import: " + path))
-      );
-    })
-   }
- }
-// eslint-disable-next-line import/no-default-export
-const admin = {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    register (app) {
-        /**
-     * Hook that adds the locale column in the Release Details table
-     * @constant
-     * @type {string}
-     */ app.createHook('ContentReleases/pages/ReleaseDetails/add-locale-in-releases');
-        if (window.strapi.features.isEnabled('cms-content-releases')) {
-            app.addMenuLink({
-                to: `plugins/${pluginId}`,
-                icon: icons.PaperPlane,
-                intlLabel: {
-                    id: `${pluginId}.plugin.name`,
-                    defaultMessage: 'Releases'
-                },
-                Component: ()=>Promise.resolve().then(function () { return require('./App-CJiqPP7-.js'); }).then((mod)=>({
-                            default: mod.App
-                        })),
-                permissions: PERMISSIONS.main,
-                position: 2
-            });
-            // Insert the releases container into the CM's sidebar on the Edit View
-            const contentManagerPluginApis = app.getPlugin('content-manager').apis;
-            if ('addEditViewSidePanel' in contentManagerPluginApis && typeof contentManagerPluginApis.addEditViewSidePanel === 'function') {
-                contentManagerPluginApis.addEditViewSidePanel([
-                    Panel
-                ]);
-            }
-            // Insert the "add to release" action into the CM's Edit View
-            if ('addDocumentAction' in contentManagerPluginApis && typeof contentManagerPluginApis.addDocumentAction === 'function') {
-                contentManagerPluginApis.addDocumentAction((actions)=>{
-                    const indexOfDeleteAction = actions.findIndex((action)=>action.type === 'unpublish');
-                    actions.splice(indexOfDeleteAction, 0, ReleaseActionModalForm);
-                    return actions;
-                });
-            }
-            app.addSettingsLink('global', {
-                id: pluginId,
-                to: 'releases',
-                intlLabel: {
-                    id: `${pluginId}.plugin.name`,
-                    defaultMessage: 'Releases'
-                },
-                permissions: [],
-                async Component () {
-                    const { ProtectedReleasesSettingsPage } = await Promise.resolve().then(function () { return require('./ReleasesSettingsPage-KRcoI1bC.js'); });
-                    return {
-                        default: ProtectedReleasesSettingsPage
-                    };
-                }
-            });
-            if ('addBulkAction' in contentManagerPluginApis && typeof contentManagerPluginApis.addBulkAction === 'function') {
-                contentManagerPluginApis.addBulkAction((actions)=>{
-                    // We want to add this action to just before the delete action all the time
-                    const deleteActionIndex = actions.findIndex((action)=>action.type === 'delete');
-                    actions.splice(deleteActionIndex, 0, ReleaseAction);
-                    return actions;
-                });
-            }
-            // Hook that adds a column into the CM's LV table
-            app.registerHook('Admin/CM/pages/ListView/inject-column-in-table', addColumnToTableHook);
-        } else if (!window.strapi.features.isEnabled('cms-content-releases') && window.strapi?.flags?.promoteEE) {
-            app.addSettingsLink('global', {
-                id: pluginId,
-                to: '/plugins/purchase-content-releases',
-                intlLabel: {
-                    id: `${pluginId}.plugin.name`,
-                    defaultMessage: 'Releases'
-                },
-                permissions: [],
-                async Component () {
-                    const { PurchaseContentReleases } = await Promise.resolve().then(function () { return require('./PurchaseContentReleases-Z9uEPb5b.js'); });
-                    return {
-                        default: PurchaseContentReleases
-                    };
-                },
-                licenseOnly: true
-            });
-        }
-    },
-    async registerTrads ({ locales }) {
-        const importedTrads = await Promise.all(locales.map((locale)=>{
-            return __variableDynamicImportRuntime3__(`./translations/${locale}.json`).then(({ default: data })=>{
-                return {
-                    data: prefixPluginTranslations(data, 'content-releases'),
-                    locale
-                };
-            }).catch(()=>{
-                return {
-                    data: {},
-                    locale
-                };
-            });
-        }));
-        return Promise.resolve(importedTrads);
-    }
-};
-
-exports.PERMISSIONS = PERMISSIONS;
-exports.ReleaseActionMenu = ReleaseActionMenu;
-exports.ReleaseActionOptions = ReleaseActionOptions;
-exports.admin = admin;
-exports.getTimezoneOffset = getTimezoneOffset;
-exports.getTimezones = getTimezones;
-exports.pluginId = pluginId;
-exports.releaseApi = releaseApi;
-exports.useCreateReleaseMutation = useCreateReleaseMutation;
-exports.useDeleteReleaseMutation = useDeleteReleaseMutation;
-exports.useGetReleaseActionsQuery = useGetReleaseActionsQuery;
-exports.useGetReleaseQuery = useGetReleaseQuery;
-exports.useGetReleaseSettingsQuery = useGetReleaseSettingsQuery;
-exports.useGetReleasesQuery = useGetReleasesQuery;
-exports.usePublishReleaseMutation = usePublishReleaseMutation;
-exports.useUpdateReleaseActionMutation = useUpdateReleaseActionMutation;
-exports.useUpdateReleaseMutation = useUpdateReleaseMutation;
-exports.useUpdateReleaseSettingsMutation = useUpdateReleaseSettingsMutation;
-//# sourceMappingURL=index-vjWrvGN3.js.map