@contentful/field-editor-shared 2.12.2 → 2.13.0

package/dist/esm/ReleaseEntityStatusBadge/ReleaseEntityStatusPopover.js

@@ -1,5 +1,5 @@
 import React, { useCallback, useRef, useState } from 'react';
-import { Badge, Flex, Popover, Skeleton } from '@contentful/f36-components';
+import { Badge, Flex, Popover } from '@contentful/f36-components';
 import { CaretDownIcon } from '@contentful/f36-icons';
 import tokens from '@contentful/f36-tokens';
 import { cx, css } from 'emotion';
@@ -136,7 +136,7 @@ const determineBadgeStatus = (localesStatusMap, activeLocales)=>{
             };
     }
 };
-export function ReleaseEntityStatusPopover({ releaseLocalesStatusMap, activeLocales, isLoading = false }) {
+export function ReleaseEntityStatusPopover({ releaseStatusMap, activeLocales }) {
     const [isOpen, setIsOpen] = useState(false);
     const timeoutRef = useRef();
     const onMouseEnter = useCallback(()=>{
@@ -151,20 +151,11 @@ export function ReleaseEntityStatusPopover({ releaseLocalesStatusMap, activeLoca
             setIsOpen(false);
         }, 300);
     }, []);
-    const status = determineBadgeStatus(releaseLocalesStatusMap, activeLocales);
+    const status = determineBadgeStatus(releaseStatusMap, activeLocales);
     const ariaLabel = status.secondary ? 'Multiple statuses' : status.primary;
     const wrapperClass = generateDynamicStyles(status);
-    if (isLoading) {
-        return /*#__PURE__*/ React.createElement(Skeleton.Container, {
-            className: styles.skeletonBadge
-        }, /*#__PURE__*/ React.createElement(Skeleton.Image, {
-            testId: `Release-entity-locale-status-badge-skeleton`,
-            width: "65px",
-            height: "20px"
-        }));
-    }
     return /*#__PURE__*/ React.createElement(Popover, {
-        isOpen: releaseLocalesStatusMap && isOpen,
+        isOpen: releaseStatusMap && isOpen,
         onClose: ()=>setIsOpen(false),
         autoFocus: false,
         placement: "bottom-end"
@@ -208,8 +199,8 @@ export function ReleaseEntityStatusPopover({ releaseLocalesStatusMap, activeLoca
         className: styles.popoverContent,
         onMouseEnter: onMouseEnter,
         onMouseLeave: onMouseLeave
-    }, !!releaseLocalesStatusMap && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(ReleaseEntityStatusLocalesList, {
-        statusMap: releaseLocalesStatusMap,
+    }, !!releaseStatusMap && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(ReleaseEntityStatusLocalesList, {
+        statusMap: releaseStatusMap,
         activeLocales: activeLocales
     }))));
 }

package/dist/esm/ReleaseEntityStatusBadge/constants.js

@@ -7,6 +7,13 @@ export const RELEASE_BADGES = {
         hover: tokens.green400,
         icon: tokens.green400
     },
+    published: {
+        label: 'Published',
+        variant: 'positive',
+        default: tokens.green300,
+        hover: tokens.green400,
+        icon: tokens.green400
+    },
     becomesDraft: {
         label: 'Becomes draft',
         variant: 'warning',

package/dist/esm/hooks/useLocalePublishStatus.js

@@ -1,6 +1,7 @@
 import { useMemo } from 'react';
 import * as entityHelpers from '../utils/entityHelpers';
-function getLocalePublishStatusMap(entity, localesApi) {
+import { sanitizeLocales } from '../utils/sanitizeLocales';
+function getLocalePublishStatusMap(entity, locales) {
     const entityStatus = entityHelpers.getEntityStatus(entity.sys);
     if ([
         'archived',
@@ -8,15 +9,11 @@ function getLocalePublishStatusMap(entity, localesApi) {
     ].includes(entityStatus)) {
         return;
     }
-    const statusMap = new Map(localesApi.available.map((localeCode)=>[
-            localeCode,
+    const statusMap = new Map(locales.map((locale)=>[
+            locale.code,
             {
-                status: entityHelpers.getEntityStatus(entity.sys, localeCode),
-                locale: {
-                    code: localeCode,
-                    default: localeCode === localesApi.default,
-                    name: localesApi.names[localeCode]
-                }
+                status: entityHelpers.getEntityStatus(entity.sys, locale.code),
+                locale
             }
         ]));
     return statusMap;
@@ -24,19 +21,7 @@ function getLocalePublishStatusMap(entity, localesApi) {
 export function useLocalePublishStatus(entity, locales) {
     return useMemo(()=>{
         if (entity && locales) {
-            const localesApi = Array.isArray(locales) ? locales.reduce((api, locale)=>{
-                api.available.push(locale.code);
-                api.names[locale.code] = locale.name;
-                if (locale.default) {
-                    api.default = locale.code;
-                }
-                return api;
-            }, {
-                available: [],
-                names: {},
-                default: ''
-            }) : locales;
-            return getLocalePublishStatusMap(entity, localesApi);
+            return getLocalePublishStatusMap(entity, locales ? sanitizeLocales(locales) : []);
         }
         return undefined;
     }, [

package/dist/esm/hooks/useReleaseStatus.js

@@ -0,0 +1,127 @@
+import { useMemo } from 'react';
+import { getEntityStatus } from '../utils/entityHelpers';
+import { sanitizeLocales } from '../utils/sanitizeLocales';
+function createReleaseLocaleStatus(locale, status) {
+    switch(status){
+        case 'published':
+            return {
+                variant: 'positive',
+                status,
+                label: 'Published',
+                locale
+            };
+        case 'willPublish':
+            return {
+                variant: 'positive',
+                status: 'willPublish',
+                label: 'Will publish',
+                locale
+            };
+        case 'becomesDraft':
+            return {
+                variant: 'warning',
+                status: 'becomesDraft',
+                label: 'Becomes draft',
+                locale
+            };
+        case 'remainsDraft':
+            return {
+                variant: 'warning',
+                status: 'remainsDraft',
+                label: 'Remains draft',
+                locale
+            };
+        case 'notInRelease':
+            return {
+                variant: 'secondary',
+                status: 'notInRelease',
+                label: 'Not in release',
+                locale
+            };
+        default:
+            throw new Error(`Unknown release entity status: ${status}`);
+    }
+}
+function getReleaseItemLocaleStatus(releaseItem, locale, previousEntityOnTimeline) {
+    if ('action' in releaseItem) {
+        if (releaseItem.action === 'publish') {
+            return 'willPublish';
+        }
+        if (releaseItem.action === 'unpublish') {
+            const status = previousEntityOnTimeline ? getEntityStatus(previousEntityOnTimeline.sys) : 'draft';
+            return [
+                'published',
+                'changed'
+            ].includes(status) ? 'becomesDraft' : 'remainsDraft';
+        }
+    }
+    const addedLocales = releaseItem.add?.fields['*'] || [];
+    const removedLocales = releaseItem.remove?.fields['*'] || [];
+    if (addedLocales.includes(locale.code)) {
+        return 'willPublish';
+    }
+    if (removedLocales.includes(locale.code)) {
+        const status = previousEntityOnTimeline ? getEntityStatus(previousEntityOnTimeline.sys, locale.code) : 'draft';
+        return [
+            'published',
+            'changed'
+        ].includes(status) ? 'becomesDraft' : 'remainsDraft';
+    }
+    return 'remainsDraft';
+}
+export function useReleaseStatus({ entity, release, locales, previousEntityOnTimeline }) {
+    const sanitizedLocales = useMemo(()=>sanitizeLocales(locales), [
+        locales
+    ]);
+    const releaseStatusMap = useMemo(()=>{
+        if (!entity?.sys || !release || !('schemaVersion' in release.sys) || release.sys.schemaVersion !== 'Release.v2') {
+            return new Map();
+        }
+        const releaseItem = release.entities.items.find((e)=>e.entity.sys.linkType === entity.sys.type && e.entity.sys.id === entity.sys.id);
+        if (!releaseItem) {
+            return new Map(sanitizedLocales.map((locale)=>{
+                if ([
+                    'published',
+                    'changed'
+                ].includes(getEntityStatus(entity.sys, locale.code))) {
+                    return [
+                        locale.code,
+                        createReleaseLocaleStatus(locale, 'published')
+                    ];
+                }
+                return [
+                    locale.code,
+                    createReleaseLocaleStatus(locale, 'notInRelease')
+                ];
+            }));
+        }
+        return new Map(sanitizedLocales.map((locale)=>[
+                locale.code,
+                createReleaseLocaleStatus(locale, getReleaseItemLocaleStatus(releaseItem, locale, previousEntityOnTimeline))
+            ]));
+    }, [
+        entity?.sys,
+        previousEntityOnTimeline,
+        release,
+        sanitizedLocales
+    ]);
+    const releaseAction = useMemo(()=>{
+        if (releaseStatusMap.size === 0) {
+            return undefined;
+        }
+        const releaseArray = Array.from(releaseStatusMap.values());
+        if (releaseArray.find(({ status })=>status === 'willPublish')) {
+            return 'publish';
+        }
+        if (releaseArray.find(({ status })=>status === 'becomesDraft')) {
+            return 'unpublish';
+        }
+        return 'not-in-release';
+    }, [
+        releaseStatusMap
+    ]);
+    return {
+        releaseStatusMap,
+        releaseAction
+    };
+}

package/dist/esm/hooks/{useActiveReleaseLocalesStatuses.spec.js → useReleaseStatus.spec.js}

@@ -1,6 +1,5 @@
 import { renderHook } from '@testing-library/react';
-import { getPreviousReleaseEntity } from '../utils/getPreviousReleaseEntity';
-import { useActiveReleaseLocalesStatuses } from './useActiveReleaseLocalesStatuses';
+import { useReleaseStatus } from './useReleaseStatus';
 const buildEntry = (status, id = 'entry-1')=>({
         sys: {
             id,
@@ -9,7 +8,9 @@ const buildEntry = (status, id = 'entry-1')=>({
                 '*': {
                     'en-US': status
                 }
-            }
+            },
+            version: 3,
+            publishedVersion: status === 'published' ? 2 : undefined
         }
     });
 const buildAsset = (status, id = 'asset-1')=>({
@@ -20,7 +21,9 @@ const buildAsset = (status, id = 'asset-1')=>({
                 '*': {
                     'en-US': status
                 }
-            }
+            },
+            version: 3,
+            publishedVersion: status === 'published' ? 2 : undefined
         }
     });
 const createEntryBasedReleaseEntity = ({ entityId = 'entry-1', action = 'publish', entityType = 'Entry' })=>({
@@ -83,51 +86,38 @@ const createLocaleBasedRelease = ({ entityId, verb, entityType = 'Entry' } = {})
             ]
         }
     });
-jest.mock('../utils/getPreviousReleaseEntity', ()=>({
-        getPreviousReleaseEntity: jest.fn()
-    }));
 const ENTITY_TYPES = [
     'Entry',
     'Asset'
 ];
-describe('useActiveReleaseLocalesStatuses', ()=>{
+describe('useReleaseStatus', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
     });
     ENTITY_TYPES.forEach((entityType)=>{
         const entityId = entityType === 'Entry' ? 'entry-1' : 'asset-1';
         const baseParams = {
-            entityId,
-            entityType,
             locales: [
                 {
                     code: 'en-US'
                 }
-            ],
-            isActiveReleaseLoading: false,
-            releaseVersionMap: new Map(),
-            releases: {
-                items: []
-            }
+            ]
         };
+        function buildEntity(status) {
+            return entityType === 'Entry' ? buildEntry(status) : buildAsset(status);
+        }
         describe(`${entityType} with entry based publishing`, ()=>{
             it('returns Will publish status when active release has publish action', ()=>{
-                getPreviousReleaseEntity.mockReturnValue({
-                    previousReleaseEntity: createEntryBasedReleaseEntity({
-                        entityId,
-                        action: 'unpublish',
-                        entityType
-                    })
-                });
-                const { result } = renderHook(()=>useActiveReleaseLocalesStatuses({
+                const { result } = renderHook(()=>useReleaseStatus({
                         ...baseParams,
-                        activeRelease: createEntryBasedRelease({
+                        previousEntityOnTimeline: buildEntity('draft'),
+                        release: createEntryBasedRelease({
                             entityId,
                             entityType
                         }),
-                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                        entity: buildEntity('published')
                     }));
-                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
                     variant: 'positive',
                     status: 'willPublish',
                     label: 'Will publish',
@@ -137,23 +127,17 @@ describe('useActiveReleaseLocalesStatuses', ()=>{
                 });
             });
             it('returns Becomes draft status when previous version has published locales and active version has unpublish action', ()=>{
-                getPreviousReleaseEntity.mockReturnValue({
-                    previousReleaseEntity: createEntryBasedReleaseEntity({
-                        entityId,
-                        action: 'publish',
-                        entityType
-                    })
-                });
-                const { result } = renderHook(()=>useActiveReleaseLocalesStatuses({
+                const { result } = renderHook(()=>useReleaseStatus({
                         ...baseParams,
-                        activeRelease: createEntryBasedRelease({
+                        previousEntityOnTimeline: buildEntity('published'),
+                        release: createEntryBasedRelease({
                             action: 'unpublish',
                             entityId,
                             entityType
                         }),
-                        currentEntityDraft: entityType === 'Entry' ? buildEntry('published') : buildAsset('published')
+                        entity: buildEntity('draft')
                     }));
-                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
                     variant: 'warning',
                     status: 'becomesDraft',
                     label: 'Becomes draft',
@@ -163,24 +147,18 @@ describe('useActiveReleaseLocalesStatuses', ()=>{
                 });
             });
             it('returns Remains draft status when previous version has draft locales and active version has unpublish action', ()=>{
-                getPreviousReleaseEntity.mockReturnValue({
-                    previousReleaseEntity: createEntryBasedReleaseEntity({
-                        action: 'unpublish',
-                        entityType,
-                        entityId
-                    })
-                });
-                const { result } = renderHook(()=>useActiveReleaseLocalesStatuses({
+                const { result } = renderHook(()=>useReleaseStatus({
                         ...baseParams,
-                        activeRelease: createEntryBasedRelease({
+                        previousEntityOnTimeline: buildEntity('draft'),
+                        release: createEntryBasedRelease({
                             action: 'unpublish',
                             entityId,
                             entityType
                         }),
-                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                        entity: buildEntity('draft')
                     }));
-                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                    variant: 'secondary',
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
+                    variant: 'warning',
                     status: 'remainsDraft',
                     label: 'Remains draft',
                     locale: {
@@ -189,19 +167,16 @@ describe('useActiveReleaseLocalesStatuses', ()=>{
                 });
             });
             it('returns Not in release status when entity is not in the release', ()=>{
-                getPreviousReleaseEntity.mockReturnValue({
-                    previousReleaseEntity: undefined
-                });
-                const { result } = renderHook(()=>useActiveReleaseLocalesStatuses({
+                const { result } = renderHook(()=>useReleaseStatus({
                         ...baseParams,
-                        activeRelease: createEntryBasedRelease({
+                        release: createEntryBasedRelease({
                             entityId: entityType === 'Entry' ? 'entry-2' : 'asset-2',
                             action: 'publish',
                             entityType
                         }),
-                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                        entity: buildEntity('draft')
                     }));
-                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
                     variant: 'secondary',
                     status: 'notInRelease',
                     label: 'Not in release',
@@ -210,25 +185,38 @@ describe('useActiveReleaseLocalesStatuses', ()=>{
                     }
                 });
             });
+            it('returns published when not in release but already published', ()=>{
+                const { result } = renderHook(()=>useReleaseStatus({
+                        ...baseParams,
+                        release: createEntryBasedRelease({
+                            entityId: entityType === 'Entry' ? 'entry-2' : 'asset-2',
+                            action: 'publish',
+                            entityType
+                        }),
+                        entity: buildEntity('published')
+                    }));
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
+                    variant: 'positive',
+                    status: 'published',
+                    label: 'Published',
+                    locale: {
+                        code: 'en-US'
+                    }
+                });
+            });
         });
         describe(`${entityType} with locale based publishing`, ()=>{
             it('returns Will publish status when active release has publish action', ()=>{
-                getPreviousReleaseEntity.mockReturnValue({
-                    previousReleaseEntity: createLocaleBasedReleaseEntity({
-                        entityId,
-                        verb: 'remove',
-                        entityType
-                    })
-                });
-                const { result } = renderHook(()=>useActiveReleaseLocalesStatuses({
+                const { result } = renderHook(()=>useReleaseStatus({
                         ...baseParams,
-                        activeRelease: createLocaleBasedRelease({
+                        previousEntityOnTimeline: buildEntity('draft'),
+                        release: createLocaleBasedRelease({
                             entityId,
                             entityType
                         }),
-                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                        entity: buildEntity('published')
                     }));
-                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
                     variant: 'positive',
                     status: 'willPublish',
                     label: 'Will publish',
@@ -238,23 +226,17 @@ describe('useActiveReleaseLocalesStatuses', ()=>{
                 });
             });
             it('returns Becomes draft status when previous version has published locales and active version has unpublish action', ()=>{
-                getPreviousReleaseEntity.mockReturnValue({
-                    previousReleaseEntity: createLocaleBasedReleaseEntity({
-                        entityId: 'entry-1',
-                        verb: 'add',
-                        entityType
-                    })
-                });
-                const { result } = renderHook(()=>useActiveReleaseLocalesStatuses({
+                const { result } = renderHook(()=>useReleaseStatus({
                         ...baseParams,
-                        activeRelease: createLocaleBasedRelease({
+                        previousEntityOnTimeline: buildEntity('published'),
+                        release: createLocaleBasedRelease({
                             verb: 'remove',
                             entityId,
                             entityType
                         }),
-                        currentEntityDraft: entityType === 'Entry' ? buildEntry('published') : buildAsset('published')
+                        entity: buildEntity('draft')
                     }));
-                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
                     variant: 'warning',
                     status: 'becomesDraft',
                     label: 'Becomes draft',
@@ -264,24 +246,18 @@ describe('useActiveReleaseLocalesStatuses', ()=>{
                 });
             });
             it('returns Remains draft status when previous version has draft locales and active version has unpublish action', ()=>{
-                getPreviousReleaseEntity.mockReturnValue({
-                    previousReleaseEntity: createLocaleBasedReleaseEntity({
-                        verb: 'remove',
-                        entityId,
-                        entityType
-                    })
-                });
-                const { result } = renderHook(()=>useActiveReleaseLocalesStatuses({
+                const { result } = renderHook(()=>useReleaseStatus({
                         ...baseParams,
-                        activeRelease: createLocaleBasedRelease({
+                        previousEntityOnTimeline: buildEntity('draft'),
+                        release: createLocaleBasedRelease({
                             verb: 'remove',
                             entityId,
                             entityType
                         }),
-                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                        entity: buildEntity('draft')
                     }));
-                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
-                    variant: 'secondary',
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
+                    variant: 'warning',
                     status: 'remainsDraft',
                     label: 'Remains draft',
                     locale: {
@@ -289,20 +265,17 @@ describe('useActiveReleaseLocalesStatuses', ()=>{
                     }
                 });
             });
-            it('returns Not in release status when entry is not in the release', ()=>{
-                getPreviousReleaseEntity.mockReturnValue({
-                    previousReleaseEntity: undefined
-                });
-                const { result } = renderHook(()=>useActiveReleaseLocalesStatuses({
+            it('returns Not in release status when entry is in draft state and not in the release', ()=>{
+                const { result } = renderHook(()=>useReleaseStatus({
                         ...baseParams,
-                        activeRelease: createLocaleBasedRelease({
+                        release: createLocaleBasedRelease({
                             entityId: entityType === 'Entry' ? 'entry-2' : 'asset-2',
                             entityType,
                             verb: 'add'
                         }),
-                        currentEntityDraft: entityType === 'Entry' ? buildEntry('draft') : buildAsset('draft')
+                        entity: buildEntity('draft')
                     }));
-                expect(result.current.releaseLocalesStatusMap.get('en-US')).toEqual({
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
                     variant: 'secondary',
                     status: 'notInRelease',
                     label: 'Not in release',
@@ -311,6 +284,25 @@ describe('useActiveReleaseLocalesStatuses', ()=>{
                     }
                 });
             });
+            it('returns published status when entry is in published state and not in the release', ()=>{
+                const { result } = renderHook(()=>useReleaseStatus({
+                        ...baseParams,
+                        release: createLocaleBasedRelease({
+                            entityId: entityType === 'Entry' ? 'entry-2' : 'asset-2',
+                            entityType,
+                            verb: 'add'
+                        }),
+                        entity: buildEntity('published')
+                    }));
+                expect(result.current.releaseStatusMap.get('en-US')).toEqual({
+                    variant: 'positive',
+                    status: 'published',
+                    label: 'Published',
+                    locale: {
+                        code: 'en-US'
+                    }
+                });
+            });
         });
     });
 });

package/dist/esm/index.js

@@ -13,10 +13,9 @@ export { isValidImage } from './utils/isValidImage';
 export { shortenStorageUnit, toLocaleString } from './utils/shortenStorageUnit';
 export * from './types';
 export * from './hooks/useActiveLocales';
-export * from './hooks/useActiveReleaseLocalesStatuses';
+export * from './hooks/useReleaseStatus';
 export * from './hooks/useLocalePublishStatus';
 export * from './LocalePublishingEntityStatusBadge';
 export * from './ReleaseEntityStatusBadge';
 export * from './utils/determineReleaseAction';
 export * from './utils/getEntityReleaseStatus';
-export * from './utils/parseReleaseParameters';

package/dist/esm/utils/sanitizeLocales.js

@@ -0,0 +1,10 @@
+export function sanitizeLocales(locales) {
+    if (Array.isArray(locales)) {
+        return locales;
+    }
+    return locales.available.map((code)=>({
+            code,
+            default: code === locales.default,
+            name: locales.names[code]
+        }));
+}

package/dist/types/ReleaseEntityStatusBadge/ReleaseEntityStatusLocalesList.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
 import type { LocaleProps } from 'contentful-management';
-import { ReleaseLocalesStatusMap } from '../types';
+import { ReleaseStatusMap } from '../types';
 type ReleaseEntityStatusLocalesListProps = {
-    statusMap: ReleaseLocalesStatusMap;
+    statusMap: ReleaseStatusMap;
     activeLocales?: Pick<LocaleProps, 'code'>[];
 };
 export declare function ReleaseEntityStatusLocalesList({ statusMap, activeLocales, }: ReleaseEntityStatusLocalesListProps): React.JSX.Element;

package/dist/types/ReleaseEntityStatusBadge/ReleaseEntityStatusPopover.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 import type { LocaleProps } from 'contentful-management';
-import type { ReleaseLocalesStatusMap } from '../types';
+import type { ReleaseStatusMap } from '../types';
 type ReleaseLocalePublishingPopoverProps = {
-    releaseLocalesStatusMap: ReleaseLocalesStatusMap;
+    releaseStatusMap: ReleaseStatusMap;
     activeLocales: Pick<LocaleProps, 'code'>[];
     isLoading?: boolean;
 };
-export declare function ReleaseEntityStatusPopover({ releaseLocalesStatusMap, activeLocales, isLoading, }: ReleaseLocalePublishingPopoverProps): React.JSX.Element;
+export declare function ReleaseEntityStatusPopover({ releaseStatusMap, activeLocales, }: ReleaseLocalePublishingPopoverProps): React.JSX.Element;
 export {};

package/dist/types/ReleaseEntityStatusBadge/constants.d.ts

@@ -6,6 +6,13 @@ export declare const RELEASE_BADGES: {
         readonly hover: string;
         readonly icon: string;
     };
+    readonly published: {
+        readonly label: "Published";
+        readonly variant: "positive";
+        readonly default: string;
+        readonly hover: string;
+        readonly icon: string;
+    };
     readonly becomesDraft: {
         readonly label: "Becomes draft";
         readonly variant: "warning";

package/dist/types/hooks/useLocalePublishStatus.d.ts

@@ -1,8 +1,10 @@
 import type { LocalesAPI } from '@contentful/app-sdk';
 import type { AssetProps, EntryProps, LocaleProps } from 'contentful-management/types';
+import { type SanitizedLocale } from '../utils/sanitizeLocales';
+export type PublishStatus = 'draft' | 'published' | 'changed';
 export type LocalePublishStatus = {
-    status: 'draft' | 'published' | 'changed';
-    locale: Pick<LocaleProps, 'code' | 'default' | 'name'>;
+    status: PublishStatus;
+    locale: SanitizedLocale;
 };
 export type LocalePublishStatusMap = Map<string, LocalePublishStatus>;
 /**